ຄວາມແຕກຕ່າງລະຫວ່າງ null ແລະບໍ່ໄດ້ ກຳ ນົດໃນ JavaScript

ເອກະສານອ້າງອີງ

JavaScript

ການ ນຳ ໃຊ້ແບບບໍ່ ທຳ ມະດາ

ເປັນຕົວ ກຳ ນົດການເຮັດວຽກ, ມັນ ໝາຍ ຄວາມວ່າພາລາມິເຕີທີ່ເຮັດວຽກບໍ່ແມ່ນວັດຖຸ

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

ເປັນຈຸດສິ້ນສຸດຂອງຕ່ອງໂສ້ຕົ້ນແບບວັດຖຸ

            Object.getPrototypeOf(Object.prototype);
        

ໃນເວລາທີ່ປ່ອຍຕົວແປ, ໃຫ້ null ກັບຕົວແປ

            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
        

ຄວາມຄ້າຍຄືກັນລະຫວ່າງ null ແລະບໍ່ມີ ກຳ ນົດ

ທີ່ບໍ່ຖືກຕ້ອງໃນເວລາທີ່ປ່ຽນເປັນ boolean

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

ຄວາມແຕກຕ່າງລະຫວ່າງ null ແລະບໍ່ໄດ້ ກຳ ນົດ

ຜົນໄດ້ຮັບຈະແຕກຕ່າງກັນເມື່ອປ່ຽນເປັນເລກ, ຜົນຂອງການປ່ຽນເປັນ null ແມ່ນຄ່າຂອງເລກທີ່ຖືກຕ້ອງຂອງ 0, ແລະຜົນຂອງການແປງທີ່ບໍ່ໄດ້ ກຳ ນົດແມ່ນ NaN.

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

ສອງປະເພດແມ່ນແຕກຕ່າງກັນ, ປະເພດຂອງ null ແມ່ນວັດຖຸ, ແລະປະເພດຂອງທີ່ບໍ່ໄດ້ ກຳ ນົດແມ່ນບໍ່ໄດ້ ກຳ ນົດ.

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

ປຽບທຽບບໍ່ມີ ກຳ ນົດແລະບໍ່ໄດ້ ກຳ ນົດ

ເພື່ອແຍກຄວາມແຕກຕ່າງລະຫວ່າງບໍ່ມີຂອບເຂດແລະບໍ່ໄດ້ ກຳ ນົດ, ມີພຽງແຕ່ການໃຊ້ສານສະກັດກັ້ນ.

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

ເພື່ອສະຫຼຸບ

ຫຼັງຈາກການປຽບທຽບຂ້າງເທິງ, ພວກເຮົາມີຄວາມເຂົ້າໃຈທີ່ຈະແຈ້ງກ່ຽວກັບສອງປະເພດນີ້. ໂດຍປົກກະຕິແລ້ວເມື່ອພວກເຮົາຕັດສິນວ່າຕົວແປມີຄ່າທີ່ຖືກຕ້ອງໃນເວລາຂຽນລະຫັດ, ພວກເຮົາບໍ່ ຈຳ ເປັນຕ້ອງແຍກຄວາມແຕກຕ່າງຂອງສອງຢ່າງ, ພຽງແຕ່ໃຊ້ມັນເປັນປະເພດ Boolean. ແຕ່ເມື່ອພວກເຮົາຕ້ອງຕັດສິນວ່າຊັບສິນມີຢູ່, ພວກເຮົາຕ້ອງໃຊ້ປະເພດນັ້ນຢ່າງເຂັ້ມງວດເພື່ອຕັດສິນທີ່ບໍ່ໄດ້ ກຳ ນົດ. ສຸດທ້າຍ, ຖ້າພວກເຮົາສົ່ງຄ່າຕົວເລກ, ພວກເຮົາຕ້ອງຕັດສິນໃຈກ່ອນ, ແລະບໍ່ສາມາດຖືກໂຍນລົງໃສ່ປະເພດຕົວເລກ, ຖ້າບໍ່ດັ່ງນັ້ນກໍ່ຈະເຮັດໃຫ້ພວກເຮົາໄດ້ຮັບຜົນທີ່ຜິດປົກກະຕິ, ແລະບໍ່ໄດ້ ກຳ ນົດຈະຄິດໄລ່ໂດຍກົງຜົນທີ່ບໍ່ຖືກຕ້ອງ NaN.