Quelle est la différence entre null et undefined en JavaScript ?

Question

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

Fournissez dans votre réponse le meilleur lien qui se rapporte à ce sujet en JavaScript.

Answer 1

null est une valeur spéciale signifiant "aucune valeur". null est un objet spécial car typeof null renvoie "objet".

D'un autre côté, undefined signifie que la variable n'a pas été déclarée, ou qu'aucune valeur ne lui a été attribuée.

Source : .

Answer 2

null et indéfini sont deux types d'objets distincts qui ont les points suivants en commun :

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

Les similitudes s'arrêtent cependant là. Pour une fois, il existe une différence fondamentale dans la manière dont les mots-clés null et indéfini sont mises en œuvre. Cela n'est pas évident, mais considérez l'exemple suivant :

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

indéfini , NaN et Infinity sont juste des noms de variables "superglobales" préinitialisées - elles sont initialisées à l'exécution et peuvent être remplacées par des variables globales ou locales normales avec les mêmes noms.

Maintenant, essayons la même chose avec null :

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

Oups ! null , 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 considéré comme un type primitif distinct, tandis que null est considéré comme un objet d'un genre particulier. Considérons 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

De plus, il y a une différence importante dans la façon dont null et indéfini sont traitées 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 (!!!)

null devient 0 lorsqu'il est utilisé dans des expressions arithmétiques ou des comparaisons numériques - de manière similaire à faux il s'agit en fait d'un type particulier de "zéro". indéfini d'autre part, est un véritable "rien" et devient NaN ("not a number") lorsque vous essayez de l'utiliser dans un contexte numérique.

Notez que null et indéfini reçoivent un traitement spécial de la part de == et != mais vous pouvez tester l'égalité numérique réelle des éléments suivants a et b avec l'expression (a >= b && a <= b) .

Answer 3

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

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

Null est une affectation :

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

Answer 4

Dans JavasSript, il existe 5 types de données primitives : String, Number, Boolean, null et undefined. Je vais essayer de vous expliquer avec quelques exemples simples

Disons que nous avons une fonction simple

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

également dans la fonction ci-dessus if(a == null) est identique à if(!a)

maintenant quand nous appelons cette fonction sans passer le paramètre a

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

également

var a;
alert(typeof a); 

cela donnera undefined ; nous avons déclaré une variable mais nous n'avons pas assigné de valeur à cette variable ; mais si nous écrivons

var a = null;
alert(typeof a); will give alert as object

donc null est un objet. en quelque sorte nous avons assigné la valeur null à 'a'.

Answer 5

Null et undefined sont tous deux utilisés pour représenter l'absence d'une certaine valeur.

var a = null;

a est initialisé et défini.

typeof(a)
//object

null est un objet en JavaScript

Object.prototype.toString.call(a) // [object Object]

var b;

b est indéfini et non initialisé

Les propriétés non définies d'un objet sont également non définies. Par exemple, "x" n'est pas défini sur l'objet c et si vous essayez d'accéder à c.x, il retournera undefined.

En général, on attribue la valeur null aux variables qui ne sont pas indéfinies.