Donnons d'abord un exemple. La fonction de cette fonction est de renvoyer la somme des éléments du tableau
;
var somme = 0 ;
for(var i = 0,aLength = arr.length;i < aLength;i++) {
somme += arr[i];
}
return sum; } Il y a un espace après le mot-clé function . sumArray est le nom de la fonction. Sa convention de dénomination est la même que celle des noms de variables : elle ne peut contenir que des lettres, des chiffres, des traits de soulignement et des signes dollar. un nombre et ne peut pas être un mot-clé.
Les paramètres entre parenthèses, également appelés paramètres formels , nécessitent uniquement le nom du paramètre. Les paramètres peuvent être 0 , 1 ou plus, séparés par , et {} contient le corps de la fonction . Contient une ou plusieurs instructions. Le corps de la fonction est utilisé pour implémenter la fonction de la fonction.
Le mot-clé return est suivi de la valeur de retour de la fonction, et la fonction peut également n'avoir aucune valeur de retour. Une fois l'exécution de la fonction terminée, l'instruction " return quittera l'exécution et l'instruction ci-dessous return ne sera plus exécutée . La valeur de retour est la sortie de la fonction.
Une fonction définie de cette manière peut être appelée avant et après la définition de la fonction , à condition que la fonction et l'instruction appelant la fonction se trouvent dans le même fichier source.
pour définir une fonction à l'aide d'une expression, qui consiste à utiliser une expression d'affectation pour attribuer la fonction à une variable . Il s'agit en fait de traiter la fonction comme une variable. À l'heure actuelle, la fonction peut avoir un nom ou pas de nom. Une fonction sans nom est appelée fonction anonyme .
var funct = function getMax(a,b) {
return a>b?a:b; };//Notez que le point-virgule après ceci ne peut pas manquer, car nous définissons une variable ! Contrairement à sa définition avec une instruction de fonction , la fonction ne peut être appelée qu'après l'instruction de définition de fonction. . Et lors de l'appel, seul le nom de la variable funct peut être utilisé et le nom de la fonction getMax ne peut pas être utilisé, par exemple :
var funct = function getMax(a,b) {.
retourner a>b?a:b;
} ;
console.log(funct(1,2));// function :var funct = function(a,b) {
return a>b?a:b; Cette fonction n'a pas de nom. Elle est affectée à la variable funct , elle est donc appelée fonction anonyme. De même, cette fonction ne peut être appelée qu'après cette instruction.
var fonction = fonction(a,b) {
return a>b?a:b; }; console.log(funct(1,2));// Résumé du résultat 2 : La définition d'une fonction avec une expression peut être utilisée directement. Une fois définie, elle ne peut être utilisée que. être utilisé dans cette instruction Ensuite, appelez la fonction
Dans la quatrième formation, nous avons introduit que les objets peuvent avoir leurs propres méthodes, bien sûr, c'est aussi une fonction. L'appel de cette fonction est légèrement différent des fonctions définies dans les deux niveaux précédents.
//Définition de la fonction : trouver la valeur maximale de trois nombres function max(a,b,c) {
si(a > b) {
si (a > c)
renvoyer un ;
autre
retourner c;
}
autre {
si (b > c)
retourner b ;
autre
retourner c;
}
}
//Appelle cette fonction var result = max(1,2,3);//result is 3
console.log(result);//Output 3 Lors de l'appel de la fonction, vous devez transmettre le même nombre de valeurs spécifiques que les paramètres formels. La fonction ci-dessus a 3 paramètres, donc lors de l'appel ci-dessous, transmettez 3 spécifiques. valeurs , 1 est passé au paramètre a , 2 est passé au paramètre b 3 est passé au paramètre c . La valeur de retour de la fonction est transmise à la variable result via le symbole d'affectation = . S'il n'y a pas de mot-clé return dans le corps de la fonction, undefined sera renvoyé.
Appel de fonctions définies dans l'objet :
var ob = {
identifiant : 1,
getMax:fonction(a,b) {
retourner a>b?a:b;
} }; var result = ob.getMax(2,1);//La valeur du résultat est 2 var result1 = ob["getMax"](2,1);//La valeur de result1 est également 2. La différence avec ce qui précède est qu'ici Pour localiser une fonction, vous devez utiliser对象名.函数名ou对象名["函数名"] , les autres sont les mêmes.
Dans la plupart des langages de programmation, le nombre et le type de paramètres réels transmis lors de l'appel d'une fonction sont vérifiés, mais JavaScript ne vérifie ni le type ni le nombre de paramètres réels.
Les paramètres réels en JavaScript correspondront aux paramètres formels dans l'ordre de gauche à droite , par exemple :
function myFunction(a,b,c) {
console.log(a);
console.log(b);
console.log(c); } myFunction(1,2,3); Le paramètre réel 1 est passé dans le paramètre formel a , le paramètre réel 2 est passé dans le paramètre formel b et le paramètre réel 3 est passé dans le paramètre formel c . Lorsque le nombre de paramètres réels est inférieur aux paramètres formels, la valeur undefined sera transmise au paramètre formel droit. Par exemple :
function maFonction(a,b,c) {
console.log(a);
console.log(b);
console.log(c); } myFunction(1,2); Le paramètre réel 1 est passé au paramètre formel a , le paramètre réel 2 est passé au paramètre formel b et undefined passé au paramètre formel c . Si vous souhaitez uniquement transmettre des données aux paramètres de droite, vous pouvez transmettre undefined aux premiers paramètres réels. Par exemple :
undefined
,1,2);
suffisamment rigoureux, la meilleure pratique consiste à définir une valeur par défaut pour les paramètres formels auxquels des valeurs undefined peuvent être transmises. Par exemple :
function getSum(a,b,c) {
si (c === non défini)
c = 0 ;
console.log(a+b+c); } myFunction(1,2); Tout JavaScript est un objet, et le paramètre réel est aussi un objet .Il a un nom arguments . être considéré comme un tableau. (de type tableau, pas un véritable tableau), les paramètres réels sont arguments[0]、arguments[1]... de gauche à droite, arguments.length représente le nombre de paramètres réels.
//Trouver la somme des paramètres function getSum() {
var aLength = arguments.length;
var somme = 0 ;
pour(var je = 0;i < aLength;i++) {
somme += arguments[i];
}
return sum; } console.log(getSum(1,2,3,4,5))//Output 15. Les paramètres formels ici sont omis directement et représentés par arguments[i] .
JavaScript complexes
Les développeurs doivent vérifier la correspondance entre chaque paramètre réel et paramètre formel, ce qui est très inefficace. Une bonne solution consiste à utiliser un objet comme paramètre, et la fonction fonctionnera sur le paramètre en fonction du nom de la propriété de l'objet.
fonction maFonction(obj) {
console.log(obj.name);
obj.numéro++;
return obj.number; } myObj = {name:"myObj",number:34}; myFunction(myObj);//Output myObj console.log(myObj.number);//Output 35 une fonction (appelée a pour faciliter l'écriture) peuvent être utilisés comme paramètres d'une autre fonction (appelée fonction b ), et la fonction b peut enfin renvoyer une valeur spécifique.
En principe, la fonction b appelle la fonction a dans son propre corps de fonction, donc le nom de la fonction a doit être transmis à la fonction b en tant que paramètre réel. Comme suit :
//Trouver la fonction de valeur maximale getMax(a,b) {
return a>b?a:b; } //Trouver la valeur minimale function getMin(a,b) {
return a<b?a:b; } //La fonction suivante prend une fonction comme paramètre et renvoie finalement une valeur function getM(func,num1,num2) {
return func(num1,num2); } getM(getMax,1,2);//Return 2 getM(getMin,1,2);//Return 1 On passe le nom de la fonction a ( getMax ou getMin ) à la fonction b ( getM（） ), puis appelez la a a transmise à l'intérieur de la fonction b pour obtenir les résultats pertinents.