Quel est le but d'un paramètre nommé "indéfini" dans une fonction JavaScript?

Tout en regardant le code source non compressé de jQuery, je suis tombé sur quelque chose que je ne comprenais pas très bien. Lors de la création de leur fonction anonyme, ils se situent indéfinis comme un deuxième argument. Qu'est-ce que cela fait, et pourquoi utilisent-ils undefined? Est-il nécessaire de mettre indéfini comme argument dans une fonction anonyme? Voici un exemple de ce dont je parle.

(function( window, undefined) { ...code here })( window ); 

Ce que cela fait, est de réaffecter undefined à undefined intérieur de cette fermeture. C'est un cas de sécurité. Parce qu'un autre code peut accidentellement faire quelque chose comme

 undefined = something; console.log(undefined); // will output 'something' 

Et cela est valable dans javascript (si le moteur JS utilisé n'a pas implémenté la spécification ECMAScript 5, dans ECMAScript 5 spec undefined n'est pas non-writable , MDN DOC ),

Quote from MDN New_in_JavaScript 1.8.5 (ECMA 5) Page

Modifications apportées aux objets globaux

Objets globaux réalisés en lecture seule

Les objets globaux NaN , Infinity et indéfinis ont été créés uniquement en lecture , selon la spécification ECMAScript 5.

Et de ES5 Annotated Spec à Guthub

ES5 spec Section x15.1.1.3

15.1.1.3 indéfini

La valeur de indefined est indéfinie (voir 8.1).

Cette propriété a les attributs { [[Writable]]: false , [[Enumerable]]: false, [[Configurable]]: false}.

Même si global undefined n'est pas accessible à l'écriture Vous pouvez avoir une variable locale nommée undefined et pouvoir gâcher votre code (principalement des comparaisons avec undefined ). Mais c'est votre responsabilité. Vous pouvez avoir des codes comme

 (function(){ console.log('Second Case: '); var undefined = 'Something'; console.log(undefined); // Will log `something` var a ; // a is undefined console.log(a === undefined); // false, as undefined is changed // you might expect a === undefined will return true, but as // `undefined` is changed it will return false. console.log(a); // undefined })(); 

Demo: http://jsfiddle.net/joycse06/V4DKN/

Cependant, si undefined est écrit, l'affectation ci-dessus peut entraver de nombreuses comparison effectuées avec undefined après que cette ligne de code n'est plus undefined . Cela a une certaine valeur maintenant.

Alors qu'ils appellent cette fonction anonyme comme

 ( window ) // one argument only 

Et recevoir

 ( window, undefined) // only window is passed when calling the function // Second argument is not passed means it's undefined // so undefined is restored to undefined inside that function // and no global accidental assignments can hamper jQuery's // code using 'undefined' now 

Cela signifie que cette fermeture undefined est restaurée à undefined , car elle n'a pas été passée à aucune valeur, ce qui garantit l'utilisation d' undefined intérieur de cette fonction anonyme.

Un très bon article détaillé sur ce http://javascriptweblog.wordpress.com/2010/08/16/understanding-undefined-and-preventing-referenceerrors/

Je cite quelques lignes du lien ci-dessus pour rendre les choses claires

Qu'est-ce qui est indéfini?

En JavaScript, il existe Undefined (type) , indéfini (valeur) et indéfini (variable).

Undefined (type) est un type de JavaScript intégré.

Undefined (valeur) est une primitive et est la seule valeur du type indéfini .

Toute propriété qui n'a pas été affectée à une valeur, assume la valeur indéfinie. (ECMA 4.3.9 et 4.3.10).

Une fonction sans déclaration de retour, ou une fonction avec une déclaration de retour vide renvoie indéfinie. La valeur d'un argument de fonction non fourni est indéfinie.

 var a; typeof a; //"undefined" window.b; typeof window.b; //"undefined" var c = (function() {})(); typeof c; //"undefined" var d = (function(e) {return e})(); typeof d; //"undefined" 

Indéfinie (variable) est une propriété globale dont la valeur initiale est indéfinie (valeur), puisqu'il s'agit d'une propriété globale, nous pouvons également l'accéder en tant que variable. Pour la cohérence, je vais toujours l'appeler une variable dans cet article.

 typeof undefined; //"undefined" var f = 2; f = undefined; //re-assigning to undefined (variable) typeof f; //"undefined" 

D'après ECMA 3, sa valeur peut être réaffectée:

 undefined = "washing machine"; //assign a string to undefined (variable) typeof undefined //"string" f = undefined; typeof f; //"string" f; //"washing machine" 

Inutile de dire que la réaffectation de valeurs à la variable indéfinie est une très mauvaise pratique et, en fait, elle n'est pas autorisée par ECMA 5.

Undefined est un type mais est également une variable globale.

Vous pouvez avoir un module qui écrase la valeur de indéfinie en faisant undefined = whatever .

undefined dans le est en fait un paramètre indéfini d'une fonction enveloppant le code entier:

 (function(window, undefined) { // undefined is the undefined parameter }(window)); 

C'est sûr, car le paramètre undefined est dans la portée locale, et personne, sauf le code de cette fonction, ne peut l'attribuer.

Il n'est pas nécessaire d'utiliser undefined paramètre undefined comme paramètre pour définir une fonction anonyme.

Si vous voyez la fonction ci-dessus, vous constaterez qu'il attend deux paramètres, mais un est fourni.

Pourquoi un undefined doit-il être restauré?

Parce que, pour s'assurer que undefined est en effet undefined dans la portée entre les accolades, même si quelqu'un a écrit quelque chose comme undefined = "defined"; Dans la portée globale, car undefined peut réellement être redéfini.

Donc, si vous avez quelque chose comme

 var undefined = 1; (function(window, undefined) { console.log(undefined); // output will be undefined not 1 }(window)); 

JQuery s'assure que undefined est vraiment indéfini dans sa portée en ne passant pas un argument à ce paramètre.

Prenez ce code par exemple lorsque undefined n'est pas réellement indéfini:

 var undefined = 1; alert(undefined); // 1