Quelle est la différence entre null et undefined en JavaScript?
Je veux savoir quelle est la différence entre null et undefined en JavaScript.
En JavaScript, undefined signifie qu'une variable a été déclarée, mais qu'aucune valeur, telle que:
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 (non défini), tandis que null est un objet.
null === undefined // false
null == undefined // true
null === null // true
et
null = 'value' // ReferenceError
undefined = 'value' // 'value'
J'ai choisi ceci de ici
La valeur indéfinie est une valeur primitive utilisée lorsqu'une valeur n'a pas été affectée à une variable.
La valeur null est une valeur primitive qui représente la référence null, vide ou inexistante.
Lorsque vous déclarez une variable via var sans lui attribuer de valeur, sa valeur est 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 à celui-ci, il va apparaître:
var s;
WScript.Echo(s);
WScript.Echo("" + s);
Vous pouvez déclarer une variable, lui attribuer la valeur 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. Tandis que indéfini est un type à lui tout seul, null est considéré comme une valeur d'objet spéciale. Vous pouvez le voir en utilisant typeof () qui renvoie 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 produira le résultat suivant:
undefined
object
Quels que soient leurs types, ils agiront toujours de la même manière si vous essayez d’avoir accès à un membre de l’un ou l’autre, 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 définir explicitement une variable comme étant non définie, mais je vous le déconseille vivement. Je recommande de définir uniquement les variables sur null et de ne pas définir la valeur des éléments que vous avez oublié de définir. En même temps, je vous encourage vraiment à toujours définir toutes les variables. JavaScript a une chaîne d’étendue différente de celle des langages de style C, déroutant même les programmeurs les plus expérimentés, et définir des variables sur null est le meilleur moyen de prévenir les bogues basés sur celui-ci.
Une autre instance où vous verrez apparaître une fenêtre non définie est l'utilisation de l'opérateur de suppression. Ceux d'entre nous issus d'un monde en C pourraient interpréter ceci à tort 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 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 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 que: JavaScript ne mettra jamais rien à null, c'est généralement ce que nous faisons. Bien que nous puissions définir les variables sur non défini, nous préférons null car ce n’est pas quelque chose qui nous est demandé. Lorsque vous déboguez, cela signifie que tout ce qui est défini sur null est de votre propre fait et non de JavaScript. Au-delà de cela, ces deux valeurs spéciales sont presque équivalentes.
null est un mot clé spécial indiquant une absence de valeur.
pensez-y comme une valeur, comme:
- "foo" est une chaîne,
- le vrai est booléen,
- 1234 est le numéro,
- null est indéfini.
La propriété non définie indique qu'aucune valeur incluant null n'a été affectée à une variable. Comme
var foo;
la variable vide définie est null de type de données undefined
Les deux représentent un valeur d'une variable sans valeur
ETnull ne représente pas une chaîne qui n'a pas de valeur - chaîne vide-
J'aime
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 propre manière d'utiliser
non défini utilisez-le 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; non défini: absence de variable elle-même;
.. où variable est un nom symbolique associé à une valeur.
JS pourrait être assez aimable pour initier implicitement les variables récemment déclarées avec null, mais ce n'est pas le cas.
S'il vous plaît lisez avec attention. Il supprimera tous vos doutes concernant la différence entre null et undefined en JavaScript. Vous pouvez aussi utiliser la fonction utilitaire donnée ci-dessous pour déterminer exactement les types.
En JavaScript, nous pouvons avoir les types de variables suivants.
- Variables non déclarées
- Variables déclarées mais non affectées
- Variables assignées avec littéral non défini
- Variables affectées avec un littéral null
- Variables affectées avec autre chose que non défini ou null
La suite explique chacun de ces cas un à un.
Variables non déclarées : La suite est vraie pour les variables non déclarées.
- Ne peut être vérifié que par typeof () qui retourne une chaîne 'undefined'
- Ne peut être vérifié avec == ou === ou avec si ou Opérateur conditionnel ? (renvoie une erreur de référence)
Variables déclarées mais non affectées
- typeof retourne une chaîne 'undefined'
- == vérifier avec null renvoie vrai
- == vérifier avec undefined renvoie true
- === vérifier avec null renvoie faux
- === vérifier avec undefined renvoie true
- si ou opérateur conditionnel ? renvoie false
Variables affectées avec 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 .
Variables affectées avec un littéral null
- typeof retourne une chaîne 'objet'
- == vérifier avec null renvoie vrai
- == vérifier avec undefined renvoie true
- === vérifier avec null renvoie vrai
- === vérifier avec undefined renvoie false
- opérateur if ou conditionnel ? renvoie false
Variables affectées avec autre chose que non défini ou null
- 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:
- Vérifiez si non déclaré / non attribué / affecté avec non défini en utilisant typeof . retourne si string 'indéfini' est renvoyé.
- Recherchez null à l'aide de === . return 'null' if true .
- Recherchez le type actuel à l'aide de typeof . type de retour s'il n'est pas égal à 'objet'
- Appelez Object.prototype.toString.call (o) pour déterminer le type d'objet réel. Il doit renvoyer une chaîne de type '[objet ObjectType]' pour tous les objets Javascript intégrés ou DOM objets définis. Pour les objets définis par l'utilisateur, il retourne '[objet Object]'
Vous pouvez également utiliser la fonction utilitaire suivante pour déterminer les types. Il supporte actuellement 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 que non défini représente une absence de valeur au niveau du système, inattendue ou semblable à une erreur et null à une 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: 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 pas de 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 non défini sont deux types d'objet distincts qui ont en commun les éléments suivants:
- les deux ne peuvent contenir qu'une seule valeur, null et indéfini respectivement;
- les deux n'ont pas de propriétés ni 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 null et non défini sont considérées comme égales entre elles et ne font rien d'autre par les opérateurs
==et!=.
Les similitudes se terminent cependant ici. Pour une fois, il existe une différence fondamentale dans la manière dont les mots-clés null et non défini sont mis en œuvre. Ce n'est pas évident, mais considérons 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 variable locale avec les mêmes noms.
Essayons maintenant 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 variable ou de propriété.
Une autre différence est que non défini 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 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 (!!!)
null devient lorsqu'il est utilisé dans des expressions arithmétiques ou des comparaisons numériques - de la même manière que false, il s'agit simplement d'un type spécial de "zéro". non défini, 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 non défini reçoivent un traitement spécial de la part des opérateurs == et !=, mais vous pouvez tester l’égalité numérique vraie de a et b avec l'expression (a >= b && a <= b).
(ajout de caractères en raison du manque de caractères, je suis donc autorisé à poster ceci.)
null est une valeur spéciale signifiant "pas de valeur". null est un objet spécial parce que typeof null renvoie 'objet'.
Par contre, undefined signifie que la variable n'a pas été déclarée ou n'a pas reçu de valeur.
tl; dr
Utilisez null pour définir une variable car vous savez que c'est un objet.
Utilisez undefined pour définir une variable dont le type est mélangé.
C’est mon utilisation à la fois de 5 primitives et de type d’objet, ce qui explique la différence entre "cas d’utilisation" de undefined ou null.
Chaîne
Si vous savez qu'une variable est uniquement une chaîne alors que tout le cycle de vie, par convention, vous pouvez l'initialiser sur "":
("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"
Nombre
Si vous savez qu'une variable est seulement un nombre alors que tout cycle de vie, par convention, vous pouvez l'initialiser à 0 (ou NaN si 0 est une valeur importante de 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 à false:
(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"
Objet
Si vous savez qu'une variable est uniquement un objet alors que tout le cycle de vie, par convention, vous pouvez l'initialiser sur null:
(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"
Remarque: l'utilisation intelligente off null doit être la version falsy d'un objet, car cet objet est toujours true, et parce que typeof null retourne object. Cela signifie que typeof myVarObject renvoie une valeur cohérente pour les types Object et null.
Tous
Si vous savez qu'une variable a un type mixte (tout type pendant tout le cycle de vie), vous pouvez, par convention, l'initialiser à undefined.
La meilleure façon de comprendre la différence est d'abord de nettoyer 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 existe 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 de manière explicite pour transmettre ces significations.
Alors, quels sont certains des problèmes spécifiques à JavaScript qui se posent en raison de cette base philosophique?
Une variable déclarée sans initialiseur obtient la valeur
undefinedcar vous n'avez jamais rien dit à propos de la valeur souhaitée.let supervisor; assert(supervisor === undefined);Une propriété d'un objet qui n'a jamais été définie est évaluée à
undefinedcar personne n'a jamais rien dit à propos de cette propriété.const dog = { name: 'Sparky', age: 2 }; assert(dog.breed === undefined);nulletundefinedsont "similaires" parce que Brendan Eich l'a dit. Mais ils ne sont absolument pas égaux entre eux.assert(null == undefined); assert(null !== undefined);nulletundefinedont heureusement des types différents.nullappartient au typeNulletundefinedau typeUndefined. Ceci est dans la spécification, mais vous ne le sauriez jamais à cause de la bizarrerietypeofque je ne vais pas répéter ici.Une fonction atteignant la fin de son corps sans instruction de retour explicite renvoie
undefinedpuisque vous ne savez rien de ce qu'elle a renvoyé.
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 - Utilisation d'une
letouconstvariable locale définie dans sa zone morte temporelle et réception d'uneReferenceError Cellules vides dans des tableaux clairsemés. Oui, ils ne sont même pas
undefinedbien qu'ils comparent===à undefined.$ 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 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);
}
}
également dans la fonction ci-dessus if (a == null) est identique à if (! a)
maintenant, quand on appelle cette fonction sans passer le paramètre un
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 undefined; 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 nul est un objet. en quelque sorte, nous avons attribué une valeur nulle à 'a'
null et undefined sont tous deux utilisés pour représenter l'absence d'une 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 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 à c.x, il retournera undefined.
Généralement, nous assignons null à des variables non indéfinies.
OK, nous risquons de nous perdre lorsque nous entendrons parler de null et undefined, mais commençons simplement, ils sont tous les deux faux et similaires à bien des égards, mais une partie étrange de JavaScript, en font quelques différences significatives, par exemple, typeof null est 'object' while typeof undefined est 'undefined'.
typeof null; //"object"
typeof undefined; //"undefined";
Mais si vous les vérifiez avec == 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, tandis que undefined peut simplement être obtenu en n'affectant rien.
Je crée une image rapide pour montrer les différences pour vous en un coup d'œil.
Pour le type undefined, il existe une et une seule valeur: undefined.
Pour le type null, il existe une et 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:
nullest une valeur videundefinedest une valeur manquante
Ou:
undefinedn'a pas encore eu de valeurnullavait une valeur et n'en a plus
En fait, null est un mot clé spécial, pas un identifiant; vous ne pouvez donc pas le traiter comme une variable à affecter.
Cependant, undefined est un identifiant. En mode non-strict et en mode strict, vous pouvez toutefois créer une variable locale du nom indéfini. Mais c'est une idée terrible!
function foo() {
undefined = 2; // bad idea!
}
foo();
function foo() {
"use strict";
undefined = 2; // TypeError!
}
foo();
Null et indéfini en JavaScript indiquent l'absence de valeur.
var a = null; //variable assigned null value var b; // undefinedMalgré le fait, les deux existent pour l'absence de valeur mais: Undefined signifie en réalité 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 indé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
Lorsque vous déclarez une variable en javascript, la valeur undefined lui est affectée. Cela signifie que la variable est intacte et que vous pouvez lui affecter n'importe quelle valeur à l'avenir. Cela implique également que vous ne connaissez pas la valeur que cette variable va avoir au moment de la déclaration.
Vous pouvez maintenant assigner explicitement une variable null. Cela signifie que la variable n'a aucune valeur. Par exemple - Certaines personnes n'ont pas de prénom. Donc, dans un tel cas, il est préférable d’attribuer la valeur null à la variable de prénom moyen d’un objet personne.
Supposons maintenant que quelqu'un accède à la variable de moyen nom de votre objet personne 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. Si elle a la valeur null, l'utilisateur peut facilement en déduire que le nom de domaine moyen n'a aucune valeur et qu'il ne s'agit pas d'une variable non modifiée.
Je souhaite ajouter une différence très subtile entre null et undefined qu'il est bon de connaître lorsque vous essayez d'apprendre le code JavaScript à la vanille (JS):
nullest un mot clé réservé dans JS tandis queundefinedest une variable de 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 étant donné que null et undefined sont toujours utilisés dans RHS d'une instruction JavaScript. Mais lorsque vous les utilisez dans LHS d'une expression, vous pouvez facilement observer cette différence. Donc, l'interpréteur JS interprète le code ci-dessous comme une erreur:
var null = 'foo'
Cela donne l'erreur ci-dessous:
Uncaught SyntaxError: Jeton inattendu null
Le code ci-dessous fonctionne avec succès, bien que je ne le recommande pas dans la vie réelle:
var undefined = 'bar'
Cela fonctionne car undefined est une variable de l'objet global (objet de la fenêtre de navigateur dans le cas de JS côté client).
L'article approfondi de Ryan Morr sur ce sujet ...
"En règle générale, si vous devez affecter une non-valeur à une variable ou une propriété, la transmettre à une fonction ou la renvoyer d'une fonction, null est presque toujours la meilleure option. Pour le dire simplement, JavaScript utilise non défini et les programmeurs doivent utilisez null. "
Comme typeof retourne undefined, undefined est un type où, comme null, un initialiseur indique que la variable ne pointe sur aucun objet (pratiquement tout le contenu en Javascript est un objet).
En javascript, toutes les variables sont stockées sous forme de paires clé-valeur. Chaque variable est stockée sous la forme nom_variable: valeur_variable/référence .
non défini signifie qu'une variable a reçu un espace en mémoire, mais qu'aucune valeur ne lui est affectée. À titre de meilleure pratique, vous ne devez pas utiliser ce type en tant que tâche.
Dans ce cas, comment indiquer quand vous voulez 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, à savoir l'absence de valeur, mais ce n'est pas la même chose que indéfini, car dans ce cas, vous avez le valeur en mémoire. Cette valeur est null
Les deux sont similaires mais l'utilisation et la signification sont différentes.
En gros, ndefined est une variable globale créée par javascript au moment de l'exécution, si null signifie qu'aucune valeur n'a été affecté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
ndefined 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 ndefined et null
null - Il s'agit d'une valeur d'affectation, utilisée avec une variable pour ne représenter aucune valeur (c'est un objet).
ndefined - C'est une variable qui n'a aucune valeur, donc JavaScript lui assignera 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 appelée non déclarée.
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ée. Une variable dont la valeur est null s'est vue attribuer explicitement la valeur null, ce qui signifie que la variable a été définie de manière explicite pour ne pas avoir de valeur. Si vous comparez undefined et null à l'aide de l'expression null==undefined, ils seront égaux.