Explication détaillée de la création d'objets de fonction JavaScript, des paramètres et des instances de portée

" "Constructeur" :

La liste de paramètres peut avoir autant de paramètres que vous le souhaitez, suivis du corps de la fonction, par exemple :

imprimera le résultat :

6

var funcName = new Function( [argname1, [... argnameN,]] body );

Mais qui créerait une fonction d'une manière aussi difficile à utiliser ? Si le corps de la fonction est complexe, il faudra beaucoup d'efforts pour assembler la chaîne, donc JavaScript fournit une sorte de sucre de syntaxe, c'est-à-dire via des littéraux Pour créer une fonction :

var add = new Function("x", "y", "return(x+y)"); 
print(add(2, 4));

ou :


En fait, un tel sucre syntaxique est plus susceptible de mal comprendre les programmeurs des domaines traditionnels. Le mot-clé function appellera Function crée un nouvel objet et transmet avec précision la liste des paramètres et le corps de la fonction au constructeur de la fonction.

De manière générale, déclarer un objet dans la portée globale (la portée sera présentée en détail dans la section suivante) revient simplement à attribuer une valeur à un attribut. Par exemple, la fonction add dans l'exemple ci-dessus ajoute simplement une valeur à. l'objet global.Un attribut est ajouté, et le nom de l'attribut est add, et la valeur de l'attribut est un objet, c'est-à-dire function(x, y){return x+y;}. La syntaxe de cette instruction est la suivante :

function add(x, y){ 
return x + y; 
}

Pas de différence. Ils ajoutent tous dynamiquement un nouvel attribut à l'objet global, c'est tout.

var add = function(x, y){ 
return x + y; 
}

Afin d'illustrer que les fonctions, comme d'autres objets, existent en tant qu'objet indépendant dans le système d'exécution JavaScript, autant regarder cet exemple :

Il n'y a rien de mal, même si p est cité Une fonction (objet) anonyme, mais elle peut aussi avoir des attributs, exactement comme les autres objets. Les résultats d'exécution sont les suivants :

var str = "This is a string";

1.2 Paramètres de la fonction

function p(){ 
print("invoke p by ()"); 
} 
p.id = "func"; 
p.type = "function"; 
print(p); 
print(p.id+":"+p.type); 
print(p());

En JavaScript. , les paramètres de la fonction C'est assez intéressant. Par exemple, vous pouvez passer n'importe quel nombre de paramètres à une fonction, même si la fonction est déclarée sans spécifier de paramètres formels, par exemple :

La fonction. adPrint accepte trois formes lorsqu'il est déclaré Paramètres : la chaîne à imprimer, la longueur à imprimer et s'il faut la convertir en marqueurs majuscules et minuscules. Mais lors de l'appel, nous pouvons transmettre un paramètre, deux paramètres ou trois paramètres à adPrint en séquence (vous pouvez même lui transmettre plus de 3 paramètres, cela n'a pas d'importance. Les résultats d'exécution sont les suivants :

function (){ 
print("invoke p by ()"); 
} 
func:function 
invoke p by ()

En fait, lorsque JavaScript gère les paramètres de fonction, c'est différent des autres langages compilés. Ce que l'interpréteur transmet à la fonction est une valeur interne de type tableau appelée arguments. Cela se fait lorsque l'objet fonction est généré. . est initialisé. Par exemple, lorsque nous transmettons un paramètre à adPrint, les deux autres paramètres ne sont pas définis. De cette façon, nous pouvons traiter ces paramètres non définis à l'intérieur de la fonction adPrint, qui peuvent être exposés à l'extérieur : nous pouvons traiter n'importe quel paramètre.

Discutons de ces arguments magiques à travers un autre exemple :

function adPrint(str, len, option){ 
var s = str || "default"; 
var l = len || s.length; 
var o = option || "i"; 
s = s.substring(0, l); 
switch(o){ 
case "u": 
s = s.toUpperCase(); 
break; 
case "l": 
s = s.toLowerCase(); 
break; 
default: 
break; 
} 

print(s); 
} 

adPrint("Hello, world"); 
adPrint("Hello, world", 5); 
adPrint("Hello, world", 5, "l");//lower case 
adPrint("Hello, world", 5, "u");//upper case

La fonction sum n'a pas de paramètres formels explicites, et nous pouvons lui passer dynamiquement autant de paramètres. Alors, comment les référencer paramètres dans la fonction somme ? Ici, vous devez utiliser le pseudo tableau d'arguments. Les résultats en cours sont les suivants :

Hello, world 
Hello 
hello 
HELLO

Portée de la fonction

Le concept de portée Cela se reflète dans presque tous les langages courants. En JavaScript, il a sa particularité : la portée de la variable en JavaScript est valide dans le corps de la fonction, et il n'y a pas de portée de bloc. En langage Java, on peut définir un bloc de boucle for comme ceci Variables d'indice dans :

function sum(){ 
var result = 0; 
for(var i = 0, len = arguments.length; i < len; i++){ 
var current = arguments[i]; 
if(isNaN(current)){ 
throw new Error("not a number exception"); 
}else{ 
result += current; 
} 
} 
return result; 
} 

print(sum(10, 20, 30, 40, 50)); 
print(sum(4, 8, 15, 16, 23, 42));//《迷失》上那串神奇的数字 
print(sum("new"));

Et en JavaScript :

150 
108 
Error: not a number exception

Les fonctions JavaScript s'exécutent dans la portée locale et les fonctions s'exécutent dans la portée locale Le corps peut accéder à ses variables externes (éventuellement de portée globale) et fonctions. La portée de JavaScript est la portée lexicale. La portée lexicale signifie que sa portée est déterminée lors de sa définition (analyse lexicale), et non lors de son exécution, comme dans l'exemple suivant :

public void method(){ 
for(int i = 0; i < obj1.length; i++){ 
//do something here; 
} 
//此时的i为未定义 
for(int i = 0; i < obj2.length; i++){ 
//do something else; 
} 
}

Quel est le résultat en cours d'exécution ? Les débutants sont susceptibles d'obtenir cette réponse :

function func(){ 
for(var i = 0; i < array.length; i++){ 
//do something here. 
} 
//此时i仍然有值，及I == array.length 
print(i);//i == array.length; 
}

Et le résultat correct devrait être :

var str = "global"; 
function scopeTest(){ 
print(str); 
var str = "local"; 
print(str); 
} 
scopeTest();

Parce que dans la définition de la fonction scopeTest, la variable non déclarée str est accédée à l'avance puis la variable str est initialisée, le premier print(str) renverra une erreur non définie. Alors pourquoi la fonction n'accède-t-elle pas à la variable str externe à ce moment-là ? En effet, une fois l'analyse lexicale terminée, lors de la construction de la chaîne de portée, la variable var définie dans la fonction sera mise dans la chaîne, donc str est dans l'ensemble de la fonction scopeTest sont tous visibles (de la première ligne à la dernière ligne du corps de la fonction). Puisque la variable str elle-même n'est pas définie, le programme est exécuté séquentiellement et renverra un défini à la première ligne. valeur à str, donc la troisième ligne print(str) de la ligne renverra "local".

global 
local

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!