Diferența dintre nul și nedefinit în JavaScript
Referinţă
JavaScriptUtilizarea 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.