ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਨਲ ਅਤੇ ਪਰਿਭਾਸ਼ਤ ਦੇ ਵਿਚਕਾਰ ਅੰਤਰ

ਹਵਾਲਾ

ਨਲ ਦੀ ਖਾਸ ਵਰਤੋਂ

ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ ਤੇ, ਇਸਦਾ ਅਰਥ ਇਹ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰ ਇਕ ਆਬਜੈਕਟ ਨਹੀਂ ਹੈ

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

ਜਿਵੇਂ ਕਿ ਆਬਜੈਕਟ ਪ੍ਰੋਟੋਟਾਈਪ ਚੇਨ ਦੇ ਅੰਤ

            Object.getPrototypeOf(Object.prototype);
        

ਵੇਰੀਏਬਲ ਨੂੰ ਜਾਰੀ ਕਰਨ ਵੇਲੇ, ਵੇਰੀਏਬਲ ਨੂੰ ਰੱਦ ਕਰੋ

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

ਪਰਿਭਾਸ਼ਤ ਦੀ ਖਾਸ ਵਰਤੋਂ

ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਪਰ ਅਸਾਈਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ, ਵੇਰੀਏਬਲ ਦੀ ਵੈਲਿ und ਨਿਰਧਾਰਤ ਨਹੀਂ ਹੈ

            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
        

ਸੰਪੇਕਸ਼ਤ

ਉਪਰੋਕਤ ਤੁਲਨਾ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ ਇਨ੍ਹਾਂ ਦੋ ਕਿਸਮਾਂ ਦੀ ਸਪਸ਼ਟ ਸਮਝ ਹੈ. ਆਮ ਤੌਰ 'ਤੇ ਜਦੋਂ ਅਸੀਂ ਨਿਰਣਾ ਕਰਦੇ ਹਾਂ ਕਿ ਕੋਡ ਲਿਖਣ ਵੇਲੇ ਇੱਕ ਵੇਰੀਏਬਲ ਦੀ ਵੈਧ ਕੀਮਤ ਹੁੰਦੀ ਹੈ, ਸਾਨੂੰ ਦੋਵਾਂ ਵਿੱਚ ਅੰਤਰ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੁੰਦੀ, ਬੱਸ ਇਸਨੂੰ ਬੁਲੀਅਨ ਕਿਸਮ ਦੇ ਰੂਪ ਵਿੱਚ ਵਰਤੋ. ਪਰ ਜਦੋਂ ਸਾਨੂੰ ਇਹ ਨਿਰਣਾ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ ਕਿ ਸੰਪੱਤੀ ਮੌਜੂਦ ਹੈ ਜਾਂ ਨਹੀਂ, ਸਾਨੂੰ ਇਸ ਕਿਸਮ ਦੀ ਸਖਤੀ ਨਾਲ ਇਸ ਦੀ ਵਰਤੋਂ ਬਿਨਾਂ ਪਰਿਭਾਸ਼ਿਤ ਨਿਰਣੇ ਲਈ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ. ਅੰਤ ਵਿੱਚ, ਜੇ ਅਸੀਂ ਇੱਕ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਪਹਿਲਾਂ ਇੱਕ ਨਿਰਣਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਸਿੱਧੇ ਤੌਰ ਤੇ ਇੱਕ ਸੰਖਿਆਤਮਕ ਕਿਸਮ ਤੇ ਨਹੀਂ ਸੁੱਟਿਆ ਜਾ ਸਕਦਾ, ਨਹੀਂ ਤਾਂ ਨਲ ਸਾਡੇ ਲਈ ਅਸਧਾਰਨ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣੇਗੀ, ਅਤੇ ਅਣਜਾਣਿਤ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਅਵੈਧ ਨਤੀਜਿਆਂ ਦੀ ਗਣਨਾ ਕਰੇਗਾ.