Question Quelle est la différence entre null et indéfini dans JavaScript?


Je veux savoir quelle est la différence entre null et undefined en JavaScript.


826
2018-02-22 10:30


origine


Réponses:


En JavaScript, undefined signifie qu'une variable a été déclarée mais n'a pas encore reçu de valeur, par exemple:

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

null est une valeur d'affectation. Il peut être affecté à une variable en tant que représentation sans valeur:

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

D'après les exemples précédents, il est clair que undefined et null sont deux types distincts: undefined est un type lui-même (indéfini) null est un objet.

null === undefined // false
null == undefined // true
null === null // true

et

null = 'value' // ReferenceError
undefined = 'value' // 'value'

825
2018-02-22 10:31



Je l'ai choisi de ici 

La valeur indéfinie est une valeur primitive utilisée lorsqu'une variable n'a pas   été attribué une valeur.

La valeur null est une valeur primitive qui représente le null, vide,   ou référence inexistante.

Lorsque vous déclarez une variable via var et ne lui donnez pas de valeur, elle aura la valeur indéfinie. En soi, si vous essayez de WScript.Echo () ou alert () cette valeur, vous ne verrez rien. Cependant, si vous ajoutez une chaîne vide, cela apparaîtra soudainement:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

Vous pouvez déclarer une variable, la définir sur null, et le comportement est identique, sauf que vous verrez "null" imprimé par rapport à "non défini". C'est une petite différence en effet.

Vous pouvez même comparer une variable non définie à null ou vice versa, et la condition sera vraie:

undefined == null
null == undefined

Ils sont cependant considérés comme deux types différents. Alors que undefined est un type tout en lui-même, null est considéré comme une valeur d'objet spéciale. Vous pouvez le voir en utilisant typeof () qui retourne une chaîne représentant le type général d'une variable:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

L'exécution du script ci-dessus entraînera la sortie suivante:

undefined
object

Indépendamment du fait qu'ils sont de types différents, ils agissent toujours de la même manière si vous essayez d'accéder à un membre de l'un ou l'autre, par ex. c'est-à-dire qu'ils vont lancer une exception. Avec WSH vous verrez le redouté "'varname" est nul ou pas un objet "et c'est si vous êtes chanceux (mais c'est un sujet pour un autre article).

Vous pouvez explicitement définir une variable pour qu'elle ne soit pas définie, mais je vous déconseille fortement de le faire. Je recommande de ne définir que des variables sur null et de laisser la valeur non définie pour les éléments que vous avez oublié de définir. En même temps, je vous encourage vraiment à toujours définir chaque variable. JavaScript a une chaîne de portée différente de celle des langages de style C, compliquant facilement même les programmeurs chevronnés, et la mise à zéro des variables est le meilleur moyen d'éviter les bogues basés dessus.

Une autre instance où vous verrez une fenêtre pop indéfinie est lors de l'utilisation de l'opérateur de suppression. Ceux d'entre nous qui proviennent d'un monde C pourraient interpréter incorrectement cela comme détruisant un objet, mais ce n'est pas le cas. Cette opération supprime un indice d'un tableau ou un membre d'un objet. Pour les tableaux, cela n'affecte pas la longueur, mais plutôt cet indice est maintenant considéré comme non défini.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

Le résultat du script ci-dessus est:

0.) a
1.) undefined
2.) c

Vous obtiendrez également indéfini renvoyé lors de la lecture d'un indice ou d'un membre qui n'a jamais existé.

La différence entre null et indéfini est la suivante: JavaScript ne définira jamais rien à null, c'est généralement ce que nous faisons. Bien que nous puissions définir des variables à undefined, nous préférons null parce que ce n'est pas quelque chose qui est fait pour nous. Lorsque vous déboguez, cela signifie que tout ce qui est défini sur null est de votre propre initiative et pas JavaScript. Au-delà, ces deux valeurs spéciales sont presque équivalentes.


58
2018-02-22 10:34



nul est un mot-clé spécial qui indique une absence de valeur.

Pensez-y comme une valeur, comme:

  • "foo" est une chaîne,
  • true est booléen,
  • 1234 est le nombre,
  • null est indéfini.

indéfini property indique qu'une valeur n'a pas été affectée à une variable, y compris null. Comme

var foo;

variable vide définie est null de type de données undefined


Les deux représentent une valeur d'une variable sans valeur

ET null ne représente pas chaîne qui n'a pas de valeur - chaîne vide-


Comme

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

Maintenant si

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

MAIS

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

ALORS chacun a sa propre façon d'utiliser

indéfini utilisez-le pour comparer le type de données variable

nul utilisez-le pour vider une valeur d'une variable

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

27
2017-10-25 20:58



nul: absence de valeur pour une variable; indéfini: absence de variable elle-même;

La variable ..where est un nom symbolique associé à une valeur.

JS pourrait être assez aimable pour initier implicitement les variables nouvellement déclarées avec nulmais ce n'est pas le cas.


13
2017-07-03 13:59



S'il vous plaît lisez avec attention. Il supprimera tous vos doutes concernant la différence entre nul et indéfini en JavaScript. Vous pouvez également utiliser la fonction d'utilité ci-dessous pour déterminer exactement les types.

En JavaScript, nous pouvons avoir les types de variables suivants.

  1. Variables non déclarées
  2. Variables déclarées mais non assignées
  3. Variables affectées au littéral indéfini
  4. Variables affectées au littéral nul
  5. Variables affectées à autre chose que indéfini ou nul

La suite explique chacun de ces cas un par un

  1. Variables non déclarées: La suite est vraie pour les variables non déclarées

    • Peut seulement être vérifié par Type de() qui retourne la chaîne 'indéfini'
    • Ne peut pas être vérifié avec == ou === ou par si ou opérateur conditionnel ?         (lève l'erreur de référence)
  2. Variables déclarées mais non assignées

    • Type de renvoie la chaîne 'indéfini'
    • == vérifier avec nul résultats vrai
    • == vérifier avec indéfini résultats vrai
    • === vérifier avec nul résultats faux
    • === vérifier avec indéfini résultats vrai
    • si ou opérateur conditionnel ? résultats faux
  3. Variables affectées au littéral  indéfini: Ces variables sont traitées de la même manière que Déclarées mais variables non assignées.

  4. Variables affectées au littéral  nul

    • Type de renvoie la chaîne 'objet'
    • == vérifier avec nul résultats vrai
    • == vérifier avec indéfini résultats vrai
    • === vérifier avec nul résultats vrai
    • === vérifier avec indéfini résultats faux
    • si ou opérateur conditionnel ? renvoie false
  5. Variables affectées à autre chose que  indéfini ou nul

    • typeof renvoie l'une des chaînes suivantes: 'chaîne','nombre','booléen','fonction', 'objet','symbole'

La suite fournit l'algorithme pour la vérification de type correcte d'une variable:

  1. Vérifier non déclaré/Non attribué/assigné avec  indéfini en utilisant Type de. retourne si chaîne 'indéfini' est retourné.
  2. Vérifier nul en utilisant ===. revenir 'nul' si vrai.
  3. Vérifiez le type réel en utilisant Type de. type de retour sinon égal à 'objet'
  4. Appel Object.prototype.toString.call (o) pour déterminer le type d'objet réel. Il doit retourner une chaîne de caractères '[objet ObjectType]'pour tout le Javascript intégré ou DOM objets définis. Pour les objets définis par l'utilisateur, il renvoie '[objet Objet]'

Vous pouvez également utiliser la fonction d'utilité suivante pour déterminer les types. Il prend actuellement en charge tous les types ECMA 262 2017.

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

10
2017-09-21 13:05



Undefined signifie qu'une variable a été déclarée mais n'a aucune valeur:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Null est une tâche:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

7
2018-02-22 10:34



Vous pouvez considérer non défini comme représentant une absence de valeur au niveau du système, inattendue ou semblable à une erreur et null comme une absence de valeur au niveau du programme, normal ou prévu.

via JavaScript: le guide définitif


7
2018-06-29 08:37



je vais t'expliquer undefined, null et Uncaught ReferenceError:

1 - Uncaught ReferenceError : variable n'a pas été déclaré dans votre script, il n'y a aucune référence à cette varaible
2 - undefined: Variable déclarée mais non initialisée
3 - null : Variable déclarée et est une valeur vide


7
2018-02-10 15:09



nul et indéfini sont deux types d'objets distincts qui ont ceci en commun:

  • les deux ne peuvent contenir qu'une seule valeur, nul et indéfini respectivement;
  • les deux n'ont pas de propriétés ou de méthodes et une tentative de lecture des propriétés de l'une ou l'autre entraînera une erreur d'exécution (pour tous les autres objets, vous obtenez une valeur indéfini si vous essayez de lire une propriété inexistante);
  • valeurs nul et indéfini sont considérés comme égaux entre eux et à rien d'autre par == et != les opérateurs.

Les similitudes se terminent cependant ici. Pour une fois, il y a une différence fondamentale dans la façon dont les mots-clés nul et indéfini sont mis en œuvre. Ce n'est pas évident, mais considérez l'exemple suivant:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

indéfini, NaN et Infini sont juste des noms de variables "superglobales" préinitialisées - elles sont initialisées au moment de l'exécution et peuvent être remplacées par une variable globale ou locale normale portant les mêmes noms.

Maintenant, essayons la même chose avec nul:

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Oops! nul, vrai et faux sont des mots-clés réservés - le compilateur ne vous laissera pas les utiliser comme noms de variables ou de propriétés

Une autre différence est que indéfini est un type primitif, tandis que nul est un type d'objet (indiquant l'absence d'une référence d'objet). Considérer ce qui suit:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

En outre, il existe une différence importante dans la façon nul et indéfini sont traités dans un contexte numérique:

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

nul devient 0 lorsqu'il est utilisé dans des expressions arithmétiques ou des comparaisons numériques - de même que faux, c'est fondamentalement juste un genre spécial de "zéro". indéfini, d'autre part, est un vrai "rien" et devient NaN ("not a number") lorsque vous essayez de l'utiliser dans un contexte numérique.

Notez que nul et indéfini recevoir un traitement spécial de == et != opérateurs, mais vous pouvez tester l'égalité numérique véritable de une et b avec l'expression (a >= b && a <= b).


7
2018-03-16 04:20



tl; dr

Utilisation null pour définir une variable, vous savez que c'est un objet.

Utilisation undefined pour définir une variable dont le type est mélangé.


C'est mon utilisation à la fois des 5 primitives et du type Object, et cela explique la différence entre «use case» de undefined ou null.

Chaîne

Si vous connaissez une variable est seulement une chaîne tout le cycle de vie, par convention, vous pouvez l'initialiser, à "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Nombre

Si vous connaissez une variable est seulement un nombre tout le cycle de vie, par convention, vous pouvez l'initialiser, à 0 (ou NaN si 0 est une valeur importante dans votre utilisation):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

ou

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

Booléen

Si vous connaissez une variable est seulement un booléen alors que tout le cycle de vie, par convention, vous pouvez l'initialiser, à false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

Objet

Si vous connaissez une variable est seulement un objet tout le cycle de vie, par convention, vous pouvez l'initialiser, à null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Remarque: l'utilisation intelligente de null doit être le falsification version d'un objet car un objet est toujours true, et parce que typeof null revenir object. Cela signifie typeof myVarObject renvoie une valeur cohérente pour le type Object et null.

Tout

Si vous connaissez une variable a un type mixte (tout type tout tout cycle de vie), par convention, vous pouvez l'initialiser, à undefined.


5
2018-01-19 18:15