Ang pagkakaiba sa pagitan ng null at hindi natukoy sa JavaScript

Sanggunian

JavaScript

Karaniwang paggamit ng null

Bilang isang parameter ng pag-andar, nangangahulugan ito na ang parameter ng pag-andar ay hindi isang object

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

Bilang pagtatapos ng object prototype chain

            Object.getPrototypeOf(Object.prototype);
        

Kapag naglalabas ng variable, magtalaga ng null sa variable

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

Karaniwang paggamit ng hindi natukoy

Ang variable ay idineklara ngunit hindi nakatalaga, ang halaga ng variable ay hindi natukoy

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

Ang parameter na dapat ibigay ng pagpapaandar ay hindi ibinigay kapag tumatawag, kung gayon ang halaga ng parameter na hindi ibinigay ay hindi natukoy

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

Ang mga pag-aari na hindi naglalaman ng bagay, ang halaga ay hindi natukoy

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

Kapag ang function ay hindi nagbabalik ng isang halaga, bumalik ito hindi natukoy bilang default

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

Mga pagkakatulad sa pagitan ng null at hindi natukoy

Mali kapag na-convert sa boolean

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

Ang pagkakaiba sa pagitan ng null at hindi natukoy

Ang resulta ay iba kapag na-convert sa isang numero. Ang resulta ng null na conversion ay isang wastong halaga ng numero na 0, at ang resulta ng hindi natukoy na conversion ay NaN.

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

Ang dalawang uri ay magkakaiba, ang uri ng null ay object, at ang uri ng hindi natukoy ay hindi natukoy.

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

ihambing ang null at hindi natukoy

Upang makilala ang pagitan ng null at hindi natukoy, ang pagkakaugnay lamang ang maaaring magamit. Sa pagsasama-sama, mahigpit nitong ihahambing kung pantay ang dalawang uri.

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

sa kabuuan

Matapos ang paghahambing sa itaas, mayroon kaming isang malinaw na pag-unawa sa dalawang uri na ito. Karaniwan kapag hinuhusgahan namin kung ang isang variable ay may wastong halaga kapag nagsusulat ng code, hindi namin kailangang makilala sa pagitan ng dalawa, gamitin lamang ito bilang isang uri ng Boolean. Ngunit kapag kailangan nating hatulan kung mayroon ang pag-aari, dapat naming mahigpit na gamitin ang uri upang hatulan ang hindi natukoy. Panghuli, kung pumasa tayo sa isang numerong halaga, dapat muna tayong magpasya, at hindi direktang mailagay sa isang uri ng numero, kung hindi man ay magdudulot sa amin ng hindi normal na mga resulta, at ang hindi natukoy ay direktang makalkula ang hindi wastong resulta NaN.