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