Funções em Java Script

Uma função é um conjunto de declarações, ou bloco de códigos, que executam uma tarefa específica. Neste post veja funções em Java Script.

Em JavaScript as funções podem ser tratadas como qualquer outra variável. Por exemplo, uma função pode ser passada como argumento para outras funções (high-order functions), ser retornada por outra função ou ser atribuída como um valor à uma variável.

A esse conceito damos o nome de “função de primeira classe” ou “cidadão de primeira linha”.

Parâmetros e retorno em funções são opcionais.

Existem dois tipos de funções: funções desenvolvidas pelo usuário e funções pré-definidas da linguagem.

Em Javascript uma função é identificada pela palavra-chave function, nome e um par de parênteses “( )” que delimitam zero ou mais parâmetros. Todas as declarações dentro de uma função estão dentro de um par de chaves “{ }”.

Sintaxe: function nomeDaFunção ( ) { declarações… }

A declaração return é utilizada dentro do corpo de uma função para retornar um valor ou para cancelar imediatamente a execução da função:

 function aoQuadrado(valor) {   
     return valor * valor
}

Funções sem Retorno

Funções sem retorno são ideais para criar pequenos trechos de script que serão repetidos várias vezes durante o código:

function oi () {   
    document.write ("Bem-vindo ao site www.criandobits.com.br!")
}

As funções sem retorno “return” retorna o tipo undefined.

Funções com Retorno

Funções com retorno são criadas da mesma forma das funções sem retorno. Sua diferença principal é que esta função devolve um resultado para o script.

Por exemplo, podemos gerar um resultado de uma soma e devolver este resultado para o script:

 function somar () {   
     return 1+2;
}
     document.write ("A soma de 1 + 2 é " + somar() );

Se for passado uma quantidade de parâmetros que exceda a capacidade da função, esta processará apenas a quantidade determinada na sua construção sem retornar qualquer erro:

 function somar (a, b, c) {   
     console.log(a + b + c)
   }
   
   somar(1, 2, 3, 5, 8)

No caso acima apenas os números 1, 2 e 3 serão somados, o resto será ignorado.

É possível tratar os parâmetros para definir valores padrão caso nenhum valor seja definido na chamada da função:

 function somar (a, b, c = 1)
   {
     console.log(a + b + c)
   }
   
   somar(1, 2)  
   /*
   No caso acima os números 1 e 2 serão somados com o valor 1, pois este foi definido para o terceiro parâmetro. 
   Caso não seja passado nenhum valor para o primeiro parâmetro, será retornado NaN (Not a Number - não é um número). */   

 function soma (a, b, c) {
   a = a || 1
   b = b || 1
   c = c || 1
   
   return a + b + c
 }
 
 console.log(soma()) // Retorna 3, pois nenhum valor para os parâmetros foi informado
 console.log(soma(2, 3)) // Retorna 6, pois não foi informado o valor para o 3º parâmetro
 console.log(soma(0, 0, 0)) // Retorna 3, pois 0 é considerado false e é assumido os valores padrão
 
 function soma2(a, b, c) {
  //Verifica se o valor de a é estritamente diferente (!==) de undefined. Se for, assume o valor padrão 1
   a = a !== undefined ? a : 1 
   
   //Verifica se existe o índice 1 no objeto arguments (segundo parâmetro da função). Se existir pega esse valor, senão assume o valor padrão 1
   b = 1 in arguments ? b : 1
   
   //Verifica se existe o parâmetro c é um número. Se não for, assume o valor padrão 1 (método mais recomendado)
   c = isNaN(c) ? 1: c 

Também é possível armazenarmos funções em arrays:

 const array = [function(a, b) { return a + b}, func2, func3] 

Podemos armazenar funções em atributos de objetos:

 const obj = {} 
 obj.falar = function () { return 'Oi!' }
 console.log(obj.falar())

Também podemos passar funções como parâmetros para outras funções:

 function run(fun) { // passamos a função como parâmetro
    fun() // chamamos a função 'fun()' de dentro da função 'run()'
 }
   
 run(function () { console.log('Executando a função...') }) // definimos o conteúdo da função 'run()'

Uma função também pode retornar outra função:

 function soma(a, b) {
    return function (c) { // retorna a função com o terceiro parâmetro...
       console.log(a + b + c) // mostra a soma todos os parâmetros passados
    }  
 }
 
 /* passamos os parâmetros a e b para a função 'soma' e o terceiro parâmetro c 
  passamos abrindo o segundo parênteses:  
 soma(1, 2)(5)
 
  // também é possível fazer desta forma:
  const tresMais = soma(1, 2)
  tresMais(5)

Os parâmetros de uma função também podem ser variáveis:

 function soma() { // função sem parâmetros
    let soma = 0;
    for(i in arguments) { // caso sejam passados parâmetros, serão armazenados no objeto do tipo array arguments
       soma += arguments[i] // soma os valores passados
    }
    return soma
 }
 
 console.log(soma(1, 3, 5))   
 
  // Se forem passados strings, estes serão concatenados:
  console.log(soma('a', 'b', 'c'))  
  
  //O retorno acima será 0abc, já que 0 será retornado pela função juntamente com os parâmetros passados.

Funções Auto-invocáveis (IIFE) em Java Script

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits