ஜாவாஸ்கிரிப்டில் பூஜ்யத்திற்கும் வரையறுக்கப்படாதவற்றுக்கும் உள்ள வேறுபாடு

குறிப்பு

பூஜ்யத்தின் வழக்கமான பயன்பாடு

ஒரு செயல்பாட்டு அளவுருவாக, செயல்பாட்டு அளவுரு ஒரு பொருள் அல்ல என்று பொருள்

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

பொருள் முன்மாதிரி சங்கிலியின் முடிவாக

            Object.getPrototypeOf(Object.prototype);
        

மாறியை வெளியிடும் போது, ​​மாறிக்கு பூஜ்யத்தை ஒதுக்குங்கள்

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

வரையறுக்கப்படாத வழக்கமான பயன்பாடு

மாறி அறிவிக்கப்பட்டுள்ளது, ஆனால் ஒதுக்கப்படவில்லை, மாறியின் மதிப்பு வரையறுக்கப்படவில்லை

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

அழைக்கும் போது செயல்பாடு வழங்க வேண்டிய அளவுரு வழங்கப்படவில்லை, பின்னர் வழங்கப்படாத அளவுருவின் மதிப்பு வரையறுக்கப்படவில்லை

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

பொருள் இல்லாத பண்புகள், மதிப்பு வரையறுக்கப்படவில்லை

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

செயல்பாடு ஒரு மதிப்பை வழங்காதபோது, ​​அது இயல்பாக வரையறுக்கப்படவில்லை

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

பூஜ்யத்திற்கும் வரையறுக்கப்படாதவற்றுக்கும் இடையிலான ஒற்றுமைகள்

பூலியன் ஆக மாற்றும்போது தவறானது

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

பூஜ்யத்திற்கும் வரையறுக்கப்படாதவற்றுக்கும் உள்ள வேறுபாடு

எண்ணாக மாற்றும்போது முடிவு வேறுபட்டது. பூஜ்ய மாற்றத்தின் விளைவாக 0 இன் செல்லுபடியாகும் எண் மதிப்பு, மற்றும் வரையறுக்கப்படாத மாற்றத்தின் விளைவாக NaN ஆகும்.

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

இரண்டு வகைகள் வேறுபட்டவை, பூஜ்ய வகை பொருள், மற்றும் வரையறுக்கப்படாத வகை வரையறுக்கப்படவில்லை.

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

பூஜ்ய மற்றும் வரையறுக்கப்படாததை ஒப்பிடுக

பூஜ்யத்திற்கும் வரையறுக்கப்படாதவற்றுக்கும் இடையில் வேறுபடுவதற்கு, ஒற்றுமை மட்டுமே பயன்படுத்தப்பட முடியும். ஒற்றுமையில், இரண்டு வகைகளும் சமமானதா என்பதை இது கண்டிப்பாக ஒப்பிடும்.

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

மொத்தத்தில்

மேற்கண்ட ஒப்பீட்டிற்குப் பிறகு, இந்த இரண்டு வகைகளைப் பற்றிய தெளிவான புரிதல் நமக்கு உள்ளது. வழக்கமாக குறியீட்டை எழுதும் போது ஒரு மாறிக்கு சரியான மதிப்பு இருக்கிறதா என்று நாம் தீர்மானிக்கும்போது, ​​இரண்டையும் வேறுபடுத்திப் பார்க்கத் தேவையில்லை, அதை பூலியன் வகையாகப் பயன்படுத்துங்கள். ஆனால் சொத்து இருக்கிறதா என்று நாம் தீர்மானிக்க வேண்டியிருக்கும் போது, ​​வரையறுக்கப்படாததை தீர்மானிக்க கண்டிப்பாக வகையைப் பயன்படுத்த வேண்டும். இறுதியாக, நாம் ஒரு எண் மதிப்பைக் கடந்துவிட்டால், நாம் முதலில் ஒரு தீர்ப்பை வழங்க வேண்டும், மேலும் நேரடியாக ஒரு எண் வகைக்கு அனுப்ப முடியாது, இல்லையெனில் பூஜ்யம் எங்களுக்கு அசாதாரண முடிவுகளைப் பெறும், மேலும் வரையறுக்கப்படாதது தவறான முடிவு NaN ஐ நேரடியாகக் கணக்கிடும்.