Trois façons de définir des fonctions en js

Tutoriel série js 4 fonctions, paramètres de fonction

En js, la fonction elle-même est un type d'objet , il peut donc être défini, attribué, utilisé comme attribut d'un objet ou paramètre d'autres fonctions. Le nom de la fonction est simplement une référence à la classe d'objet de la fonction.

1. Définition de la fonction

[1] L'instruction de déclaration de fonction
utilise le mot-clé function, suivi d'un ensemble de paramètres et du corps de la fonction

function funcname([arg1 [,arg2 [...,argn]]]){
    statement;
}

【2】Expression de définition de fonction

Une fonction définie en mode expression, le nom de la fonction est facultatif

var functionName = function([arg1 [,arg2 [...,argn]]]){
    statement;
}var functionName = function funcName([arg1 [,arg2 [...,argn]]]){
    statement;
}

La fonction anonyme (fonction anonyme) est également appelée lambda Une fonction est une fonction sans identifiant après le mot-clé function

De manière générale, aucun nom n'est requis lors de la définition de fonctions dans des expressions, ce qui rend le code qui les définit plus compact. Les expressions de définition de fonction sont particulièrement adaptées pour définir des fonctions qui ne seront utilisées qu'une seule fois

var tensquared = (function(x) {return x*x;}(10));   //

Alors qu'une expression de définition de fonction contient un nom, la portée locale de la fonction contiendra un nom lié à l'objet fonction. En fait, le nom de la fonction deviendra une variable locale à l'intérieur de la fonction

var test = function fn(){   return fn;
}console.log(test);//fn(){return fn;}console.log(test());//fn(){return fn;}console.log(test()());//fn(){return fn;}

Compréhension personnelle, pour les expressions de fonction nommées, le nom de la fonction est équivalent au paramètre formel de l'objet fonction, qui ne peut être utilisé à l'intérieur de la fonction Use; et le nom de la variable est équivalent au paramètre réel de l'objet fonction, qui peut être utilisé à la fois à l'intérieur et à l'extérieur de la fonction

var test = function fn(){   return fn === test;
}console.log(test());//trueconsole.log(test === fn);//ReferenceError: fn is not defined

La fonction définit un attribut de nom non standard , par lequel la fonction donnée est accessible Le nom spécifié. La valeur de cet attribut est toujours égale à l'identifiant qui suit le mot-clé function L'attribut name de la fonction anonyme est vide

//IE11-浏览器无效，均输出undefined//chrome在处理匿名函数的name属性时有问题，会显示函数表达式的名字function fn(){};
console.log(fn.name);//'fn'var fn = function(){};
console.log(fn.name);//''，在chrome浏览器中会显示'fn'var fn = function abc(){};
console.log(fn.name);//'abc'

[3] Constructeur de fonction

Constructeur de fonction La fonction reçoit un nombre quelconque de paramètres, mais le dernier paramètre est toujours considéré comme le corps de la fonction, tandis que les paramètres précédents énumèrent les paramètres de la nouvelle fonction

var functionName = new Function(['arg1' [,'arg2' [...,'argn']]],'statement;');

[Note] Le constructeur Function ne peut pas être spécifié Nom de fonction, il crée une fonction anonyme

Techniquement, il s'agit d'une expression de fonction. Cependant, cela n’est pas recommandé car cette syntaxe entraîne une analyse double du code. La première fois consiste à analyser le code javascript normal, et la deuxième fois consiste à analyser la chaîne passée dans le constructeur, ce qui affecte les performances

var sum = new Function('num1','num2','return num1 + num2');//等价于var sum = function(num1,num2){
    return num1+num2;
}

Pour les fonctions créées par le constructeur Function(), la compilation de son corps de fonction s'exécutera toujours dans une portée globale. Par conséquent, le constructeur Function() est similaire à eval() exécuté dans la portée globale

var test = 0;function fn(){
    var test = 1;    return new Function('return test');}
console.log(fn()());//0

[Note] Toutes les fonctions ne peuvent pas devenir des constructeurs

var o = new Math.min();//Uncaught TypeError: Math.min is not a constructor

2. Ordre de déclaration des fonctions

Les déclarations de fonctions seront chargées en premier par rapport aux variables. Ne vous inquiétez donc pas de savoir si la déclaration de fonction est avant ou après l'appel.

Lors de l'appel d'une fonction, elle interrogera d'abord l'objet actif local, c'est-à-dire dans le fichier js actuel, s'il n'y a pas de requête, elle interrogera donc vers le haut, si le même nom de fonction est défini. dans deux fichiers js, les deux js Les fonctions respectives sont appelées à l'intérieur du fichier, et la dernière fonction déclarée est appelée dans d'autres fichiers js.

3.

Les déclarations répétées de variables sont inutiles et n'écraseront pas les variables précédemment déclarées dans la même portée, mais les déclarations répétées de fonctions écraseront les déclarations de fonction précédentes. ou une variable du même nom.

//变量的重复声明无用var a = 1;var a;
console.log(a);//1

//覆盖同名变量var a;function a(){
    console.log(1);
}a();//1

//覆盖同名函数a();//2function a(){
    console.log(1);
}function a(){
    console.log(2);
}

4. Supprimer les variables créées par

l'instruction de déclaration de fonction ne peut pas être supprimée, c'est la même chose que la déclaration de variable.

function foo(){
    console.log(1);
}delete foo;//falseconsole.log(foo());//1

Cet article présente trois façons de définir des fonctions en js. Pour plus de contenu connexe, veuillez faire attention au site Web chinois php.

Recommandations associées :

« Vrai et faux » en JS

Comment déterminer une collision via JS !

Présentation de quelques solutions d'implémentation js pour les algorithmes classiques

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!