ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನಲ್ಲಿ ಶೂನ್ಯ ಮತ್ತು ಸ್ಪಷ್ಟೀಕರಿಸದ ನಡುವಿನ ವ್ಯತ್ಯಾಸ

ಉಲ್ಲೇಖ

JavaScript

ಶೂನ್ಯದ ವಿಶಿಷ್ಟ ಬಳಕೆ

ಕಾರ್ಯ ನಿಯತಾಂಕವಾಗಿ, ಕಾರ್ಯ ನಿಯತಾಂಕವು ವಸ್ತುವಲ್ಲ ಎಂದು ಇದರ ಅರ್ಥ

            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 ಅನ್ನು ನೇರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.