ଜାଭାସ୍କ୍ରିପ୍ଟରେ ନଲ୍ ଏବଂ ଅଜ୍ଞାତ ମଧ୍ୟରେ ପାର୍ଥକ୍ୟ |

ସନ୍ଦର୍ଭ

ନଲ୍ ର ସାଧାରଣ ବ୍ୟବହାର |

ଏକ ଫଙ୍କସନ୍ ପାରାମିଟର ଭାବରେ, ଏହାର ଅର୍ଥ ହେଉଛି ଫଙ୍କସନ୍ ପାରାମିଟର ଏକ ବସ୍ତୁ ନୁହେଁ |

            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 ର ଏକ ବ valid ଧ ସଂଖ୍ୟା ମୂଲ୍ୟ, ଏବଂ ଅଜ୍ଞାତ ରୂପାନ୍ତରର ଫଳାଫଳ ହେଉଛି NaN |

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

ଦୁଇଟି ପ୍ରକାର ଅଲଗା, ନଲ୍ ର ପ୍ରକାର ବସ୍ତୁ, ଏବଂ ଅଜ୍ f ାତର ପ୍ରକାର ଅଜ୍ f ାତ ଅଟେ |

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

ନଲ୍ ଏବଂ ଅଜ୍ଞାତ ତୁଳନା କରନ୍ତୁ |

ନଲ୍ ଏବଂ ଅଜ୍ଞାତ ମଧ୍ୟରେ ପାର୍ଥକ୍ୟ କରିବାକୁ, କେବଳ ସମନ୍ୱୟ ବ୍ୟବହାର କରାଯାଇପାରିବ | ସମନ୍ୱୟରେ, ଏହା ଦୁଇ ପ୍ରକାରର ସମାନ କି ନୁହେଁ ତାହା କଠୋର ଭାବରେ ତୁଳନା କରିବ |

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

ସଂକ୍ଷେପରେ

ଉପରୋକ୍ତ ତୁଳନା ପରେ, ଏହି ଦୁଇ ପ୍ରକାରର ଆମର ସ୍ପଷ୍ଟ ବୁ understanding ାମଣା ଅଛି | ସାଧାରଣତ when ଯେତେବେଳେ ଆମେ ବିଚାର କରୁ ଯେ କୋଡ୍ ଲେଖିବାବେଳେ ଏକ ଭେରିଏବଲ୍ ର ଏକ ବ valid ଧ ମୂଲ୍ୟ ଅଛି କି ନାହିଁ, ଆମକୁ ଉଭୟ ମଧ୍ୟରେ ପ୍ରଭେଦ କରିବାର ଆବଶ୍ୟକତା ନାହିଁ, ଏହାକୁ କେବଳ ବୁଲିୟନ୍ ପ୍ରକାର ଭାବରେ ବ୍ୟବହାର କରନ୍ତୁ | କିନ୍ତୁ ଯେତେବେଳେ ଆମକୁ ବିଚାର କରିବାକୁ ପଡିବ ଯେ ସମ୍ପତ୍ତି ଅଛି କି ନାହିଁ, ଆମକୁ ନିର୍ଦ୍ଦିଷ୍ଟ ଭାବରେ ବିଚାର କରିବାକୁ ପ୍ରକାରକୁ ବ୍ୟବହାର କରିବାକୁ ପଡିବ | ପରିଶେଷରେ, ଯଦି ଆମେ ଏକ ସାଂଖ୍ୟିକ ମୂଲ୍ୟ ପାସ୍ କରୁ, ତେବେ ଆମକୁ ପ୍ରଥମେ ଏକ ବିଚାର କରିବାକୁ ପଡିବ, ଏବଂ ଏକ ସାଂଖ୍ୟିକ ପ୍ରକାରକୁ ସିଧାସଳଖ ନିକ୍ଷେପ କରାଯାଇପାରିବ ନାହିଁ, ନଚେତ୍ ନଲ୍ ଆମକୁ ଅସ୍ୱାଭାବିକ ଫଳାଫଳ ପାଇବ, ଏବଂ ଅଜ୍ଞାତ ସିଧାସଳଖ NaN ଅବ alid ଧ ଫଳାଫଳ ଗଣନା କରିବ |