La différence entre null et undefined en JavaScript

Référence

JavaScript

Utilisation 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.