differenza tra "vuoto 0" e "indefinito"

Question

sto usando "Closure Compiler", quando si compila miei script passo la seguente:

Prima di compilare:

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

compilato:

// 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 questo credo che la domanda sull'uso di "void 0" e "undefined", c'è qualche differenza nell'uso o i due casi sono buoni ?.

Modifica

se io definisco "var indefinito" compilato con "vuoto 0", se non mi definisco "indefinito" compilato con "undedined.", Quindi non è una questione di numero di caratteri tra "indefinito "e "vuoto 0"

Test

Edit II: prestazioni, sulla base di this link

Code and Test

IE 8:
typeof: 228ms
indefinito: 62ms
vuoto 0: 57ms

Firefox 3.6:
typeof: 10ms
indefinito: 3ms
vuoto 0: 3ms

Opera 11:
typeof: 67ms
indefinito: 19ms
vuoto 0: 20 ms

Chrome 8:
typeof: 3ms
indefinito: 5ms
vuoto 0: 3ms

Answer 1

From MDN:

L'operatore void valuta l'dato expression e quindi restituisce undefined.

Questo operatore consente di inserire espressioni che producono effetti collaterali in luoghi in cui è desiderata un'espressione che restituisce un valore non definito.

L'operatore void viene spesso utilizzato solo per ottenere il valore di base undefined, generalmente utilizzando "void(0)" (che equivale a "void 0"). In questi casi, è possibile utilizzare la variabile globale undefined (supponendo che non sia stata assegnata a un valore non predefinito).

swap chiusura compilatore in void 0 perché contiene meno caratteri undefined, producendo quindi equivalente, codice più piccolo.

---

Re: OP commento

sì, ho letto la documentazione, ma nell'esempio ho dato, "chiusura google" in un caso con "vuoto 0" e un altro "indefinito"

Credo che questo sia in realtà un bug in Google Closure Compiler!

Answer 2

Non c'è differenza, Provate voi stessi:

void 0 === undefined 

valuterà a true.
undefined è caratteri più lunghi, credo che sia il motivo per cui lo usano in questo modo.

Answer 3

La vera unica differenza semantica tra void expr e undefined è che su ECMAScript 3, la undefined proprietà dell'oggetto globale (window.undefined sugli ambienti del browser) è scrivibile, mentre l'operatore void restituirà il undefined valore sempre.

Un modello popolare che è spesso implementata, ad utilizzare undefined senza preoccupazioni è semplicemente dichiarando un argomento, e non passa nulla ad esso:

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

})(); 

che permetterà minifiers a ridursi l'argomento forse per una sola lettera (anche più breve di void 0 :), ad esempio:

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

Answer 4

Basta un follow-up su tutte le risposte prima.

Sembrano uguali, ma al compilatore sono completamente diversi.

Le due sezioni di codice vengono compilate in output diversi perché si fa riferimento a una variabile locale (la var indefinita) e il compilatore si limita a inserirle perché viene utilizzata esattamente una volta e non è più di una riga. Se è usato più di una volta, allora questo in-lining non accadrà. L'in-lining fornisce un risultato di "indefinito", che è più breve da rappresentare come "void 0".

quella senza variabile locale si riferisce al variabile denominata "indefinito" sotto il oggetto globale, che è automaticamente "extern'ed" dalla chiusura compilatore (infatti, tutte le proprietà dell'oggetto globali). Pertanto, non si verifica alcuna ridenominazione e non avviene alcun in-lining. Ecco! ancora "indefinito".