Funzioni

Una funzione è un blocco modulare e riutilizzabile di istruzioni utilizzato per eseguire una serie di attività correlate, come calcolare e restituire un valore in base agli argomenti forniti alla funzione. Come per tutti i valori non primitivi, le funzioni sono oggetti. Sono oggetti univoci in quanto possono essere chiamati per eseguire il codice, passare dati sotto forma di argomenti e return un valore.

Le funzioni sono considerate oggetti di "prima classe", il che significa che, nonostante il loro comportamento unico, possono essere utilizzate in tutti gli stessi contesti di qualsiasi altro oggetto JavaScript. Ad esempio, una funzione può essere assegnata a una variabile, passata come argomento ad altre funzioni e restituita da altre funzioni.

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

Una funzione definita come proprietà di un oggetto viene di solito chiamata "metodo". Come per le variabili dichiarate utilizzando var, le dichiarazioni delle funzioni effettuate al di fuori di una funzione di inclusione vengono aggiunte all'oggetto globale come metodi.

Dichiarazioni delle funzioni

Una dichiarazione di funzione (chiamata anche "istruzione di funzione" o "definizione funzione") crea una funzione con nome che può essere richiamata altrove nell'ambito contenitore. Le dichiarazioni di funzioni sono composte dalla parola chiave function seguita da un identificatore, un elenco di parametri separati da virgole racchiusi tra parentesi e un'istruzione di blocco chiamata "corpo della funzione". Incontrerai spesso dichiarazioni di funzioni che non terminano con un punto e virgola. Poiché una dichiarazione di funzione è un'istruzione, il punto e virgola finale può essere dedotto da ASI.

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

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

Nell'ambito delle decisioni di progettazione iniziali di JavaScript, le dichiarazioni di funzione sono soggette allo stesso comportamento di sollevamento legacy delle variabili dichiarate con var, il che significa che una dichiarazione di funzione viene issata in cima al suo ambito e può essere richiamata 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."

Al di fuori della modalità rigida, le dichiarazioni di funzione utilizzano il comportamento di scoping precedente di JavaScript, il che significa che l'ambito di una dichiarazione di una funzione è la sua funzione di inclusione più vicina:

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, l'ambito delle dichiarazioni delle funzioni viene limitato al blocco contenitore più vicino, come nel caso delle variabili dichiarate utilizzando let o const:

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

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

Chiamata di funzione

Come nel caso delle variabili, l'identificatore utilizzato quando si dichiara una funzione funge da nome simbolico di un valore. Il riferimento a una funzione solo per 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 chiama) la funzione seguendo il nome della funzione con una coppia corrispondente di parentesi:

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

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

I parametri nella definizione della funzione agiscono come variabili segnaposto per i valori che possono essere trasferiti al corpo della funzione quando la funzione viene chiamata. I valori tra parentesi quando una funzione viene chiamata sono gli "argomenti" (in alcuni casi potrebbero essere utilizzati anche "argomenti" per descrivere sia argomenti che parametri):

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 un valore 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."

Puoi impostare i valori predefiniti dei parametri inizializzandoli nello stesso modo in cui inizializzeresti una variabile: un operatore di assegnazione (=) seguito da un valore. Se in un secondo momento specifichi un argomento per quella funzione, il nuovo valore sostituisce quello 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 funzione non freccia ha accesso anche a un oggetto arguments indicizzato con zero, array simile a un oggetto arguments contenente valori passati come argomenti, indipendentemente dal fatto che la definizione della funzione specifichi i parametri:

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

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

Funzioni variadiche

L'oggetto arguments consente di creare funzioni variadiche di base che accettano 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 variadice è raramente utilizzato nello sviluppo JavaScript moderno. È più comune utilizzare la sintassi dei parametri REST, più moderna e leggibile, che crea un parametro con nome inizializzato come array contenente qualsiasi argomento 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 dei parametri REST funziona come previsto con i parametri della funzione 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`
``