Funzioni

Una funzione è un blocco modulare e riutilizzabile di istruzioni utilizzato per eseguire un insieme ad attività correlate, come il calcolo e la restituzione di un valore in base ad argomenti fornito alla funzione. Come per tutti i valori non primitivi, sono oggetti. Sono oggetti unici in quanto possono essere chiamati eseguire il codice, passare i dati sotto forma di argomenti e restituisce un valore.

Le funzioni sono considerate "first class" di oggetti, il che significa che, a prescindere dal loro comportamento, possono essere utilizzati in tutte gli stessi contesti di qualsiasi altro oggetto JavaScript. Ad esempio, una funzione può essere assegnati a una variabile, passati come argomento ad altre funzioni e restituiti da altre funzioni.

function myFunction() {
   console.log( "This is my function." );
};

Una funzione definita come proprietà di un oggetto è di solito chiamato "metodo". Come per le variabili dichiarate utilizzando var, le dichiarazioni di funzione effettuate al di fuori di una funzione che lo include vengono aggiunte al oggetto globale come metodi.

Dichiarazioni di funzione

Una dichiarazione di funzione (chiamata anche "istruzione di funzione" o "definizione di funzione") crea una funzione con nome che può essere richiamata altrove nell'ambito che lo contiene. Le dichiarazioni di funzione sono costituite dalla parola chiave function seguita da una , un elenco di parametri separati da virgole racchiusi tra parentesi e un l'istruzione di blocco denominata "body della funzione". Incontrerai spesso dichiarazioni di funzione che non terminare con un punto e virgola; perché una dichiarazione di funzione è un'istruzione, I punti e virgola possono essere dedotti da ASI.

function myFunction() {
   console.log( "This is my function." );
};

myFunction();
> "This is my function."

Come trattenuta dalle prime decisioni di progettazione di JavaScript, le dichiarazioni di funzione sono soggette allo stesso processo di sollevamento precedente. comportamento come variabili dichiarate con var, il che significa che una dichiarazione di funzione viene portato all'inizio del suo ambito e può essere chiamato prima della dichiarazione come risultato, indipendentemente dal fatto che l'ambito sia regolato o meno dalla modalità rigida:

"use strict";
{
    myFunction();
    function myFunction() {
        console.log( "This is my function." );
    };
}
> "This is my function."

Fuori dalla modalità standard, funzione dichiarazioni utilizzano l'ambito precedente di JavaScript di una funzione, il che significa che una dichiarazione di funzione è limitata all'ambito :

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

In modalità con restrizioni, le dichiarazioni di funzione hanno un ambito basato sul blocco che contiene più vicino, come per le variabili dichiarate utilizzando let o const:

"use strict";
{
    function myFunction() {
        console.log( "This is my function." );
    };
}

myFunction();
> Uncaught ReferenceError: myFunction is not defined

Chiamate di funzione

Come per le variabili, l'identificatore utilizzato per dichiarare una funzione agisce come nome simbolico di un valore. Il riferimento a una funzione tramite solo l'identificatore restituisce solo l'oggetto della funzione e non esegue la funzione che contiene:

function myFunction() {
   console.log( "This is my function." );
};

myFunction;
> myFunction() {
   console.log( "This is my function." );
}

Per eseguire il codice all'interno del corpo della funzione, chiama (o richiama) la funzione seguendo il nome della funzione con una coppia di parentesi corrispondenti:

function myFunction() {
    console.log( "My function has been executed." );
}

myFunction();
> "My function has been executed."

I parametri nella definizione della funzione agiscono da variabili segnaposto per valori che possono essere passati nel corpo della funzione quando questa viene chiamata. I valori tra parentesi quando viene chiamata una funzione sono "argomenti" (sebbene potresti vedere "argomenti" utilizzato per descrivere sia argomenti che parametri in alcune documentazione):

function myFunction( myParameter ) {
   console.log( `The value is: ${ myParameter }.` );
};

myFunction( "this string" );
> "The value is: this string."

Se un argomento previsto viene omesso, il parametro risultante contiene una undefined, perché il parametro viene dichiarato nel corpo della funzione, ma non inizializzato con un valore:

function myFunction( myParameter ) {
   console.log( `The value is: ${ myParameter }.` );
};

myFunction();
> "The value is: undefined."

Per impostare i valori predefiniti dei parametri, puoi inizializzarli nello stesso modo in cui inizializza una variabile: un operatore di assegnazione (=) seguito da un valore. Se successivamente specifichi un argomento per quella funzione, il nuovo valore sostituisce valore predefinito:

function myFunction( myParameter = "omitted" ) {
   console.log( `The value is: ${ myParameter }.` );
};

myFunction( "this string" );
> "The value is: this string."

myFunction();
> "The value is: omitted."

Il corpo di una non freccia ha anche accesso a una funzione Oggetto arguments di tipo array contenente qualsiasi valore passato come argomento, indipendentemente dal fatto che la funzione definizione specifica i parametri:

function myFunction() {
   console.log( arguments );
};

myFunction( 3, true, "My string" );
> Arguments { 0: 3, 1: true, 2: "My string", … }

Funzioni variabili

L'oggetto arguments consente di creare funzioni variabili di base, che possono accetta un numero variabile di argomenti:

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

Tuttavia, questo approccio alle funzioni variadi è raramente utilizzato nel moderno JavaScript. sviluppo del prodotto. Di solito si usano i modelli più moderni e leggibili sintassi del parametro REST, che crea un parametro denominato inizializzato come array contenente argomenti oltre a quelli esplicitamente specificati:

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"

A differenza dell'associazione parameter, la sintassi del parametro REST funziona come previsto con i parametri delle funzioni freccia:

function myOuterFunction() {
    let myInnerArrowFunction = ( ...myParams ) => {
        console.log( myParams[ 0 ] );
    }
    myInnerArrowFunction( true );
};

myOuterFunction( false );
> true

let myArrowFunction = ( ...myParams ) => {
    console.log( myParams[ 0 ] );
};

myArrowFunction( true );
> true`
``