javascript - google - uglifyjs

diferencia entre "vacío 0" e "indefinido"

Question

Estoy usando "Closure Compiler" , cuando compilo mis scripts, gasto lo siguiente:

Antes de compilar:

// ==ClosureCompiler==
// @compilation_level SIMPLE_OPTIMIZATIONS
// @output_file_name default.js
// @formatting pretty_print,print_input_delimiter
// ==/ClosureCompiler==
var myObj1 = (function() {
var undefined; //<----- declare undefined
this.test = function(value, arg1) {
var exp = 0;
arg1 = arg1 == undefined ? true : arg1; //<----- use declare undefined
exp = (arg1) ? value * 5 : value * 10;
return exp;
};
return this;
}).call({});
var myObj2 = (function() {
this.test = function(value, arg1) {
var exp = 0;
arg1 = arg1 == undefined ? true : arg1; //<----- without declare undefined
exp = (arg1) ? value * 5 : value * 10;
return exp;
};
return this;
}).call({});

Compilado:

// Input 0
var myObj1 = function() {
this.test = function(b, a) {
a = a == void 0 ? true : a; //<-----
var c = 0;
return c = a ? b * 5 : b * 10
};
return this
}.call({}), myObj2 = function() {
this.test = function(b, a) {
a = a == undefined ? true : a; //<-----
var c = 0;
return c = a ? b * 5 : b * 10
};
return this
}.call({});

Con esto creo que la cuestión del uso de "vacío 0" y "indefinido", ¿hay alguna diferencia en el uso o los dos casos están bien ?.

Editar

si defino "var undefined" compilado con "void 0", si no definí "undefined" compilado con "undeined", entonces no es cuestión de número de caracteres entre "undefined" y "void 0"

Test

Editar II: rendimiento, basado en este enlace

Código y prueba

IE 8:
typeof: 228ms
indefinido: 62 ms
vacío 0: 57ms

Firefox 3.6:
typeof: 10 ms
indefinido: 3ms
vacío 0: 3ms

Opera 11:
typeof: 67ms
indefinido: 19ms
vacío 0: 20ms

Chrome 8:
typeof: 3ms
indefinido: 5ms
vacío 0: 3ms

Answer 1

La única diferencia semántica real entre void expr e undefined es que en ECMAScript 3 , la propiedad undefined del objeto global ( window.undefined en entornos de navegador) es escribible, mientras que el operador void devolverá siempre el valor undefined .

Un patrón popular que a menudo se implementa, usar undefined sin preocupaciones es simplemente declarar un argumento y no pasarle nada:

(function (undefined) {
//...
if (foo !== undefined) {
// ...
}
})();

Eso permitirá a los minificadores reducir el argumento tal vez a una sola letra (incluso más corta que el void 0 :), por ejemplo:

(function (a) {
//...
if (foo !== a) {
// ...
}
})();

Answer 2

No hay diferencia, Pruébelo usted mismo:

void 0 === undefined

evaluará a true .
undefined tiene 3 caracteres más, creo que es la razón por la que lo usan de esa manera.

Answer 3

Solo un seguimiento de todas las respuestas anteriores.

Se ven iguales, pero para el compilador son completamente diferentes.

Las dos secciones de código compilan diferentes salidas porque una hace referencia a una variable local (var indefinida) y el compilador simplemente la alinea porque se usa exactamente una vez y no tiene más de una línea. Si se usa más de una vez, entonces este forro interior no ocurrirá. El revestimiento interior proporciona un resultado de "indefinido", que es más corto para representar como "vacío 0".

El que no tiene una variable local se refiere a la variable llamada "indefinida" debajo del objeto global , que es automáticamente "externa" por el compilador de cierre (de hecho, todas las propiedades del objeto global son). Por lo tanto, no tiene lugar el cambio de nombre, y no tiene lugar el revestimiento. Voila! todavía "indefinido".

Answer 4

De MDN :

El operador void evalúa la expression dada y luego devuelve undefined .

Este operador permite insertar expresiones que producen efectos secundarios en lugares donde se desea una expresión que se evalúa como indefinida.

El operador vacío a menudo se usa meramente para obtener el valor primitivo undefined , usualmente usando " void(0) " (que es equivalente a " void 0 "). En estos casos, la variable global undefined se puede usar en su lugar (suponiendo que no se haya asignado a un valor no predeterminado).

El Compilador de cierres se intercambia en el void 0 porque contiene menos caracteres que los undefined , por lo tanto , produce un código equivalente y más pequeño .

Re: OP comentario

sí, leí la documentación, pero en el ejemplo que di, "cierre de google" en un caso que usa "vacío 0" y otro "indefinido"

¡Creo que esto es un error en Google Closure Compiler !