Uma função é um bloco de instruções modular e reutilizável usado para executar um conjunto de tarefas relacionadas, como calcular e retornar um valor com base em argumentos fornecida à função. Assim como acontece com todos os valores não primitivos, são objetos. Eles são objetos exclusivos que podem ser chamados para executar códigos, receber dados na forma de argumentos, e retornar um valor.
As funções são consideradas de "primeira classe" objetos, o que significa que, apesar de seu comportamento único, eles podem ser usados em todos os nos mesmos contextos de qualquer outro objeto JavaScript. Por exemplo, uma função pode ser atribuído a uma variável, passado como argumento para outras funções e por outras funções.
function myFunction() {
console.log( "This is my function." );
};
Uma função definida como uma propriedade de um objeto é
geralmente chamada de "método". Assim como acontece com variáveis declaradas usando var
,
declarações de função feitas fora de uma função de delimitação são adicionadas à
objeto global como métodos.
Declarações de função
Uma declaração de função (também chamada de "declaração de função" ou "definição da função")
cria uma função nomeada que pode ser invocada em outro lugar no escopo que a contém.
As declarações de função consistem na palavra-chave function
seguida por uma
identificador, uma lista de parâmetros separados por vírgula entre parênteses e um
de bloco chamada a
“corpo da função”. Você frequentemente encontrará declarações de função que não
terminar com um ponto e vírgula; porque uma declaração de função é uma instrução, à direita
pontos e vírgulas podem ser inferidos por ASI.
function myFunction() {
console.log( "This is my function." );
};
myFunction();
> "This is my function."
Como uma retenção das primeiras decisões de design do JavaScript, as declarações de função
estejam sujeitas à mesma elevação legada;
comportamento como variáveis declaradas com var
, o que significa que uma declaração de função
é elevado para o topo de seu escopo e pode ser chamado antes da declaração como um
resultado, independentemente de esse escopo ser regido ou não pelo modo estrito:
"use strict";
{
myFunction();
function myFunction() {
console.log( "This is my function." );
};
}
> "This is my function."
Fora do modo estrito, função declarações usam o escopo legado do JavaScript comportamento, ou seja, o escopo de uma declaração de função é o delimitador mais próximo função:
function myFunction() {
function myNestedFunction() {
console.log( "This is my nested function." );
}
myNestedFunction();
};
myFunction();
> "This is my nested function."
myNestedFunction();
>Uncaught ReferenceError: myNestedFunction is not defined
No modo estrito, as declarações de função
têm o escopo definido para o bloco delimitador mais próximo, como acontece com as variáveis declaradas usando
let
ou const
:
"use strict";
{
function myFunction() {
console.log( "This is my function." );
};
}
myFunction();
> Uncaught ReferenceError: myFunction is not defined
Chamadas de função
Assim como acontece com as variáveis, o identificador usado ao declarar uma função age como um nome simbólico para um valor. Referenciar uma função apenas pelo identificador retorna somente o objeto de função e não executa a função que contém:
function myFunction() {
console.log( "This is my function." );
};
myFunction;
> myFunction() {
console.log( "This is my function." );
}
Para executar o código dentro do corpo da função, chame (ou invoque) a função seguindo o nome da função com um par correspondente de parênteses:
function myFunction() {
console.log( "My function has been executed." );
}
myFunction();
> "My function has been executed."
Os parâmetros na definição da função atuam como variáveis de espaço reservado para valores que podem ser transmitidos para o corpo da função quando ela é chamada. Os valores entre parênteses quando uma função é chamada são "argumentos" (embora podem aparecer "argumentos" usados para descrever argumentos e parâmetros em alguns documentação):
function myFunction( myParameter ) {
console.log( `The value is: ${ myParameter }.` );
};
myFunction( "this string" );
> "The value is: this string."
Se um argumento esperado for omitido, o parâmetro resultante conterá um
Valor undefined
, porque o parâmetro é declarado ao corpo da função, mas
não inicializado com um valor:
function myFunction( myParameter ) {
console.log( `The value is: ${ myParameter }.` );
};
myFunction();
> "The value is: undefined."
Você pode definir valores de parâmetros padrão inicializando-os da mesma forma que faria
inicializar uma variável: um operador de atribuição (=
) seguido por um valor. Se você
depois especificar um argumento para essa função, esse novo valor substitui o
valor padrão:
function myFunction( myParameter = "omitted" ) {
console.log( `The value is: ${ myParameter }.` );
};
myFunction( "this string" );
> "The value is: this string."
myFunction();
> "The value is: omitted."
O corpo de uma não seta
também tem acesso a um objeto com índice zero,
objeto arguments
semelhante à matriz
que contenham valores passados como argumentos, independentemente de a função
especifica os parâmetros:
function myFunction() {
console.log( arguments );
};
myFunction( 3, true, "My string" );
> Arguments { 0: 3, 1: true, 2: "My string", … }
Funções varárias
O objeto arguments
permite criar funções variáveis básicas, que podem
aceitam um número variável de argumentos:
function myFunction() {
let result = "";
for (let i = 0; i < arguments.length; i++) {
result += arguments[i] + " - ";
}
console.log( result );
};
myFunction( "My first string", "My second string", "my third string" );\
> "My first string - My second string - my third string - "
No entanto, essa abordagem às funções variadas raramente é usada em JavaScript moderno no desenvolvimento de software. É mais comum usar os modelos mais modernos sintaxe do parâmetro REST, que cria um parâmetro nomeado inicializado como uma matriz contendo quaisquer argumentos além das explicitamente especificadas:
function myFunction( mySeparator, ...myStrings ) {
console.log( myStrings.join( mySeparator ) );
};
myFunction( " - ", "My first string", "My second string", "my third string" );
> "My first string - My second string - my third string"
Ao contrário da vinculação parameter
, a sintaxe do parâmetro REST funciona conforme esperado com os parâmetros da arrow function:
function myOuterFunction() {
let myInnerArrowFunction = ( ...myParams ) => {
console.log( myParams[ 0 ] );
}
myInnerArrowFunction( true );
};
myOuterFunction( false );
> true
let myArrowFunction = ( ...myParams ) => {
console.log( myParams[ 0 ] );
};
myArrowFunction( true );
> true`
``