Diferența dintre nul și nedefinit în JavaScript

Referinţă

JavaScript

Utilizarea tipică a nulului

Ca parametru funcțional, înseamnă că parametrul funcțional nu este un obiect

            function myFn(obj) {
    if(null == obj) {
        // code
    }
}
        

Ca sfârșitul lanțului prototip de obiect

            Object.getPrototypeOf(Object.prototype);
        

Când eliberați variabila, atribuiți nula variabilei

            let o={
 code:'abc'
};
o = null;
        

Utilizare tipică a nedefinit

Variabila este declarată, dar nu este atribuită, valoarea variabilei este nedefinită

            let o;
console.log(o);    //undefined
        

Parametrul pe care ar trebui să-l furnizeze funcția nu este furnizat la apelare, atunci valoarea parametrului care nu este furnizat este nedefinită

            function myFn(o) {
    console.log(o);
}
myFn();   //undefined
        

Proprietățile pe care obiectul nu le conține, valoarea este nedefinită

            let o={
 code:'abc'
};
console.log(o.name);    //undefined
        

Când funcția nu returnează o valoare, aceasta revine nedefinită în mod implicit

            function myFn(obj) {
    obj = 'a';
}
console.log(myFn());    //undefined
        

Asemănări între nul și nedefinit

Fals când este convertit în boolean

            console.log(Boolean(null));  // false
console.log(Boolean(undefined)); // false
        

Diferența dintre nul și nedefinit

Rezultatul este diferit atunci când este convertit într-un număr. Rezultatul conversiei nule este o valoare validă a numărului 0, iar rezultatul conversiei nedefinite este NaN.

            console.log(Number(null));  // 0
console.log(Number(undefined)); // NaN
        

Cele două tipuri sunt diferite, tipul de nul este obiect, iar tipul de nedefinit este nedefinit.

            console.log(typeof null); //object
console.log(typeof undefined); //undefined
        

compara nul și nedefinit

Pentru a face distincția între nul și nedefinit, se poate folosi doar congruența. În congruență, se va compara strict dacă cele două tipuri sunt egale.

            console.log(Boolean(null == undefined));  // true
console.log(Boolean(null === undefined)); // false
        

în concluzie

După comparația de mai sus, avem o înțelegere clară a acestor două tipuri. De obicei, atunci când judecăm dacă o variabilă are o valoare validă atunci când scriem cod, nu este nevoie să facem distincția între cele două, ci doar să o folosim ca tip boolean. Dar când trebuie să judecăm dacă proprietatea există, trebuie să folosim cu strictețe tipul pentru a judeca nedefinit. În cele din urmă, dacă trecem o valoare numerică, trebuie să facem mai întâi o judecată și nu putem fi aruncați direct la un tip numeric, altfel nul ne va face să obținem rezultate anormale, iar nedefinit va calcula direct rezultatul nevalid NaN.