Exemples détaillés de la différence entre les littéraux de fonction javascript et les constructeurs Function()

La différence entre le constructeur de fonction littéral et Function()
Bien que le littéral de fonction soit une fonction anonyme, la syntaxe vous permet de spécifier n'importe quel nom de fonction. Lors de l'écriture d'une fonction récursive, vous pouvez l'appeler vous-même, en utilisant Function. ( ) le constructeur ne fonctionne pas. Le constructeur

var f = function fact(x) { 
if (x < = 1) return 1; 
else return x*fact(x-1);
};

Function() permet la création et la compilation dynamiques de code Javascript au moment de l'exécution. En cela, elle est similaire à la fonction globale eval().

Le constructeur Function() analyse le corps de la fonction et crée un nouvel objet fonction à chaque fois qu'il est exécuté. Par conséquent, l’efficacité de l’appel du constructeur Function() dans une boucle ou une fonction fréquemment exécutée est très faible. En revanche, les littéraux de fonction ne sont pas recompilés à chaque fois qu'ils sont rencontrés.

Lors de la création d'une fonction à l'aide du constructeur Function(), elle ne suit pas la portée typique. Elle l'exécute toujours en tant que fonction de niveau supérieur.

var y = "global"; 
function constructFunction() { 
var y = "local"; 
return new Function("return y"); // 无法获取局部变量} 
alert(constructFunction()()); // 输出 "global" 函数直接量：

Tant qu'il s'agit d'une syntaxe d'expression, l'hôte du script pensera que la fonction est une fonction directe. Si rien n'est ajouté, elle sera considérée comme une déclaration de fonction si elle commence par Write function. en une expression Dans la formule, comme les quatre opérations arithmétiques, l'hôte la traitera également comme une quantité directe, comme suit :

var a = 10 + function(){ 
return 5; 
}();

(function(){ 
alert(1); 
} ) ( ); 
( function(){ 
alert(2); 
} ( ) ); 
void function(){ 
alert(3); 
}() 
0, function(){ 
alert(4); 
}(); 
-function(){ 
alert(5); 
}(); 
+function(){ 
alert(6); 
}(); 
!function(){ 
alert(7); 
}(); 
~function(){ 
alert(8); 
}(); 
typeof function(){ 
alert(9); 
}();

Il existe de nombreuses façons de définir des fonctions en js, et la quantité directe de fonction en fait partie. Par exemple, var fun = function(){}, si la fonction n'est pas affectée à fun, alors c'est une fonction anonyme.

Regardez comment les fonctions anonymes sont appelées.

1. Appels de fonction qui obtiennent des valeurs de retour après l'exécution

//方式一，调用函数，得到返回值。强制运算符使函数调用执行 
(function(x,y){ 
alert(x+y); 
return x+y; 
}(3,4)); 
//方式二，调用函数，得到返回值。强制函数直接量执行再返回一个引用，引用在去调用执行 
(function(x,y){ 
alert(x+y); 
return x+y; 
})(3,4);

2. Ignorer les valeurs de retour après l'exécution

//方式三，调用函数，忽略返回值 
void function(x) { 
x = x-1; 
alert(x); 
}(9);

Eh bien, regardez enfin la mauvaise façon d'appeler

//错误的调用方式 
function(x,y){ 
alert(x+y); 
return x+y; 
}(3,4);

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!