¿Cuál es el propósito de un parámetro llamado "indefinido" en una función de JavaScript?

Question

Al ver el código fuente sin comprimir de jQuery, tropecé con algo que no entiendo del todo. Cuando crean su función anónima, colocan indefinido como un segundo argumento. ¿Qué está haciendo esto, y por qué están usando undefined? ¿Es necesario poner indefinido como argumento en una función anónima? A continuación se muestra un ejemplo de lo que estoy hablando.

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

Answer 1

Lo que esto está haciendo, está reasignando a undefinedundefined dentro de ese cierre. Eso es a prueba de fallas.Debido otro código puede hacer accidentalmente algo así como

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

Y eso es válido en javascript (si el motor JS siendo utilizado no ha aplicado ECMAScript 5 especificación, en ECMAScript 5 especificación undefined es no non-writable, MDN DOC),

Presupuesto de MDN New_in_JavaScript 1.8.5 (ECMA 5) Página

cambios en los objetos globales

objetos globales hecho de sólo lectura

El NaN, Infinity, y indefinidos objetos globales se han hecho sólo lectura, según la especificación de ECMAScript 5.

Y desde ES5 Annotated Spec en Guthub

ES5 spec Sectionx15.1.1.3

15.1.1.3 indefinido

no está definido el valor de indefinido (véase 8.1).

Esta propiedad tiene los atributos {[[Escribir]]: falso, [[Enumerable]]: falso, [[Configurable]]: falso}.

Incluso si no se puede escribir global undefined Usted puede tener una variable local llamada undefined y puede ensuciar su código (principalmente comparaciones con undefined). Pero esa es su responsabilidad. Puede tener códigos como

(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 
})(); 

Demostración:http://jsfiddle.net/joycse06/V4DKN/

Sin embargo, si undefined se puede escribir entonces la tarea anterior puede obstaculizar muchas comparison hechos con undefined después de esa línea de código como undefined no es undefined más. Tiene algún valor ahora.

Así como que están llamando a que la función anónima como

(window) // one argument only 

y recibir

(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 

Eso significa que dentro de ese cierre undefined se restaura a undefined, ya que no se ha aprobado ningún valor asegurando así uso de undefined dentro de esa función anónima.

Un artículo muy bueno detallada sobre este http://javascriptweblog.wordpress.com/2010/08/16/understanding-undefined-and-preventing-referenceerrors/

cito algunas líneas del acoplamiento del artículo de arriba para hacer las cosas claras

Lo que no está definido?

En JavaScript no es Indefinido (tipo), indefinido (valor) y indefinido (variable).

Indefinido (tipo) es un tipo incorporado de JavaScript.

undefined (valor) es un primitivo y es el único valor del tipo Indefinido.

Cualquier propiedad que no tenga asignado un valor, asume el valor indefinido. (ECMA 4.3.9 y 4.3.10).

Una función sin declaración de devolución o una función con una declaración de devolución vacía devuelve indefinido. El valor de un argumento de función sin suministro no está definido.

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" 

indefinido (variable) es una propiedad global, cuyo valor inicial no está definido (valor), Ya que es un mundial de la propiedad también se puede acceder a ella como una variable. Por consistencia, siempre voy a llamarlo una variable en este artículo.

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

A partir de ECMA 3, su valor puede ser reasignado:

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

Ni que decir tiene, la re-asignación de valores a la variable no definida es muy mala práctica, y de hecho no es permitido por ECMA 5.

Answer 2

Undefined es un tipo pero también es una variable global.

Puede tener un módulo que sobrescribe el valor de indefinido haciendo undefined = whatever.

undefined en la realidad es un parámetro definido de una función de envolver todo el código:

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

Es seguro, como el parámetro undefined está en el ámbito local, y nadie excepto el código de esta función puede asignar lo.

No es necesario usar undefined como parámetro cuando se define una función anónima.

Si ve por encima de la función que lo llevaran observa que espera dos parámetros pero uno se suministra.

¿Por qué undefined necesita restaurar?

porque, a asegura que es de hecho undefinedundefined en el alcance entre llaves, incluso si alguien ha escrito algo así como undefined = "defined"; en el ámbito global, porque undefined realidad se puede redefinir.

lo que si tiene algo así como

var undefined = 1; 

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

Answer 3

jQuery es asegurarse de que undefined realmente no está definida dentro de su alcance por no pasar un argumento a ese parámetro.

Tome este código, por ejemplo, cuando en realidad no es undefined indefinido:

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