જાવાસ્ક્રિપ્ટમાં નલ અને અપૂર્ણ વ્યાખ્યા વચ્ચેનો તફાવત

સંદર્ભ

નલનો લાક્ષણિક ઉપયોગ

ફંક્શન પેરામીટર તરીકે, તેનો અર્થ એ કે ફંકશન પેરામીટર anબ્જેક્ટ નથી

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

Protબ્જેક્ટ પ્રોટોટાઇપ સાંકળના અંત તરીકે

            Object.getPrototypeOf(Object.prototype);
        

ચલને મુક્ત કરતી વખતે, ચલને નલ સોંપો

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

અનિશ્ચિતનો લાક્ષણિક વપરાશ

વેરીએબલ ઘોષિત કરવામાં આવે છે પરંતુ સોંપેલ નથી, વેરીએબલનું મૂલ્ય નિર્ધારિત છે

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

ફંક્શન દ્વારા જે પરિમાણ આપવું જોઈએ તે ક callingલિંગ કરતી વખતે પ્રદાન કરવામાં આવતું નથી, તો પછી જે પેરામીટર આપવામાં આવ્યાં નથી તેનું મૂલ્ય અનિશ્ચિત છે

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

ગુણધર્મો કે જેમાં objectબ્જેક્ટ શામેલ નથી, મૂલ્ય નિર્ધારિત છે

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

જ્યારે ફંક્શન કોઈ વેલ્યુ પરત કરતું નથી, ત્યારે તે ડિફ defaultલ્ટ રૂપે અપૂર્ણ વ્યાખ્યા આપે છે

            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
        

બે પ્રકારો ભિન્ન છે, નલનો પ્રકાર objectબ્જેક્ટ છે, અને અસ્પષ્ટ પ્રકારનો પ્રકાર અનિશ્ચિત છે.

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

નલ અને અસ્પષ્ટ વ્યાખ્યાયિત કરો

નલ અને અસ્પષ્ટ વ્યાખ્યાયિત કરવા માટે, ફક્ત એકરૂપ થવું જ ઉપયોગમાં લેવાય છે, એકરૂપમાં, તે બંને પ્રકારો સમાન છે કે નહીં તેની સખ્તાઇથી તુલના કરશે.

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

સરવાળો

ઉપરોક્ત તુલના પછી, આપણને આ બે પ્રકારોની સ્પષ્ટ સમજ છે. સામાન્ય રીતે જ્યારે આપણે કોડ લખતી વખતે ચલનું માન્ય મૂલ્ય છે કે કેમ તેનો નિર્ણય કરીએ ત્યારે, આપણે બંને વચ્ચે તફાવત કરવાની જરૂર નથી, ફક્ત તેને બુલિયન પ્રકાર તરીકે વાપરો. પરંતુ જ્યારે આપણે મિલકત અસ્તિત્વમાં છે કે કેમ તેનો નિર્ણય કરવાની જરૂર છે, ત્યારે આપણે અસ્પષ્ટ રીતે ન્યાય કરવા માટે પ્રકારનો ઉપયોગ કરવો જ જોઇએ. આખરે, જો આપણે આંકડાકીય મૂલ્ય પસાર કરીએ, તો આપણે પહેલા ચુકાદો આપવો જ જોઇએ, અને સીધા આંકડાકીય પ્રકારમાં ન કા .ી શકાતા, નહિતર આપણને અસામાન્ય પરિણામો લાવવાનું કારણ બનશે, અને અસ્પષ્ટ પરિણામ સીધા અમાન્ય પરિણામની ગણતરી કરશે એનએન.