Fonctions

Une fonction est un bloc modulaire et réutilisable d’instructions utilisé pour exécuter un ensemble de tâches connexes, telles que le calcul et le renvoi d'une valeur basée sur des arguments fournies à la fonction. Comme pour toutes les valeurs non primitives, sont des objets. Ce sont des objets uniques dans la mesure où ils peuvent être appelés pour exécuter du code, recevoir des données sous forme d'arguments, et renvoie une valeur.

Les fonctions sont considérées comme une "première classe". d'objets, ce qui signifie que, malgré leur comportement unique, ils peuvent être utilisés dans tous les 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 comme propriété d'un objet est généralement appelé « 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 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 la fonction") crée une fonction nommée qui peut être appelée ailleurs dans son champ d'application qui la contient. Les déclarations de fonction se composent du mot clé function suivi d'un une liste de paramètres séparés par une virgule et placés entre parenthèses, ainsi qu'un une instruction de bloc appelée « corps de la fonction ». Vous rencontrerez souvent des déclarations de fonction qui ne se terminer par un point-virgule ; car une déclaration de fonction est une instruction, Les points-virgules peuvent être déduits par ASI.

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

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

En raison des premières décisions de conception de JavaScript, les déclarations de fonction sont soumises au même hissage hérité du comportement en tant que variables déclarées avec var, ce qui signifie qu'une déclaration de fonction est hissé au sommet de son champ d'application et peut être appelé avant la déclaration en tant que résultat, que cette portée soit régie 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, la fonction utilisent l'ancien champ d'application de JavaScript ce qui signifie qu'une déclaration de fonction est limitée à son environnement englobant :

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 joue le rôle nom symbolique d'une valeur. Le référencement d'une fonction par l'identifiant seul renvoie uniquement 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 servent de variables d'espace réservé pour valeurs qui peuvent être transmises dans le corps de la fonction lorsque celle-ci est appelée. Les valeurs entre parenthèses lorsqu'une fonction est appelée sont des "arguments" (bien que vous pourriez voir des arguments utilisé pour décrire à la fois les arguments et les paramètres dans certaines documentation):

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 undefined, car le paramètre est déclaré dans le corps de la fonction, mais non initialisé avec une valeur:

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

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

Pour définir des valeurs de paramètres par défaut, initialisez-les comme vous le feriez initialiser une variable: un opérateur d'affectation (=) suivi d'une valeur. Si vous plus tard un argument pour cette fonction, cette nouvelle valeur remplace 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."

Corps d'une autre flèche a également accès à une fonction d'index zéro objet arguments de type tableau contenant toutes les valeurs transmises en tant qu'arguments, que la fonction spécifie les paramètres:

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

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

Fonctions variables

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 code JavaScript moderne développement d'applications. Il est plus courant d'utiliser l'approche la plus moderne et la plus lisible Syntaxe du paramètre REST qui crée un paramètre nommé initialisé en tant que tableau contenant tous les arguments autres que celles explicitement spécifiées:

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