Dallimi midis null dhe të padefinuar në JavaScript
Referenca
JavaScriptPërdorimi tipik i nulit
Si parametër i funksionit, do të thotë që parametri i funksionit nuk është objekt
function myFn(obj) {
if(null == obj) {
// code
}
}
Si fundi i zinxhirit prototip të objektit
Object.getPrototypeOf(Object.prototype);
Kur lëshoni ndryshoren, caktoni null variablës
let o={
code:'abc'
};
o = null;
Përdorimi tipik i padefinuar
Ndryshorja deklarohet por nuk caktohet, vlera e ndryshores është e papërcaktuar
let o;
console.log(o); //undefined
Parametri që funksioni duhet të sigurojë nuk sigurohet gjatë thirrjes, atëherë vlera e parametrit që nuk është dhënë është e papërcaktuar
function myFn(o) {
console.log(o);
}
myFn(); //undefined
Karakteristikat që objekti nuk përmban, vlera është e papërcaktuar
let o={
code:'abc'
};
console.log(o.name); //undefined
Kur funksioni nuk kthen një vlerë, ajo kthehet e papërcaktuar në mënyrë të paracaktuar
function myFn(obj) {
obj = 'a';
}
console.log(myFn()); //undefined
Ngjashmëritë midis nulit dhe të padefinuarës
E gabuar kur shndërrohet në boolean
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
Dallimi midis nulit dhe padefinuar
Rezultati është i ndryshëm kur shndërrohet në një numër. Rezultati i shndërrimit null është një vlerë e vlefshme e numrit 0, dhe rezultati i shndërrimit të papërcaktuar është NaN.
console.log(Number(null)); // 0
console.log(Number(undefined)); // NaN
Të dy llojet janë të ndryshëm, lloji i null është objekt, dhe lloji i padefinuar është i padefinuar.
console.log(typeof null); //object
console.log(typeof undefined); //undefined
krahasoni nul dhe të padefinuar
Për të bërë dallimin midis nul dhe të padefinuar, mund të përdoret vetëm kongruenca. Në kongruencë, ajo do të krahasojë në mënyrë rigoroze nëse të dy llojet janë të barabartë.
console.log(Boolean(null == undefined)); // true
console.log(Boolean(null === undefined)); // false
për të përmbledhur
Pas krahasimit të mësipërm, ne kemi një kuptim të qartë të këtyre dy llojeve. Zakonisht kur gjykojmë nëse një ndryshore ka një vlerë të vlefshme kur shkruajmë kod, nuk kemi nevojë të bëjmë dallimin midis të dyve, thjesht e përdorim atë si një tip Boolean. Por kur duhet të gjykojmë nëse prona ekziston, duhet të përdorim në mënyrë rigoroze llojin për të gjykuar të papërcaktuar. Më në fund, nëse kalojmë një vlerë numerike, duhet të bëjmë një gjykim së pari, dhe nuk mund të hidhet drejtpërdrejt në një tip numerik, përndryshe null do të na bëjë që të marrim rezultate anormale, dhe i papërcaktuar do të llogarisë drejtpërdrejt rezultatin e pavlefshëm NaN.