La différence entre les fonctions communes définies dans les compétences javascript_javascript

Les différences entre les fonctions les plus courantes définies en JavaScript s'expliquent principalement à travers les trois aspects suivants. Les amis dans le besoin peuvent s'y référer

1 : Appeler la fonction mot-clé pour construire

Par exemple :

function distance(x1,x2,y1,y2) 
　　{ 
　　　　var dx=x2-x1; 
　　　　var dy=y2-y1; 
　　　　return Math.sqrt(dx*dx+dy*dy); 
　　} 

2 : Utiliser le constructeur Function()

Par exemple :

var f=new Function*"x","y","return x*y"); 

Cette ligne de code crée une nouvelle fonction qui est essentiellement équivalente à une fonction définie en utilisant la syntaxe que vous connaissez :

function f(x,y) 
　　{ 
　　  return x*y; 
　　} 

Le constructeur Functino() peut accepter n'importe quel nombre de paramètres de chaîne. Son dernier paramètre est le corps de la fonction, qui peut contenir n'importe quelle instruction JavaScript séparée par des points-virgules. Les autres paramètres sont des chaînes utilisées pour décrire les noms des paramètres formels à définir par la fonction. Si la fonction que vous définissez n'a pas de paramètres, vous pouvez simplement transmettre une chaîne (le corps de la fonction) au constructeur.

Notez qu'aucun des paramètres passés au constructeur Function() ne précise le nom de la fonction qu'il crée. Les fonctions sans nom créées avec le constructeur Function() sont parfois appelées « fonctions anonymes ».

Vous pourriez être très curieux de savoir à quoi sert le constructeur Function(). Pourquoi ne pouvons-nous pas simplement utiliser des instructions de fonction pour définir toutes les fonctions ? La raison en est que le constructeur Function() nous permet de construire et de compiler dynamiquement une fonction sans nous limiter au corps de fonction précompilé de l'instruction de fonction. L'effet secondaire est que chaque fois qu'une fonction est appelée, le constructeur Function() doit la compiler. Par conséquent, nous ne devons pas appeler fréquemment ce constructeur dans les corps de boucles ou dans les fonctions fréquemment utilisées.

Une autre raison d'utiliser le constructeur Function() est qu'il peut définir la fonction comme faisant partie d'une expression JavaScript au lieu de la définir comme une instruction. Dans ce cas, son utilisation est plus pratique et même élégante.

3 : Fonction littérale

Une fonction littérale est une expression qui peut définir une fonction anonyme. La syntaxe d'un littéral de fonction est très similaire à celle d'une instruction de fonction, sauf qu'elle est utilisée comme une expression plutôt que comme une instruction et qu'il n'est pas nécessaire de spécifier un nom de fonction. Les trois lignes de code suivantes définissent trois fonctions fondamentalement identiques en utilisant l'instruction function(), le constructeur Function() et le littéral de fonction :

function f(x){return x*x}; 
　　var f=new Function("x","return x*x;"); 
　　var f=function(x){reurn x*x}; 

Bien que la fonction littérale crée une fonction sans nom, sa syntaxe précise également qu'elle peut spécifier un nom de fonction, ce qui est très utile lors de l'écriture d'une fonction récursive qui s'appelle elle-même.

Par exemple :

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

Le code ci-dessus définit une fonction sans nom et stocke une référence à celle-ci dans la variable f. Cela ne crée pas réellement une fonction nommée fact(), cela permet simplement au corps de la fonction de se désigner par ce nom. Notez cependant que ce littéral de fonction nommé n’a pas été implémenté correctement dans les versions antérieures à JavaScript 1.5.

L'utilisation des littéraux de fonction est très similaire à la méthode de création de fonctions à l'aide du constructeur Function(). Puisqu'ils sont créés par des expressions JavaScript plutôt que par des instructions, la façon dont ils sont utilisés est plus flexible, en particulier pour les fonctions qui ne sont utilisées qu'une seule fois et qui n'ont pas besoin d'être nommées. Par exemple, une fonction spécifiée à l'aide d'une expression littérale de fonction peut être stockée dans une variable, transmise à d'autres fonctions, ou même appelée directement :

a[0]=function(x){return x*x;};//定义一个函数并保存它 
　　a.sort(function(a,b){return a-b;});//定义一个函数；把它传递给另一个函数 
　　var tensquared=(function(x){return x*x;})(10); 

　　和Function()构造函数一样，函数直接量创建的是未命名函数，而且不会自动地将这个函数存储在属性中。但是，比起Function()构造函数来说，函数直接量有一个重要的优点。由Function()构造函数创建的函数的主体必须用一个字符串说明，用这种方式来表达一个长而复杂的函数是狠笨拙的。但是函数直接量的主体使用的却是标准的JavaScript语法。而且函数直接量只被解析一次，而作为字符串传递给Function()构造函数的JavaScript代码则在每次调用构造函数时只需被解析一次和编译一次。

　　 　　在JavaScript1.1中，可以使用构造函数Function()来定义函数，在JavaScript1.2和其后的版本中，还可以使用函数直接量来构造函数。你应该注意这两种方法之间的重要差别。

　　首先，构造函数Function()允许在运行时动态地创建和编译JavaScript代码。但是函数直接量却是函数结构的一个静态部分，就像function语句一样。

　　其次，作为第一个差别的必然结果，每次调用构造函数Function()时都会解析函数体并且创建一个新东汉数对象。如果对构造函数的调用出现在一个循环中，或者出现在一个经常被调用的函数中，这种方法的效率非常低。另一个方面，函数直接量或出现在循环和函数中的嵌套函数不是在每次调用时都被重新编译，而且每当遇到一个函数直接量时也不创建一个新的函数对象。

　　Function()构造函数和函数之间量之间的第三点差别是，使用构造函数Function()创建的函数不使用词法作用域，相反的，它们总是被当作顶级函数来编译，就像下面代码所说明的那样：

　var y="global"; 
　　function constructFunction() 
　　{ 
　　　　var y="local"; 
　　　　return new Function("return y");//不捕捉局部作用域。 
　　} 
　　//这行代码将显示"global"，因为Function()构造函数返回的函数并不使用局部作用域。 
　　//假如使用一个函数直接量，这行代码则可能显示"local"。 
　　alert(constructFunction());