Funções

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`
``