Fonctions

Une fonction est un bloc d'instructions modulaire et réutilisable, qui permet d'effectuer un ensemble de tâches associées, comme calculer et renvoyer une valeur en fonction des arguments fournis à la fonction. Comme pour toutes les valeurs non primitives, les fonctions sont des objets. Ce sont des objets uniques en ce sens qu'ils peuvent être appelés pour exécuter du code, recevoir des données transmises sous la forme d'arguments et return une valeur.

Les fonctions sont considérées comme des objets de première classe, ce qui signifie que malgré leur comportement unique, elles peuvent être utilisées dans les mêmes contextes que tout autre objet JavaScript. Par exemple, une fonction peut être attribuée à une variable, transmise en tant qu'argument à d'autres fonctions et renvoyée par d'autres fonctions.

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

Une fonction définie en tant que propriété d'un objet est généralement appelée "méthode". Comme pour les variables déclarées à l'aide de var, les déclarations de fonction effectuées en dehors d'une fonction englobante sont ajoutées à l'objet global en tant que méthodes.

Déclarations de fonctions

Une déclaration de fonction (également appelée "instruction de fonction" ou "définition de fonction") crée une fonction nommée qui peut être appelée ailleurs dans son champ d'application. Les déclarations de fonction se composent du mot clé function suivi d'un identifiant, d'une liste de paramètres séparés par une virgule placée entre parenthèses et d'une instruction de bloc appelée "corps de la fonction". Vous rencontrerez fréquemment des déclarations de fonction qui ne se terminent pas par un point-virgule. Étant donné qu'une déclaration de fonction est une instruction, les points-virgules de fin peuvent être déduits par ASI.

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

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

En réponse aux premières décisions de conception de JavaScript, les déclarations de fonction sont soumises au même comportement de hissage hérité que les variables déclarées avec var, ce qui signifie qu'une déclaration de fonction est hissée en haut de son champ d'application et peut être appelée avant la déclaration en conséquence, que ce champ d'application soit régi ou non par le mode strict:

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

En dehors du mode strict, les déclarations de fonction utilisent l'ancien comportement de scoping de JavaScript, ce qui signifie qu'une déclaration de fonction est limitée à la fonction englobante la plus proche:

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

En mode strict, les déclarations de fonction sont limitées au bloc englobant le plus proche, comme pour les variables déclarées à l'aide de let ou const:

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

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

Appel de fonction

Comme pour les variables, l'identifiant utilisé lors de la déclaration d'une fonction agit comme un nom symbolique pour une valeur. Le référencement d'une fonction par identifiant ne renvoie que l'objet fonction et n'exécute pas la fonction qu'il contient:

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

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

Pour exécuter le code dans le corps de la fonction, appelez (ou appelez) la fonction en suivant le nom de la fonction avec une paire de parenthèses correspondante:

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

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

Les paramètres de la définition de la fonction agissent comme des variables d'espace réservé pour les valeurs pouvant être transmises dans le corps de la fonction lorsque celle-ci est appelée. Lorsqu'une fonction est appelée, les valeurs entre parenthèses sont des "arguments" (bien que des "arguments" puissent être utilisés pour décrire à la fois les arguments et les paramètres dans certaines documentations):

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

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

Si un argument attendu est omis, le paramètre obtenu contient une valeur undefined, car il est déclaré dans le corps de la fonction, mais n'est pas initialisé avec une valeur:

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

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

Vous pouvez définir des valeurs de paramètres par défaut en les initialisant de la même manière que vous initialisez une variable: un opérateur d'affectation (=) suivi d'une valeur. Si vous spécifiez ultérieurement un argument pour cette fonction, cette nouvelle valeur remplace la valeur par défaut:

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

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

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

Le corps d'une fonction non-flèche a également accès à un objet arguments de type tableau indexé contenant toutes les valeurs transmises en tant qu'arguments, que la définition de la fonction spécifie ou non des paramètres:

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

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

Fonctions variadiques

L'objet arguments vous permet de créer des fonctions variables de base, qui peuvent accepter un nombre variable d'arguments:

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

Cependant, cette approche des fonctions variables est rarement utilisée dans le développement JavaScript moderne. Il est plus courant d'utiliser la syntaxe des paramètres REST, plus moderne et lisible, qui crée un paramètre nommé initialisé sous la forme d'un tableau contenant tous les arguments autres que ceux explicitement spécifiés:

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"

Contrairement à la liaison parameter, la syntaxe des paramètres REST fonctionne comme prévu avec les paramètres de fonction fléchée:

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

myOuterFunction( false );
> true

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

myArrowFunction( true );
> true`
``