Het verschil tussen null en ongedefinieerd in JavaScript
Referentie
JavaScriptTypisch gebruik van null
Als functieparameter betekent dit dat de functieparameter geen object is
function myFn(obj) {
if(null == obj) {
// code
}
}
Als het einde van de prototypeketen van het object
Object.getPrototypeOf(Object.prototype);
Wijs null toe aan de variabele bij het vrijgeven van de variabele
let o={
code:'abc'
};
o = null;
Typisch gebruik van ongedefinieerd
De variabele is gedeclareerd maar niet toegewezen, de waarde van de variabele is niet gedefinieerd
let o;
console.log(o); //undefined
De parameter die de functie moet leveren, wordt niet opgegeven bij het aanroepen, en de waarde van de parameter die niet wordt opgegeven, is niet gedefinieerd
function myFn(o) {
console.log(o);
}
myFn(); //undefined
Eigenschappen die het object niet bevat, de waarde is niet gedefinieerd
let o={
code:'abc'
};
console.log(o.name); //undefined
Als de functie geen waarde retourneert, retourneert deze standaard ongedefinieerd
function myFn(obj) {
obj = 'a';
}
console.log(myFn()); //undefined
Overeenkomsten tussen nul en ongedefinieerd
False bij conversie naar boolean
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
Het verschil tussen nul en ongedefinieerd
Het resultaat is anders bij conversie naar een getal. Het resultaat van een nulconversie is een geldige getalswaarde van 0, en het resultaat van een ongedefinieerde conversie is NaN.
console.log(Number(null)); // 0
console.log(Number(undefined)); // NaN
De twee typen zijn verschillend, het type null is object en het type ongedefinieerd is ongedefinieerd.
console.log(typeof null); //object
console.log(typeof undefined); //undefined
vergelijk null en ongedefinieerd
Om onderscheid te maken tussen nul en ongedefinieerd, kan alleen congruentie worden gebruikt.In congruentie zal het strikt vergelijken of de twee typen gelijk zijn.
console.log(Boolean(null == undefined)); // true
console.log(Boolean(null === undefined)); // false
opsommen
Na bovenstaande vergelijking hebben we een duidelijk begrip van deze twee typen. Als we beoordelen of een variabele een geldige waarde heeft bij het schrijven van code, hoeven we meestal geen onderscheid te maken tussen de twee, gebruik het gewoon als een Booleaans type. Maar als we moeten beoordelen of de eigenschap bestaat, moeten we strikt het type gebruiken om ongedefinieerd te beoordelen. Ten slotte, als we een numerieke waarde doorgeven, moeten we eerst een oordeel vellen, en kunnen we niet direct naar een numeriek type casten, anders zal null ervoor zorgen dat we abnormale resultaten krijgen, en ongedefinieerd zal direct het ongeldige resultaat NaN berekenen.