La différence entre null et undefined en JavaScript
Référence
JavaScriptUtilisation typique de null
En tant que paramètre de fonction, cela signifie que le paramètre de fonction n'est pas un objet
function myFn(obj) {
if(null == obj) {
// code
}
}
En tant que fin de la chaîne de prototypes d'objets
Object.getPrototypeOf(Object.prototype);
Lors de la libération de la variable, attribuez null à la variable
let o={
code:'abc'
};
o = null;
Utilisation typique de undefined
La variable est déclarée mais non affectée, la valeur de la variable n'est pas définie
let o;
console.log(o); //undefined
Le paramètre que la fonction doit fournir n'est pas fourni lors de l'appel, alors la valeur du paramètre qui n'est pas fourni n'est pas définie
function myFn(o) {
console.log(o);
}
myFn(); //undefined
Propriétés que l'objet ne contient pas, la valeur n'est pas définie
let o={
code:'abc'
};
console.log(o.name); //undefined
Lorsque la fonction ne renvoie pas de valeur, elle retourne undefined par défaut
function myFn(obj) {
obj = 'a';
}
console.log(myFn()); //undefined
Similitudes entre null et undefined
False lors de la conversion en booléen
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
La différence entre null et undefined
Le résultat est différent lorsqu'il est converti en nombre. Le résultat de la conversion null est une valeur numérique valide de 0 et le résultat d'une conversion non définie est NaN.
console.log(Number(null)); // 0
console.log(Number(undefined)); // NaN
Les deux types sont différents, le type de null est object et le type de undefined n'est pas défini.
console.log(typeof null); //object
console.log(typeof undefined); //undefined
comparer null et indéfini
Pour faire la distinction entre nul et indéfini, seule la congruence peut être utilisée. En congruence, on comparera strictement si les deux types sont égaux.
console.log(Boolean(null == undefined)); // true
console.log(Boolean(null === undefined)); // false
Pour résumer
Après la comparaison ci-dessus, nous avons une compréhension claire de ces deux types. Habituellement, lorsque nous jugeons si une variable a une valeur valide lors de l'écriture de code, nous n'avons pas besoin de faire la distinction entre les deux, utilisez-la simplement comme un type booléen. Mais lorsque nous devons juger si la propriété existe, nous devons strictement utiliser le type pour juger indéfini. Enfin, si nous passons une valeur numérique, nous devons d'abord faire un jugement, et ne pouvons pas être directement convertis en type numérique, sinon null nous entraînera à obtenir des résultats anormaux, et undefined calculera directement le résultat non valide NaN.