განსხვავება 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
        

მსგავსება ნულსა და განუსაზღვრელს შორის

ყალბი, როდესაც ლოგიკურად გარდაიქმნება

            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
        

რომ შევაჯამოთ

ზემოაღნიშნული შედარების შემდეგ, ჩვენ ნათლად გვესმის ეს ორი ტიპი. ჩვეულებრივ, როდესაც ვიმსჯელებთ, აქვს თუ არა ცვლადს მოქმედი მნიშვნელობა კოდის წერისას, ჩვენ არ გვჭირდება ერთმანეთისგან გარჩევა, უბრალოდ ის გამოიყენეთ როგორც ლოგიკური ტიპის. როდესაც ჩვენ უნდა ვიმსჯელოთ, არსებობს თუ არა ქონება, ჩვენ მკაცრად უნდა გამოვიყენოთ ის, რომ განვსაზღვროთ განუსაზღვრელი. დაბოლოს, თუ ციფრულ მნიშვნელობას მივიღებთ, პირველ რიგში უნდა გამოვიტანოთ განსჯა და მისი პირდაპირი მიცემა არ შეიძლება ციფრულ ტიპზე, წინააღმდეგ შემთხვევაში null გამოიწვევს არანორმალური შედეგების მიღებას, ხოლო განუსაზღვრელი პირდაპირ გამოითვლის NaN არასწორ შედეგს.