web-dev-qa-db-fra.com

différence entre "void 0" et "undefined"

J'utilise "Closure Compiler" , lors de la compilation de mes scripts, je dépense 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 cela, 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: performances, basées sur ce lien

Code et test

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

Firefox 3.6:
typeof: 10 ms
non défini: 3 ms
void 0: 3ms

Opera 11:
typeof: 67ms
non défini: 19 ms
void 0: 20ms

Chrome 8:
typeof: 3 ms
non défini: 5 ms
void 0: 3ms

javascriptgoogle-closuregoogle-closure-compiler
59
andres descalzo

De MDN :

L'opérateur void évalue le expression donné, puis renvoie undefined.

Cet opérateur permet d'insérer des expressions qui produisent des effets secondaires dans des endroits où une expression évaluée à indéfinie est souhaitée.

L'opérateur void est souvent utilisé simplement pour obtenir la valeur primitive undefined, généralement en utilisant "void(0)" (ce qui équivaut à "void 0 "). Dans ces cas, la variable globale undefined peut être utilisée à la place (en supposant qu'elle n'a pas été affectée à une valeur non par défaut).

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

Re: OP commentaire

oui, j'ai lu la documentation, mais dans l'exemple que j'ai donné, "fermeture google" dans un cas utilisant "void 0" et un autre "non défini"

Je crois que c'est en fait un bug dans Google Closure Compiler !

67
Matt Ball

La vraie différence sémantique entre void expr et undefined est celle sur ECMAScript, la propriété undefined de l'objet global (window.undefined sur les environnements de navigation) est accessible en écriture, tandis que l'opérateur void renverra la valeur undefinedtoujours.

Un modèle populaire qui est souvent implémenté, pour utiliser undefined sans soucis, c'est simplement déclarer un argument, et ne rien lui passer:

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

})();

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

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

Juste un suivi de toutes les réponses avant.

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

Les deux sections de code sont compilées sur des sorties différentes car l'une fait référence à une variable locale (la variable non définie), et le compilateur l'inline simplement car elle est utilisée exactement une fois et ne comporte pas plus d'une ligne. S'il est utilisé plus d'une fois, cette doublure ne se produira pas. La doublure intérieure fournit un résultat de "non défini", qui est plus court pour représenter "vide 0".

Celui sans variable locale fait référence à la variable appelée "indéfinie" sous objet global, qui est automatiquement "externalisée" par le compilateur de fermeture (en fait, toutes les propriétés d'objet global le sont). Par conséquent, aucun changement de nom n'a lieu et aucun alignement n'a lieu. Voila! toujours "indéfini".

8
Stephen Chung

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

void 0 === undefined

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

4
jAndy