différence entre "void 0" et "undefined" (non défini)

Question

J'utilise "Compilateur de fermetures" En compilant mes scripts, je passe ce qui suit :

Avant de compiler :

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

Compilé :

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

Avec ceci je crois que la question de l'utilisation de "void 0" et "undefined", y a-t-il une différence dans l'utilisation ou les deux cas sont bien ?

Modifier

si je définis "var undefined" compilé avec "void 0 ", si je n'ai pas défini "undefined" compilé avec "undedined. "alors ce n'est pas une question de nombre de caractères entre "undefined" et "void 0".

Test

Edit II : performance, basée sur ce lien

Code et test

IE 8 :
typeof : 228ms
indéfini : 62ms
void 0 : 57ms

Firefox 3.6 :
typeof : 10ms
indéfini : 3ms
void 0 : 3ms

Opéra 11 :
typeof : 67ms
indéfini : 19ms
void 0 : 20ms

Chrome 8 :
typeof : 3ms
indéfini : 5ms
void 0 : 3ms

Answer 1

De MDN :

El void évalue l'opérateur expression et renvoie ensuite undefined .

Cet opérateur permet d'insérer des expressions qui produisent des effets secondaires à des endroits où l'on souhaite obtenir une expression dont l'évaluation est indéfinie.

L'opérateur void est souvent utilisé uniquement pour obtenir l'information suivante undefined valeur primitive, en utilisant généralement " void(0) "(ce qui est équivalent à " void 0 "). Dans ces cas, la variable globale undefined peut être utilisé à la place (en supposant qu'il n'a pas été affecté à une valeur autre que celle par défaut).

Le compilateur Closure remplace void 0 car il contient moins de caractères que undefined , produisant ainsi un code équivalent et plus petit .

---

Re : Commentaire de l'OP

Oui, j'ai lu la documentation, mais dans l'exemple que j'ai donné, "google closure" dans un cas utilisant "void 0" et un autre "undefined".

Je crois que c'est en fait bug dans le compilateur Google Closure !

Answer 2

La seule différence sémantique réelle entre void expr y undefined est que sur ECMAScript 3 le undefined de l'objet global ( window.undefined sur les environnements de navigation) est accessible en écriture, alors que le fichier void retournera l'opérateur undefined valeur toujours .

Un modèle populaire qui est souvent mis en œuvre, d'utiliser undefined sans soucis est simplement de déclarer un argument, et de ne rien lui passer :

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

})();

Cela permettra aux minifieurs de réduire l'argument peut-être à une seule lettre (même plus court que void 0 :), par exemple :

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

Answer 3

Juste un suivi de toutes les réponses précédentes.

Ils se ressemblent, mais pour le compilateur, ils sont complètement différents.

Les deux sections de code se compilent avec des résultats différents parce que l'une d'entre elles fait référence à une variable locale (la var undefined), et le compilateur la met simplement en ligne parce qu'elle est utilisée exactement une fois et ne dépasse pas une ligne. Si elle est utilisée plus d'une fois, l'alignement ne se fera pas. L'in-lining fournit un résultat "undefined", qui est plus court à représenter comme "void 0".

Celle qui ne comporte pas de variable locale fait référence à la variable appelée "undefined" dans le fichier objet global qui est automatiquement "externalisé" par le compilateur de fermetures (en fait, toutes les propriétés globales des objets le sont). Par conséquent, il n'y a pas de renommage, ni de doublage. Voila ! toujours "undefined".

Answer 4

Il n'y a aucune différence, essayez-le vous-même :

void 0 === undefined

évaluera à true .
undefined es 3 caractères plus longs, je suppose que c'est la raison pour laquelle ils l'utilisent de cette façon.