Ang pagkakaiba sa pagitan ng null at hindi natukoy sa JavaScript
Sanggunian
JavaScriptKaraniwang 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.