Quelle est la différence entre null et non défini dans JavaScript?

j'ai choisi ceci de ici

la valeur non définie est une valeur primitive utilisée lorsqu'une variable n'a pas été attribué une valeur.

la valeur nulle est une valeur primitive qui représente la valeur nulle, vide, ou référence inexistante.

lorsque vous déclarez une variable via var et que vous ne lui donnez pas de valeur, elle aura la valeur non définie. Par lui-même, si vous essayez de 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 à null, et le comportement est identique sauf que vous verrez" null "imprimé versus"non défini". C'est une petite différence en effet.

vous pouvez même comparer une variable qui n'est pas définie à null ou vice versa, et la condition sera true:

undefined == null
null == undefined

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

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

L'exécution du script ci-dessus donnera la sortie suivante:

undefined
object

Qu'ils soient de types différents, ils agiront toujours de la même façon si vous essayez d'accéder à un membre de l'un d'eux, par exemple, 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 non définie, mais je vous déconseille fortement de le faire. Je recommande de définir uniquement les variables à null et de laisser indéfini la valeur pour les choses que vous avez oublié de définir. En même temps, je vous encourage vraiment à toujours régler chaque variable. JavaScript dispose d'une chaîne scope différente de celle des langages de style C, créant facilement de la confusion même pour les programmeurs vétérans, et le réglage des variables à null est la meilleure façon d'éviter les bogues basés sur elle.

une autre instance où vous verrez apparaître un pop up Non défini est lorsque vous utilisez l'opérateur delete. Ceux d'entre nous qui viennent d'un monde en C pourraient à tort interpréter cela comme la destruction d'un objet, mais ce n'est pas le cas. Ce que cette opération fait est supprimer un indice d'un tableau ou un membre d'un Objet. Pour les tableaux, il n'affecte pas la longueur, mais plutôt que l'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 Non défini retourné lors de la lecture d'un indice ou d'un membre qui n'a jamais existé.

la différence entre null et non défini est: JavaScript ne définira jamais rien à null, c'est généralement ce que nous faisons. Alors que nous pouvons mettre en variables à non défini, nous préférons null parce que ce n'est pas quelque chose qui est jamais fait pour nous. Quand vous déboguez cela signifie que tout ce qui est défini à null est de votre fait et non JavaScript. Au-delà de cela, ces deux valeurs spéciales sont presque équivalentes.

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 le numéro,
• null n'est pas défini.

la propriété non définie indique qu'une variable n'a pas été affecté une valeur null . Comme

var foo;

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

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

et null ne représente pas un 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

SO chacun a sa façon d'utiliser

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

null 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 

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

..où variable est un nom symbolique associé à une valeur.

JS pourrait avoir la gentillesse d'introduire implicitement des variables nouvellement déclarées avec nul , mais ce n'est pas le cas.

s'il vous Plaît lire attentivement ce qui suit. Il supprimera tous vos doutes concernant la différence entre null et Non défini en JavaScript. Vous pouvez également utiliser la fonction utilitaire donnée ci-dessous pour déterminer exactement les types.

en JavaScript nous pouvons avoir les types suivants de variables.

1. Variables Non Déclarées
2. Variables déclarées mais non attribuées
3. Variables affectées à la lettre non définies
4. Variables affectées à la lettre nul
5. Variables attribuées avec autre chose que Non défini ou nul

ci-dessous explique chacun de ces cas un par un

1. Variables non déclarées : ce qui suit s'applique aux variables non déclarées

   • peut seulement être vérifié par typeof () qui renvoie la chaîne de caractères 'indefined'
   • Ne peut pas être vérifiée avec == ou === ou par si ou opérateur conditionnel ? (erreur de référence)

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

   "
   • typeof renvoie la chaîne 'undefined'
   • == vérifier avec null retourne vrai
   • == cochez la case non définie vrai
   • === vérifier avec null retourne false
   • === vérifiez auprès de undefined renvoie vrai
   • si ou opérateur conditionnel ? renvoie false

3. Variables attribuées avec la lettre variables non définies : ces variables sont traitées de la même manière que les Variables déclarées mais non attribuées .

4. Variables attribuées avec la lettre null

   • typeof renvoie la chaîne "objet"
   • == vérifier avec null retourne vrai
   • == vérifiez auprès de undefined renvoie vrai
   • === vérifier avec null retourne vrai
   • === cocher la case indefined returns false
   • si ou opérateur conditionnel ? retourne false

5. Variables affectées à autre chose que Non défini ou null

   • typeof renvoie les chaînes de caractères suivantes: 'string' , 'numéro' , 'boolean' , "fonction" , "objet" , de "symbole"

fournit L'algorithme pour le contrôle de type correct d'un variable:

1. contrôle pour non déclaré / non attribué / attribué avec Non défini utilisant typeof . retour si la chaîne 'undefined' est renvoyé.
2. Vérifier null à l'aide de === . retour 'null' si vrai .
3. Vérifier le type réel en utilisant type de . le type de retour si ce n'est égal à "objet"
4. Appel Objet.prototype.toString.appeler (o) pour déterminer le type d'objet réel. Il doit retourner une chaîne de type '[ObjectType objet] ' pour tous les construits en Javascript ou DOM défini Objet. Pour les objets définis par l'utilisateur, il retourne '[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 
}

Indéfini désigne 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 cession:

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

vous pourriez considérer comme non défini pour représenter une absence de valeur au niveau du système, inattendue, ou de type erreur et nul pour représenter l'absence de valeur au niveau du programme, normale, ou attendue.

via JavaScript:le Guide définitif

je vais expliquer undefined , null et Uncaught 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 varaible

2 - undefined : Variable déclarée mais non initialisée

3 - null : Variable déclarée et est une valeur vide

null et Non défini sont deux types d'objets distincts qui ont en commun:

• les deux ne peuvent contenir qu'une seule valeur, null et Non défini respectivement;
• les deux ont aucune des propriétés ou des méthodes et une tentative de lecture de toutes les propriétés de entraînera une erreur d'exécution (pour tous les autres objets, vous obtenez valeur non définie si vous essayez de lire une propriété inexistante);
• les valeurs null et non définies sont considérées égales les unes aux autres et à rien d'autre par les opérateurs == et != .

les similitudes s'arrêtent cependant ici. Pour une fois, il ya une différence fondamentale dans la façon dont les mots clés null et les non définis sont mis en œuvre. Ce n'est pas évident, mais prenons l'exemple suivant:

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

Non défini , nan et Infinity ne sont que des noms de variables "superglobales" préinitialisées - elles sont initialisées à l'exécution et peuvent être remplacées par des variables globales normales ou locales 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);

Oops! null , true et false 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 Non défini est un type primitif, tandis que null est un type d'objet (indiquant l'absense d'une référence d'objet). 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

il y a aussi une différence importante dans la façon dont nul et Non défini sont traités dans le 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 - similaire à faux , il est fondamentalement juste une sorte spéciale de "zéro". undefined , d'autre part, est un véritable "rien" et devient NaN ("pas un nombre") lorsque vous essayez de l'utiliser dans le contexte numérique.

noter que null et Non défini recevoir un traitement spécial de == et != opérateurs, mais vous pouvez tester l'égalité numérique vraie de a et b avec l'expression (a >= b && a <= b) .

tl; dr

Utiliser null pour définir une variable, vous savez qu'elle est un Objet.

utiliser undefined pour définir une variable dont le type est mixte.

C'est mon usage de 5 primitives et du type D'objet, et qui explique la différence entre "use case" de undefined ou 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, à "" :

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

numéro

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 NaN si 0 est une valeur importante dans votre usage):

(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"

Boolean

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, à 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, à null :

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

Note: smart usage off null doit être la falsy version d'un objet parce qu'un objet est toujours true , et parce que typeof null retour object . Cela signifie typeof myVarObject retourner la valeur cohérente pour L'objet et le type null.

tous

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 .

null est un mot-clé de langue qui évalue à une valeur spéciale qui est habituellement utilisé pour indiquer l'absence de valeur. En utilisant l'opérateur typeof sur null renvoie la chaîne "object", indiquant que null peut être considéré comme une valeur d'objet spécial qui indique "sans objet". Toutefois, dans la pratique, null est généralement considéré comme le seul membre de son propre type, et il peut être utilisé pour indiquer "aucune valeur" pour les nombres et les chaînes ainsi que objet. La plupart des les langages de programmation ont l'équivalent de JavaScript null: Vous pouvez être familier avec elle, comme nul ou nul.

JavaScript a aussi une seconde valeur qui indique l'absence de valeur. La valeur non définie représente une forme plus profonde d'absence. C'est la valeur des variables qui n'ont pas été initialisé et la valeur que vous obtenez lorsque vous interrogez la valeur d'une propriété d'un objet ou d'un tableau élément qui n'existe pas. La valeur non définie est aussi retournée par les fonctions qui ont pas de valeur de retour, et la valeur des paramètres de la fonction pour laquelle aucun argument n'est fourni. undefined est une variable globale prédéfinie (pas un mot-clé de langue comme null) qui est initialisée à la valeur non définie. Dans ECMAScript 3, undefined est une variable de lecture / écriture, et il peut être réglé à une valeur quelconque. Cette erreur est corrigée dans ECMAScript 5 et undefined est en lecture seule dans cette version de la langue. Si vous appliquez le type d'opérateur à la valeur indéfinie, il retourne "undefined", indiquant que cette valeur est la seule membre d'un type spécial.

malgré ces différences, nul et non défini indique à la fois une absence de valeur et peut souvent être utilisé de façon interchangeable. L'opérateur d'égalité == les considère comme des égaux. (Utiliser l'opérateur d'égalité stricte === pour les distinguer.) Les deux sont des valeurs faibles-ils se comportent comme des faux lorsqu'une valeur booléenne est nécessaire. Ni nulle ni indéfini ont toutes les propriétés ou méthodes. En fait, à l'aide de . ou [] pour accéder à un propriété ou méthode de ces les valeurs provoquent une erreur typographique.

vous pourriez considérer comme non défini pour représenter un niveau de système, inattendu, ou de type erreur absence de valeur et null pour représenter le niveau du programme, l'absence normale ou prévue de valeur. Si vous devez attribuer l'une de ces valeurs à une variable ou d'une propriété ou passer un ces valeurs à une fonction, null est presque toujours le bon choix.

null est une valeur spéciale signifiant "aucune valeur". null est un objet spécial parce que typeof null retourne "objet".

par contre, undefined signifie que la variable n'a pas été déclarée ou n'a pas reçu de valeur.

en Javasscript il y a 5 types de données primitives chaîne , Nombre , booléen , null et non défini. 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);
     }
  }

aussi 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

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

aussi

var a;
alert(typeof a); 

ce donnera non défini; nous avons déclaré une variable mais nous n'avons pas signé 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 attribué une valeur null à 'a'

les valeurs nulles et non définies 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: non défini en fait signifie que la variable n'est pas initialisée. Fonctions qui reviennent rien et les paramètres de fonction pour lesquels aucune valeur n'est fournie, la valeur non définie est retournée. Utiliser l'opérateur d'égalité stricte === distinguer entre nul et non défini.

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

OK, nous pouvons être confus quand nous entendons parler de null et undefined , mais commençons par simple, ils sont tous les deux falsy et similaire à bien des égards, mais partie bizarre de JavaScript, les rendre couple de différences importantes, par exemple, la typeof null est 'object' tandis que la typeof undefined est 'undefined' .

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

mais si vous les cochez avec == comme ci-dessous, vous voyez qu'ils sont tous les deux faux:

null==undefined; //true

aussi vous pouvez assigner null à une propriété d'objet ou à une primitive, tandis que undefined peut simplement être atteint en n'assignant à rien.

je crée une image rapide pour montrer les différences pour vous à un coup d'oeil.

comme typeof returns undefined, undefined est un type où comme null est un initialiseur indique la variable points à aucun objet(pratiquement tout en Javascript est un objet).

null et non défini sont tous les 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 non défini et non initialisé

les propriétés d'un objet non défini 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 reviendra indéfini.

Généralement, nous assignons null aux variables non indéfinies.

pour le type undefined , il y a une seule valeur: undefined .

pour le type null , il y a une seule valeur: null .

donc pour les deux, l'étiquette 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, null est un mot-clé spécial , pas un identifiant, et donc vous ne pouvez pas le traiter comme une variable à attribuer.

cependant, undefined est un identificateur . Dans les deux modes non-strict et strict , 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 undefined lui est attribuée . Cela signifie que la variable est intacte et peut être assignée n'importe quelle valeur à l'avenir. Il implique également que vous ne connaissez pas la valeur de cette variable va contenir au moment de la déclaration.

Maintenant vous pouvez attribuer explicitement une variable null . Cela signifie que la variable n'a aucune valeur. Par exemple, Certaines personnes n'ont pas un deuxième nom. Donc, dans un tel cas, son il est préférable d'attribuer la valeur null à la variable middlename d'un objet person.

supposons maintenant que quelqu'un accède à la variable middlename de votre objet person et qu'elle ait la valeur undefined . Il ne sait pas si le développeur a oublié d'initialiser cette variable ou si elle n'a aucune valeur. Si elle a la valeur null , alors l'utilisateur peut facilement déduire que middlename n'a pas de valeur et ce n'est pas une variable intacte.

la meilleure façon de comprendre la différence est d'abord de clarifier votre esprit des rouages internes de JavaScript et juste de 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, null et undefined . Vous êtes libre d'utiliser ces valeurs explicitement à transmettre ces significations.

alors quoi est-ce que certains des problèmes propres au JavaScript se posent à cause de cette base philosophique?

1. une variable déclarée sans initialiseur obtient la valeur undefined parce que vous n'avez jamais dit quoi que ce soit au sujet de ce que la valeur prévue était.

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

2. une propriété d'un objet qui n'a jamais été fixé est évaluée à undefined parce que personne n'a jamais rien dit à propos de cette propriété.

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

3. null et undefined sont "similaires" l'un à l'autre parce que Brendan Eich l'a dit. Mais ils ne sont absolument pas égaux l'un à l'autre.

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

4. null et undefined ont heureusement différents types. null appartient au type Null et undefined au type Undefined . C'est dans les specs, mais vous ne savez jamais ce à cause de la bizarrerie typeof que je ne répéterai pas ici.

5. une fonction qui atteint le bout de son corps sans une déclaration de retour explicite retourne undefined car vous ne savez rien de ce qu'il est retourné.

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

• NaN
• utilisant une variable qui n'a jamais été déclarée et recevant un ReferenceError
• utilisant une let ou const variable locale définie dans sa zone morte temporelle et recevant un ReferenceError

• les cellules Vides dans les matrices creuses. Oui, ils ne sont même pas undefined bien qu'ils comparent === à non défini.

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

null - il s'agit d'une valeur de cession. Qui est utilisé avec la variable pour représenter aucune valeur. (son objet)

Non défini - il s'agit d'une variable qui n'a aucune valeur qui lui est attribuée. Donc javascript lui assignera un non défini. (c'est un type de données)

non déclaré - si la variable n'est pas créée du tout, il est connu comme non déclaré.

la différence entre undefined et null est minime, mais il y a une différence. Une variable dont la valeur est undefined n'a jamais été initialisé. Une variable dont la valeur est null a 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 undefined et null en utilisant l'expression null==undefined , ils seront égaux.

selon L'article complet de Ryan Morr sur ce sujet...

" généralement, si vous devez attribuer une non-valeur à une variable ou à un bien, la passer à une fonction, ou la retourner à partir d'une fonction, null est presque toujours la meilleure option. Pour le dire simplement, JavaScript utilise non défini et les programmeurs devraient utiliser null."

Voir l'Exploration de l'Éternel Abîme de Null et Undefined

avec JavaScript, null est pour les objets, undefined est pour les variables, les propriétés et les méthodes.

est nul, un objet doit être défini, sinon il ne sera pas défini.

Si vous voulez tester si un objet existe, cela provoquera une erreur si l'objet n'est pas défini:

Incorrect:

if (myObj !== null && typeof myObj !== "undefined") 

pour cette raison, vous devez d'abord tester typeof ():

Correct:

if (typeof myObj !== "undefined" && myObj !== null) 

Lorsqu'une valeur est nulle, elle n'est rien et ne contient rien. Une valeur vide ou une variable est encore pleine; elle est juste pleine de vide. Le vide est différent de nul, ce qui est tout simplement rien. Par exemple, définir une variable et définir sa valeur à une chaîne vide ressemble à ceci:

 var myVariable = ''; 

la variable myVariable est vide, mais elle n'est pas nulle.

Undefined est un état, parfois utilisé comme une valeur, représentent un variable qui n'a pas encore contenu de valeur. tels que var abcd ;. Cet état est différent de null, bien que null et undefined puissent évaluer de la même manière.

• Non défini signifie qu'une variable a été déclarée mais n'a pas encore reçu de valeur.
• null est une valeur de cession. Il peut être assigné à une variable comme une représentation d'aucune valeur.
• Non défini et nul sont deux types distincts:

undefined est un type lui-même (non défini) alors que la valeur null est un objet.

• les variables non attribuées sont initialisées par JavaScript avec une valeur par défaut non définie.
• JavaScript ne définit jamais une valeur à null. Cela doit se faire par programme.

fondamentalement, Non défini est une variable globale que javascript crée au moment de l'exécution si nul signifie qu'aucune valeur n'a assignée à la variable (en fait nul 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

Non défini c'est ce que vous obtiendrez en sortie.

maintenant,

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

et vous obtiendrez 5 comme sortie. C'est la principale différence entre le Non défini et null

en javascript toutes les variables sont stockées en tant que paires de valeurs clés. Chaque variable est stockée sous la forme nom variable_name: variable_value / référence .

Non défini signifie qu'une variable a reçu un espace en mémoire, mais qu'aucune valeur ne lui a été attribuée. À titre de pratique exemplaire, vous ne devriez pas utiliser ce type d'affectation.

Dans ce cas, comment désigner quand vous voulez une variable sans valeur à un moment plus tard dans le code? Vous pouvez utiliser le type null , qui est aussi un type qui est utilisé pour définir la même chose, l'absence d'une valeur, mais ce n'est pas la même chose que non défini, comme dans ce cas vous avez effectivement la valeur en mémoire. Cette valeur est null

les Deux sont similaires, mais l'usage et le sens sont différents.

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

Vérifiez l'outil de développement de log in de la console, il sera imprimé comme non défini.

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

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

juste pour ajouter mes vues -

une variable qui est déclarée seulement, et jamais utilisée nulle part, est supprimée par un compilateur d'optimisation dans le cas de langages compilés comme C++[ou un avertissement est signalé dans L'IDE]. Cela signifie finalement que la variable est inexistante parce que sa mémoire n'est jamais attribuée.

dans le cas d'un interpréteur javascript, [je suppose] qu'une variable n'est considérée comme existante qu'à partir du point où elle reçoit une valeur. Avant ce point, son type est "undefined", et aucune mémoire n'est allouée pour lui. Et donc son type n'est pas défini.

Un nul en javascript est une valeur qui représente une adresse, mais que l'adresse des points pour rien encore[inexistant de référence]. Néanmoins, sa valeur.