Qual è lo scopo di un parametro denominato "non definito" in una funzione JavaScript?

Question

Durante la visualizzazione del codice sorgente non compresso di jQuery mi sono imbattuto in qualcosa che non capisco. Quando creano la loro funzione anonima, si posizionano indefiniti come secondo argomento. Che cosa sta facendo e perché stanno usando undefined? È necessario mettere indefinito come argomento in una funzione anonima? Di seguito è riportato un esempio di ciò di cui sto parlando.

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

Answer 1

Quello che sta facendo, è riassegnazione undefined-undefined dentro che la chiusura. Questo è un failsafe.Perché altro codice può fare accidentalmente qualcosa di simile

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

E questo è valido in javascript (se il motore JS utilizzato non ha attuato le specifiche ECMAScript 5, in ECMAScript 5 spec undefined è non non-writable, MDN DOC),

citazione di MDN New_in_JavaScript 1.8.5 (ECMA 5) Pagina

modifiche agli oggetti globali

oggetti globali hanno apportato solo leggere

Il NaN, Infinity, e indefiniti oggetti globali sono stati fatti sola lettura, secondo le specifiche ECMAScript 5.

E da ES5 Annotated Spec in Guthub

ES5 spec Sectionx15.1.1.3

15.1.1.3 indefinito

Il valore undefined è indefinito (vedi 8.1).

Questa proprietà ha gli attributi {[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false}.

Anche se global undefined non è scrivibile Si può avere una variabile locale denominata undefined e può rovinare il vostro codice (principalmente il confronto con undefined). Ma questa è la tua responsabilità. Si possono avere i codici come

(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/

Tuttavia, se undefined è scrivibile poi l'assegnazione di cui sopra può ostacolare molti comparison fatti con undefined dopo quella riga di codice come undefined non è undefined più. Ha qualche valore ora.

Così come stanno chiamando quella funzione anonima come

(window) // one argument only 

e la ricezione di

(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 

Ciò significa dentro che la chiusura undefined viene ripristinato a undefined, in quanto non è stato passato alcun valore assicurando così uso di undefined all'interno di quella funzione anonima.

Un ottimo articolo dettagliato su questo http://javascriptweblog.wordpress.com/2010/08/16/understanding-undefined-and-preventing-referenceerrors/

sto citando alcune linee dal link articolo di cui sopra per rendere le cose chiare

Qual è indefinito?

In JavaScript c'è indefinito (tipo), indefinito (valore) e indefinito (variabile).

Non definito (tipo) è un tipo JavaScript incorporato.

undefined (valore) è una primitiva ed è l'unico valore del tipo Non definito.

Qualsiasi proprietà a cui non è stato assegnato un valore, assume il valore non definito. (ECMA 4.3.9 e 4.3.10).

Una funzione senza un'istruzione return o una funzione con un'istruzione return vuota restituisce undefined. Il valore di un argomento di funzione non supportato non è definito.

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" 

indefinito (variabile) è una proprietà globale il cui valore iniziale non è definito (valore), dalla sua una struttura globale che può anche accedere come variabile. Per coerenza, lo chiamerò sempre una variabile in questo articolo.

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

Al ECMA 3, il suo valore può essere riassegnata:

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

Inutile dire, ri-assegnazione di valori alla variabile indefinita è molto cattiva pratica, e infatti la sua non consentito dalla ECMA 5.

Answer 2

Undefined è un tipo ma è anche una variabile globale.

È possibile avere un modulo che sovrascriva il valore di non definito eseguendo undefined = whatever.

undefined in realtà è un parametro definito di una funzione avvolgere l'intero codice:

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

È sicuro, come parametro undefined è in ambito locale, e nessuno tranne il codice in questa funzione può assegnare ad esso.

Non è necessario utilizzare undefined come parametro quando si definisce una funzione anonima.

Se vedete sopra funzione che si wll nota che si aspetta due parametri ma uno è fornito.

Perché è necessario ripristinare undefined?

perché, per fa in modo che undefined è davvero undefined nel perimetro tra parentesi graffe, anche se qualcuno ha scritto qualcosa di simile undefined = "defined"; nel campo di applicazione globale, perché undefined può effettivamente essere ridefinito.

Quindi, se avete qualcosa come

var undefined = 1; 

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

Answer 3

jQuery è fare in modo che undefined davvero non è definito nel suo ambito per non passare un argomento a tale parametro.

Prendete questo codice per esempio quando undefined in realtà non è undefined:

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