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

Je veux savoir quelle est la différence entre nullet undefineden JavaScript.

En JavaScript, undefinedsignifie qu'une variable a été déclarée mais n'a pas encore reçu de valeur, telle que:

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

nullest une valeur d'affectation. Il peut être affecté à une variable comme une 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 undefinedet nullsont deux types distincts: undefinedest un type lui-même (non défini) tandis que nullest un objet.

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

et

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

J'ai choisi ça d' ici

La valeur non définie est une valeur primitive utilisée lorsqu'aucune valeur n'a été affectée à une variable.

La valeur nulle est une valeur primitive qui représente la référence nulle, vide ou 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 d'utiliser WScript.Echo () ou alert () cette valeur, vous ne verrez rien. Cependant, si vous y ajoutez une chaîne vide, elle 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é contre "undefined". C'est vraiment une petite différence.

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. Bien qu'undefined soit un type à lui tout seul, null est considéré comme une valeur d'objet spécial. 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 soient de types différents, ils agiront toujours de la même manière si vous essayez d'accéder à un membre de l'un ou l'autre, c'est-à-dire qu'ils lèveront 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 la déconseille fortement. Je recommande de définir uniquement les variables sur null et de laisser indéfinie la valeur des é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, confondant facilement même les programmeurs chevronnés, et définir des variables sur null est le meilleur moyen d'éviter les bogues basés sur elle.

Une autre instance où vous verrez une fenêtre contextuelle non définie est lors de l'utilisation de l'opérateur de suppression. Ceux d'entre nous d'un monde C pourraient à tort interpréter cela comme détruisant un objet, mais ce n'est pas le cas. Cette opération consiste à supprimer un indice d'un tableau ou un membre d'un objet. Pour les tableaux, cela n'affecte pas la longueur, mais plutôt que l'indice est désormais 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 un retour non défini lors de la lecture d'un indice ou d'un membre qui n'a jamais existé.

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

(l'ajout de caractères en raison du manque de caractères, donc je suis autorisé à poster ceci.)

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

pensez-y comme une valeur, comme:

• "foo" est une chaîne,
• vrai est booléen,
• 1234 est nombre,
• null n'est pas défini.

indéfini propriété indique qu'une variable n'a pas reçu de valeur incluant null aussi. Comme

var foo;

la variable vide définie est nullde type de donnéesundefined

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

ET null ne représente pas une chaîne sans 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

DONC chacun a sa propre façon d'utiliser

indéfini utiliser pour comparer le type de données variable

null l' utiliser pour vider une valeur d'une variable

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

null : 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 nouvelles variables déclarées avec null , mais ce n'est pas le cas.

S'il vous plaît lisez avec attention. Cela supprimera tous vos doutes concernant la différence entre null et indéfini en JavaScript. Vous pouvez également utiliser la fonction utilitaire indiquée 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 attribuées
3. Variables affectées avec un littéral non défini
4. Variables affectées d'un littéral nul
5. Variables affectées avec autre chose qu'indéfini ou nul

Ce qui suit explique chacun de ces cas un par un

1. Variables non déclarées : ce qui suit est vrai pour les variables non déclarées

   • Ne peut être vérifié que par typeof () qui retourne une chaîne 'undefined'
   • Ne peut pas être vérifié avec == ou === ou par un opérateur if ou conditionnel ? (lance une erreur de référence)

2. Variables déclarées mais non attribuées

   • typeof renvoie une chaîne «non définie»
   • == vérifier avec null renvoie vrai
   • == vérifier avec des retours indéfinis true
   • === vérifier avec null renvoie false
   • === vérifier avec des retours indéfinis true
   • si ou opérateur conditionnel ? renvoie faux

3. Variables affectées avec un littéral non défini : ces variables sont traitées de la même manière que les variables déclarées mais non attribuées .

4. Variables affectées d'un littéral nul

   • typeof renvoie la chaîne 'object'
   • == vérifier avec null renvoie vrai
   • == vérifier avec des retours indéfinis true
   • === vérifier avec null renvoie vrai
   • === vérifier avec des retours non définis false
   • si ou opérateur conditionnel ? renvoie faux

5. Variables affectées avec autre chose qu'indéfini ou nul

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

Ce qui suit fournit l'algorithme pour la vérification de type correcte d'une variable:

1. Vérifiez non déclaré / non affecté / attribué avec non défini à l' aide de typeof . retourne si la chaîne 'non définie' est retournée.
2. Vérifiez null en utilisant === . retourne 'null' si vrai .
3. Vérifiez le type réel à l'aide de typeof . retourne le type s'il n'est pas égal à «objet»
4. Appelez Object.prototype.toString.call (o) pour déterminer le type d'objet réel. Il doit retourner une chaîne de type «[object ObjectType]» pour tous les objets définis en Javascript ou DOM . Pour les objets définis par l'utilisateur, il renvoie '[objet objet]'

Vous pouvez également utiliser la fonction utilitaire 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 
}

Vous pouvez considérer undefined pour représenter une absence de valeur au niveau du système, inattendue ou semblable à une erreur et null pour représenter une absence de valeur au niveau du programme, normale ou attendue.

via JavaScript: Le guide définitif

Je vais vous expliquer undefined, nulletUncaught ReferenceError :

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

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 mission:

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

null et undefined sont deux types d'objets distincts qui ont en commun les éléments suivants:

• les deux ne peuvent contenir qu'une seule valeur, nulle et non définie 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 non définie si vous essayez de lire une propriété inexistante);
• les valeurs nulles et non définies sont considérées comme égales entre elles et à rien d'autre par les opérateurs ==et !=.

Les similitudes s'arrêtent cependant ici. Pour une fois, il existe une différence fondamentale dans la façon dont les mots-clés null et undefined sont implémentés. Ce n'est pas évident, mais considérons l'exemple suivant:

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

indéfini , NaN et Infinity sont que 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 null :

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

Oops! null , true et false sont des mots clés réservés - le compilateur ne vous permet pas de les utiliser comme noms de variable ou de propriété

Une autre différence est que undefined est un type primitif, alors que null 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 dont null et undefined 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 (!!!)

null devient 0 lorsqu'il est utilisé dans des expressions arithmétiques ou des comparaisons numériques - de manière similaire à false , il s'agit essentiellement d'un type spécial de "zéro". undefined , d'autre part, est un vrai "rien" et devient NaN ("pas un nombre") lorsque vous essayez de l'utiliser dans un contexte numérique.

Notez que null et undefined reçoivent un traitement spécial de la part des opérateurs ==et !=, mais vous pouvez tester la véritable égalité numérique de a et b avec l'expression (a >= b && a <= b).

tl; dr

Utilisez nullpour définir une variable que vous savez qu'il s'agit d'un objet.

Utilisez undefinedpour définir une variable dont le type est mixte.

Ceci est mon utilisation des 5 primitives et du type d'objet, et cela explique la différence entre «cas d'utilisation» de undefinedor null.

Chaîne

Si vous savez qu'une variable n'est qu'une chaîne alors que tout le cycle de vie, par convention, vous pouvez l'initialiser pour "":

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

Nombre

Si vous savez qu'une variable n'est qu'un nombre alors que tout le cycle de vie, par convention, vous pouvez l'initialiser 0(ou NaNs'il 0s'agit d'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 savez qu'une variable n'est qu'un booléen alors que tout le cycle de vie, par convention, vous pouvez l'initialiser pour false:

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

Objet

Si vous savez qu'une variable n'est qu'un objet alors que tout le cycle de vie, par convention, vous pouvez l'initialiser pour null:

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

Remarque: l'utilisation intelligente hors null doit être la version falsifiée d'un objet car un objet l'est toujours trueet parce que typeof nullreturn object. Cela signifie typeof myVarObjectrenvoyer une valeur cohérente pour le type Object et null.

Tout

Si vous savez qu'une variable a un type mixte (n'importe quel type pendant tout le cycle de vie), par convention, vous pouvez l'initialiser à undefined.

nullest une valeur spéciale qui signifie "aucune valeur". nullest un objet spécial car typeof nullrenvoie «objet».

En revanche, undefinedsignifie que la variable n'a pas été déclarée ou n'a pas reçu de valeur.

La meilleure façon de comprendre la différence est de d'abord vider votre esprit du fonctionnement interne de JavaScript et de simplement comprendre les différences de sens entre:

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

Il y a une différence de sens entre ces trois cas, et JavaScript distingue les deux derniers cas avec deux valeurs différentes, nulletundefined . Vous êtes libre d'utiliser ces valeurs explicitement pour transmettre ces significations.

Alors, quels sont les problèmes spécifiques à JavaScript qui se posent en raison de cette base philosophique?

1. Une variable déclarée sans initialiseur obtient la valeur undefinedcar vous n'avez jamais rien dit sur la valeur prévue.

   let supervisor;
   assert(supervisor === undefined);

2. Une propriété d'un objet qui n'a jamais été définie est évaluée undefinedcar personne n'a jamais rien dit sur cette propriété.

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);

3. nullet undefinedsont "similaires" les uns aux autres parce que Brendan Eich l'a dit. Mais ils ne sont absolument pas égaux entre eux.

   assert(null == undefined);
   assert(null !== undefined);

4. nullet undefinedheureusement avoir différents types. nullappartient au type Nullet undefinedau type Undefined. C'est dans la spécification, mais vous ne le sauriez jamais à cause de l' typeofétrangeté que je ne répéterai pas ici.

5. Une fonction atteignant la fin de son corps sans une déclaration de retour explicite renvoie undefinedpuisque vous ne savez rien de ce qu'elle a renvoyé.

Soit dit en passant, il existe d'autres formes de "néant" en JavaScript (c'est bien d'avoir étudié la philosophie ...)

• NaN
• Utiliser une variable qui n'a jamais été déclarée et recevoir un ReferenceError
• Utiliser une variable locale letou constdéfinie dans sa zone morte temporelle et recevoir unReferenceError

• Cellules vides dans des tableaux clairsemés. Oui, ce ne sont même pas undefinedbien qu'ils se comparent ===à indéfinis.

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]

Dans JavasSript, il existe 5 types de données primitifs String, Number, Boolean, null et undefined. Je vais essayer d'expliquer avec un exemple simple

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 si (a == null) est le même que si (! 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;

aussi

var a;
alert(typeof a); 

cela donnera indéfini; nous avons déclaré une variable mais nous n'avons attribué aucune valeur à cette variable; mais si on écrit

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

donc null est un objet. d'une certaine manière, nous avons attribué une valeur nulle à «a»

Pour le undefinedtype, il existe une et une seule valeur:undefined .

Pour le nulltype, il existe une et une seule valeur:null .

Donc pour les deux, le label est à la fois son type et sa valeur.

La différence entre eux. Par exemple:

• null est une valeur vide
• undefined est une valeur manquante

Ou:

• undefined n'a pas encore de valeur
• null avait une valeur et n'a plus

En fait, nullest un mot-clé spécial - , pas un identifiant, et donc vous ne pouvez pas le traiter comme une variable à affecter.

Cependant, undefinedc'est un identifiant . En non-strictmode et en strictmode, cependant, vous pouvez créer une variable locale du nom non défini. Mais c'est une terrible idée!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

Lorsque vous déclarez une variable en javascript, la valeur lui est affectée undefined. Cela signifie que la variable est intacte et peut être affectée à n'importe quelle valeur à l'avenir. Cela implique également que vous ne connaissez pas la valeur que cette variable va contenir au moment de la déclaration.

Vous pouvez maintenant attribuer explicitement une variable null . Cela signifie que la variable n'a aucune valeur. Par exemple - Certaines personnes n'ont pas de deuxième prénom. Dans un tel cas, il est donc préférable d'affecter la valeur null à la variable de nom intermédiaire d'un objet personne.

Supposons maintenant que quelqu'un accède à la variable middlename de votre objet person et qu'elle ait la valeur undefined. Il ne saurait pas si le développeur a oublié d'initialiser cette variable ou si elle n'a aucune valeur. S'il a la valeur null, alors l'utilisateur peut facilement déduire que le nom intermédiaire n'a aucune valeur et qu'il ne s'agit pas d'une variable intacte.

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 n'est pas défini et n'est pas initialisé

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

Généralement, nous attribuons null à des variables non indéfinies.

Par l'article complet de Ryan Morr sur ce sujet ...

"En général, si vous devez attribuer une non-valeur à une variable ou à une propriété, la transmettre à une fonction ou la renvoyer à partir d'une fonction, null est presque toujours la meilleure option. Pour le dire simplement, JavaScript utilise undefined et les programmeurs doivent utilisez null. "

Voir Exploration de l'abîme éternel de nul et indéfini

Null et non défini en JavaScript indiquent l'absence de valeur.

var a = null; //variable assigned null value
var b;  // undefined

Malgré le fait que les deux existent pour l'absence de valeur, mais: Undefined signifie en fait que la variable n'est pas initialisée. Fonctions qui ne renvoient rien et paramètres de fonction pour lesquels aucune valeur n'est fournie, une valeur non définie est renvoyée. Utilisez l'opérateur d'égalité stricte === pour faire la distinction entre null et indéfini.

Référence: http://www.thesstech.com/javascript/null-and-undefined

OK, nous pouvons être confus lorsque nous en entendons parler nullet undefined, mais commençons simplement, ils sont tous deux faux et similaires à bien des égards, mais une partie étrange de JavaScript, en fait quelques différences importantes, par exemple, typeof null est 'object'tandis que typeof undefined est 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

Mais si vous les vérifiez ==comme ci-dessous, vous voyez qu'ils sont tous les deux faux :

null==undefined; //true

Vous pouvez également affecter nullà une propriété d'objet ou à une primitive, tout enundefined simplement atteint en n'attribuant à rien.

Je crée une image rapide pour vous montrer les différences en un coup d'œil.

Comme typeof renvoie undefined, undefined est un type où comme null est un initialiseur indique que la variable ne pointe vers aucun objet (pratiquement tout en Javascript est un objet).

En javascript, toutes les variables sont stockées sous forme de paires de valeurs clés. Chaque variable est stockée sous nom_variable: valeur_variable / référence .

undefined signifie qu'une variable a reçu un espace en mémoire, mais aucune valeur ne lui est affectée. En tant que meilleure pratique, vous ne devez pas utiliser ce type comme affectation.

Dans ce cas, comment indiquer quand vous souhaitez qu'une variable soit sans valeur à un stade ultérieur du code? Vous pouvez utiliser le type null , qui est également un type utilisé pour définir la même chose, l'absence de valeur, mais ce n'est pas la même chose que non défini, car dans ce cas, vous avez réellement la valeur en mémoire. Cette valeur est nulle

Les deux sont similaires mais l'usage et le sens sont différents.

Je veux ajouter une différence très subtile entre nullet undefinedce qui est bon à savoir lorsque vous essayez d'apprendre de Vanilla JavaScript (JS) de fond en comble:

• nullest un mot clé réservé dans JS while undefinedest une variable sur l'objet global de l'environnement d'exécution dans lequel vous vous trouvez.

Lors de l'écriture de code, cette différence n'est pas identifiable comme les deux nullet undefinedest toujours utilisée dans RHS d'une instruction JavaScript. Mais lorsque vous les utilisez dans LHS d'une expression, vous pouvez facilement observer cette différence. L'interpréteur JS interprète donc le code ci-dessous comme une erreur:

var null = 'foo'

Il donne l'erreur ci-dessous:

SyntaxError non capturée: null de jeton inattendu

Bien que le code ci-dessous fonctionne correctement, je ne le recommanderai pas dans la vraie vie:

var undefined = 'bar'

Cela fonctionne car il undefineds'agit d'une variable sur l'objet global (objet de fenêtre de navigateur en cas de JS côté client)

La différence entre undefinedet nullest minime, mais il y a une différence. Une variable dont la valeur est undefinedn'a jamais été initialisée. Une variable dont la valeur est nulla reçu explicitement une valeur de null, ce qui signifie que la variable a été explicitement définie pour n'avoir aucune valeur. Si vous comparez undefinedet nullen utilisant l' null==undefinedexpression, ils seront égaux.

Fondamentalement, Undefined est une variable globale que javascript crée au moment de l'exécution, que null signifie qu'aucune valeur n'a été attribuée à la variable (en fait, null est lui-même un objet).

Prenons un exemple:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

Indéfini, c'est ce que vous obtiendrez en sortie.

Maintenant,

        x=5;
        y=null;
        z=x+y;

et vous obtiendrez 5 en sortie. C'est la principale différence entre l' indéfini et le null

null - C'est une valeur d'affectation, qui est utilisée avec une variable pour ne représenter aucune valeur (c'est un objet).

undefined - Il s'agit d'une variable à laquelle aucune valeur ne lui est affectée, donc JavaScript lui affectera un indéfini (c'est un type de données).

non déclaré - Si une variable n'est pas créée du tout, elle est connue comme non déclarée.

Regarde ça. La sortie vaut mille mots.

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

Voir également:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

À votre santé!

Les deux valeurs spéciales impliquent un état vide.

La principale différence est que undefined représente la valeur d'une variable qui n'a pas encore été initialisée, tandis que null représente une absence intentionnelle d'un objet.

Le numéro de variable est défini, cependant, n'est pas affecté avec une valeur initiale:

let number;
number; // => undefined

la variable numérique n'est pas définie, ce qui indique clairement une variable non initialisée

Le même concept non initialisé se produit lors de l'accès à une propriété d'objet non existante:

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

Étant donné que la propriété lastName n'existe pas dans obj, JavaScript évalue correctement obj.lastName à undefined.

Dans d'autres cas, vous savez qu'une variable s'attend à contenir un objet ou une fonction pour renvoyer un objet. Mais pour une raison quelconque, vous ne pouvez pas instancier l'objet. Dans un tel cas, null est un indicateur significatif d'un objet manquant.

Par exemple, clone () est une fonction qui clone un objet JavaScript simple. La fonction devrait renvoyer un objet:

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

Cependant, clone () peut être invoqué avec un argument non-objet: 15 ou null (ou généralement une valeur primitive, null ou indéfinie). Dans ce cas, la fonction ne peut pas créer de clone, elle renvoie donc null - l'indicateur d'un objet manquant.

L' opérateur typeof fait la distinction entre les deux valeurs:

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

L'opérateur de qualité strict === différencie correctement undefined de null:

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

En plus d'une signification différente, il existe d'autres différences:

1. La déstructuration d'objets fonctionne différemment pour ces deux valeurs:

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null

2. JSON.stringify () conserve nullmais ometundefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}

3. type d'opérateur

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"

Si une variable n'est pas initialisée, elle n'est pas définie. undefined n'est pas un objet. Exemple: var MyName; console.log (typeof MyName);

Vérifiez le journal de la console dans l'outil de développement, il sera imprimé comme non défini.

null est un objet. Si vous voulez qu'une variable soit nulle, alors null est utilisé. une variable nulle existe mais la valeur n'est pas connue. Elle doit être affectée grammaticalement à une variable pro. null n'est pas initialisé automatiquement.

Exemple: var MyName = null; console.log (typeof MyName); Vérifiez le journal de csole dans l'outil de développement, ce sera un objet.