Dallimi midis null dhe të padefinuar në JavaScript

Referenca

JavaScript

Pë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.