Dlaczego wartość null jest obiektem i jaka jest różnica między wartością null a niezdefiniowaną?

Dlaczego jest nulluważany objectw JavaScript?

Sprawdza

if ( object == null )
      Do something

taki sam jak

if ( !object )
      Do something

?

I również:

Jaka jest różnica między nulli undefined?

(name is undefined)

Ty: co to jest name? ^(*)
JavaScript name :? Co to jest name? Nie wiem o czym mówisz. Nigdy wcześniej o tym nie wspominałeś name. Czy widzisz jakiś inny język skryptowy po stronie (klienta)?

name = null;

Ty: co to jest name?
JavaScript: nie wiem.

W skrócie; undefinedjest tam, gdzie nie istnieje pojęcie rzeczy; nie ma żadnego typu i nigdy wcześniej nie był przywoływany w tym zakresie; nullto miejsce, o którym wiadomo, że istnieje, ale nie wiadomo, jaka jest wartość.

Jedną rzeczą do zapamiętania jest to, że nullnie jest, koncepcyjnie, takie same jak falselub ""czy takie, nawet jeśli przyrównać po odlewaniu typu, tj

name = false;

Ty: co to jest name?
JavaScript: Boolean false.

name = '';

Ty: co to jest name?
JavaScript: pusty ciąg

^{*: namew tym kontekście należy rozumieć zmienną, która nigdy nie została zdefiniowana. Może to być dowolna niezdefiniowana zmienna, jednak nazwa jest właściwością niemal dowolnego elementu formularza HTML. To sięga daleko, dawno temu i zostało ustanowione na długo przed id. Jest to przydatne, ponieważ identyfikatory muszą być unikalne, ale nazwy nie muszą być.}

Różnicę można streścić w tym fragmencie:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined) //true
alert(null == undefined)  //true

Kontrola

object == nulljest inny do sprawdzenia if ( !object ).

Ta ostatnia jest równa ! Boolean(object), ponieważ !operator jednoargumentowy automatycznie rzuca odpowiedni operand na wartość logiczną.

Ponieważ Boolean(null)równa się wtedy fałsz !false === true.

Więc jeśli obiekt jest nie zerowa , ale fałszywe lub 0 lub „” , kontrola minie, ponieważ:

alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false

nullto nie jest obiektem , jest to prymitywny wartość . Na przykład nie można dodawać do niego właściwości. Czasami ludzie błędnie zakładają, że jest to obiekt, ponieważ typeof nullpowraca "object". Ale tak naprawdę jest to błąd (który można nawet naprawić w ECMAScript 6).

Różnica między nulli undefinedjest następująca:

• undefined: używany przez JavaScript i oznacza „bez wartości”. Niezainicjowane zmienne, brakujące parametry i nieznane zmienne mają tę wartość.

  > var noValueYet;
  > console.log(noValueYet);
  undefined
  
  > function foo(x) { console.log(x) }
  > foo()
  undefined
  
  > var obj = {};
  > console.log(obj.unknownProperty)
  undefined
  

  Jednak dostęp do nieznanych zmiennych powoduje wyjątek:

  > unknownVariable
  ReferenceError: unknownVariable is not defined
  

• null: używane przez programistów do wskazywania „brak wartości”, np. jako parametr funkcji.

Badanie zmiennej:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

Zasadniczo należy zawsze używać === i nigdy == w JavaScript (== wykonuje wszelkiego rodzaju konwersje, które mogą dawać nieoczekiwane wyniki). Sprawdzenie x == nulljest przypadkiem na krawędzi, ponieważ działa zarówno w przypadku, jak nulli undefined:

> null == null
true
> undefined == null
true

Częstym sposobem sprawdzania, czy zmienna ma wartość, jest konwersja jej na wartość logiczną i sprawdzenie, czy tak jest true. Ta konwersja jest wykonywana przez ifinstrukcję i operator logiczny! ("nie").

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

Wada tego podejścia: Wszystkie poniższe wartości oceniają na false, więc musisz być ostrożny (np. Powyższe kontrole nie rozróżniają między undefinedi 0).

• undefined, null
• Booleany: false
• Liczby: +0, -0,NaN
• Smyczki: ""

Możesz przetestować konwersję na wartość logiczną, używając Booleanjako funkcji (zwykle jest to konstruktor, którego można używać new):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

Jaka jest różnica między wartością zerową a niezdefiniowaną?

Właściwość, która nie ma definicji, jest niezdefiniowana. null jest obiektem. Jego typ to obiekt. null to specjalna wartość oznaczająca „brak wartości. undefined nie jest obiektem, jego typ jest niezdefiniowany.

Możesz zadeklarować zmienną, ustawić ją na null, a zachowanie jest identyczne, z wyjątkiem tego, że zobaczysz wydruk „null” i „niezdefiniowany”. Możesz nawet porównać zmienną niezdefiniowaną do wartości null lub odwrotnie, a warunek będzie spełniony:

 undefined == null
 null == undefined

Więcej informacji można znaleźć w JavaScript Różnica między wartością zerową a niezdefiniowaną .

a przy nowej edycji tak

if (object == null)  does mean the same  if(!object)

podczas testowania, czy obiekt jest fałszywy, oba spełniają warunek tylko podczas testowania, jeśli jest fałszywy , ale nie gdy jest prawdziwy

Sprawdź tutaj: Javascript gotcha

Pierwsza część pytania:

Dlaczego wartość null jest uważana za obiekt w JavaScript?

Jest to błąd projektowy JavaScript, którego nie mogą teraz naprawić. Powinien to być typ null, nie typ obiektu lub wcale go nie mieć. Wymaga dodatkowej kontroli (czasem zapomnianej) podczas wykrywania rzeczywistych obiektów i jest źródłem błędów.

Druga część pytania:

Sprawdza


if (object == null)
Do something

to samo co

if (!object)
Do something

Oba kontrole są zawsze fałszywe, z wyjątkiem:

• obiekt jest niezdefiniowany lub pusty: oba są prawdziwe.

• obiekt jest prymitywny, a 0 ""lub false: najpierw sprawdź false, drugi true.

Jeśli obiekt nie jest prymitywny, ale prawdziwy obiekt, jak new Number(0), new String("")lub new Boolean(false), po czym obie kontrole są fałszywe.

Więc jeśli „obiekt” jest interpretowany jako prawdziwy Obiekt, wówczas obie kontrole są zawsze takie same. Jeśli operacje podstawowe są dozwolone, kontrole są różne dla 0 ""i fałsz.

W takich przypadkach object==nullnieoczywiste wyniki mogą być źródłem błędów. Stosowanie ==nie jest zalecane kiedykolwiek użyć ===zamiast.

Trzecia część pytania:

A także:

Jaka jest różnica między wartością zerową a niezdefiniowaną?

W JavaScript jedną różnicą jest to, że null ma typ obiektu, a undefined jest typu undefined.

W JavaScript null==undefinedjest prawdziwe i uważane za równe, jeśli typ jest ignorowany. Dlaczego tak postanowili, ale 0 ""i fałsz nie są sobie równe, nie wiem. To wydaje się arbitralna opinia.

W JavaScript null===undefinednie jest prawdą, ponieważ typ musi być taki sam w ===.

W rzeczywistości wartości zerowe i niezdefiniowane są identyczne, ponieważ oba reprezentują nieistnienie. Podobnie jak 0, i jeśli ""o to chodzi, być może puste pojemniki []i {}. Tak wiele rodzajów tego samego niczego nie jest receptą na błędy. Jeden typ lub żaden nie jest lepszy. Spróbowałbym użyć jak najmniej.

„false”, „true” i „!” są kolejną torbą robaków, którą można uprościć, na przykład if(!x)i if(x)same są wystarczające, nie potrzebujesz prawdy i fałszu.

Zadeklarowany var xtyp jest niezdefiniowany, jeśli nie podano żadnej wartości, ale powinien być taki sam, jakby x nigdy nie został zadeklarowany. Innym źródłem błędów jest pusty pojemnik na nic. Więc najlepiej jest to zadeklarować i zdefiniować razem var x=1.

Ludzie chodzą w kółko w kółko, próbując odkryć te różne rodzaje niczego, ale to wszystko to samo w skomplikowanych różnych ubraniach. Rzeczywistość jest

undefined===undeclared===null===0===""===[]==={}===nothing

I może wszyscy powinni rzucać wyjątki.

var x = null;

x jest zdefiniowane jako null

y nie jest zdefiniowane; // ponieważ go nie zdefiniowałem

if (!x)

wartość null jest oceniana jako fałsz

Jednym ze sposobów nadania wartości zerowej i niezdefiniowanej jest zrozumienie, gdzie występuje każda z nich.

Oczekuj zerowej wartości zwracanej w następujących sytuacjach:

• Metody kwerendujące DOM

  console.log(window.document.getElementById("nonExistentElement"));
  //Prints: null

• Odpowiedzi JSON otrzymane z żądania Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• Nowa funkcjonalność jest w ciągłym ruchu. Zwraca null:

        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

Wszystkie pozostałe przypadki nieistnienia są oznaczone jako niezdefiniowane (jak zauważył @Axel). Każdy z następujących wydruków jest „niezdefiniowany”:

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

Oczywiście, jeśli zdecydujesz się napisać var ​​unitialised = null; lub samodzielnie zwróć wartość NULL z metody, wówczas w innych sytuacjach wystąpi NULL. Ale to powinno być dość oczywiste.

Trzeci przypadek ma miejsce, gdy chcesz uzyskać dostęp do zmiennej, ale nawet nie wiesz, czy została zadeklarowana. W takim przypadku użyj typeof, aby uniknąć błędu odniesienia:

if(typeof unknown !== "undefined"){
    //use unknown
}

Podsumowując, sprawdź wartość null, gdy manipulujesz DOM, masz do czynienia z Ajaxem lub używasz niektórych funkcji ECMAScript 5. We wszystkich innych przypadkach można bezpiecznie sprawdzić, czy nie jest zdefiniowana z zachowaniem ścisłej równości:

if(value === undefined){
  // stuff
}

Porównanie wielu różnych kontroli zerowych w JavaScript:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

zarówno null, jak i undefined są równe false dla równości wartości (null == undefined): oba zwinięte są w wartość logiczną false. Nie są tym samym obiektem (null! == undefined).

undefined jest właściwością obiektu globalnego („okna” w przeglądarkach), ale jest typem pierwotnym, a nie samym obiektem. Jest to wartość domyślna dla niezainicjowanych zmiennych i funkcji kończących się bez instrukcji return.

null jest instancją Object. wartość null jest używana dla metod DOM, które zwracają obiekty kolekcji w celu wskazania pustego wyniku, co zapewnia fałszywą wartość bez wskazywania błędu.

Niektóre szczegóły:

null i undefined to dwie różne wartości. Jeden reprezentuje brak wartości nazwy, a drugi reprezentuje brak nazwy.

Co dzieje się w ifnastępujący sposób, wygląda następująco if( o ):

Wyrażenie w nawiasach o jest oceniane, a następnie ifkopnięcia w wymuszaniu typu wartości wyrażenia w nawiasach - w naszym przypadku o.

Falsy (które zostaną wymuszone na false) w JavaScript to: '', null, undefined, 0 i false .

Aby dodać do odpowiedzi Czym różni się od undefinedinull od JavaScript Definitive Guide 6th Edition, str. 41 na tej stronie :

Możesz rozważyć undefinedreprezentację na poziomie systemu, nieoczekiwany lub podobny do błędu brak wartości i nullreprezentację na poziomie programu, normalny lub oczekiwany brak wartości. Jeśli musisz przypisać jedną z tych wartości do zmiennej lub właściwości lub przekazać jedną z tych wartości do funkcji, nullprawie zawsze jest właściwym wyborem.

nulljest przedmiotem. Jego typ to zero. undefinednie jest przedmiotem; jego typ jest niezdefiniowany.

Poniższa funkcja pokazuje, dlaczego i jest w stanie ustalić różnicę:

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

Jeśli zadzwonisz

test();

Dostajesz

nieokreślony

zero

Pierwsze console.log(...)próbuje uzyskać myPropertyod myObjnatomiast nie jest jeszcze określona - tak to wróci „nieokreślone”. Po przypisaniu mu wartości null druga console.log(...)zwraca oczywiście „null”, ponieważ myPropertyistnieje, ale ma nullprzypisaną wartość .

Aby móc sprawdzić tę różnicę, JavaScript ma nulli undefined: Chociaż nulljest - podobnie jak w innych językach obiekt, undefinednie może być obiektem, ponieważ nie ma dostępnej instancji (nawet nullinstancji).

Na przykład window.someWeirdPropertyjest niezdefiniowany, więc

"window.someWeirdProperty === null" ocenia na false podczas

"window.someWeirdProperty === undefined" ocenia na prawdę.

Ponadto checkif if (!o)nie jest taka sama jak sprawdzanie if (o == null)dla obycia false.

Inną zabawną rzeczą w przypadku wartości null w porównaniu do niezdefiniowanej jest to, że można ją zwiększać.

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

Jest to przydatne do ustawiania domyślnych wartości liczbowych liczników. Ile razy ustawiłeś zmienną na -1 w jej deklaracji?

W Javascript null nie jest objecttypem, jest primitavetypem.

Jaka jest różnica? Niezdefiniowany odnosi się do wskaźnika, który nie został ustawiony. Null odnosi się do wskaźnika zerowego, na przykład coś ręcznie ustawiło zmienną na typnull

Spójrz na to:

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

Z „The Principles of Object-Oriented Javascript” autorstwa Nicholasa C. Zakasa

Ale dlaczego obiekt, gdy typ jest pusty? (W rzeczywistości został uznany za błąd przez komitet TC39, który projektuje i utrzymuje JavaScript. Mógłbyś rozumieć, że null jest wskaźnikiem pustego obiektu, co powoduje, że „obiekt” jest logiczną wartością zwracaną, ale nadal jest mylący.)

Zakas, Nicholas C. (2014-02-07). Zasady obiektowego JavaScript (lokalizacje Kindle 226-227). Brak prasy skrobiowej. Wersja Kindle.

To mówi:

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

Nieokreślona sprawa:

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

Najlepszym sposobem, aby pomyśleć o „null”, jest przypomnienie, jak podobna koncepcja jest używana w bazach danych, gdzie wskazuje, że pole nie zawiera „żadnej wartości”.

• Tak, wartość przedmiotu jest znana; to jest „określony”. To nie została zainicjowana.
• Wartość przedmiotu to: „nie ma wartości”.

Jest to bardzo przydatna technika pisania programów, które są łatwiejsze do debugowania. Nieokreślona zmienna może być wynikiem błędu ... (skąd byś wiedział?) ... ale jeśli zmienna zawiera wartość „null”, wiesz, że „ktoś gdzieś w tym programie ustaw ją na „null.” „Dlatego sugeruję, aby gdy trzeba pozbyć się wartości zmiennej, nie„ usuwaj ”... ustaw ją na„ null ”. Stara wartość zostanie osierocona i wkrótce zostanie wyrzucona do kosza; nowa wartość to „nie ma żadnej wartości (teraz)”. W obu przypadkach stan zmiennej jest pewny: „oczywiście, celowo, udało się to”.

1. Niezdefiniowana oznacza, że ​​zmienna została zadeklarowana, ale nie przypisano jej żadnej wartości, natomiast Null można przypisać do zmiennej reprezentującej „brak wartości” (Null jest operatorem przypisania)

2. Nieokreślony jest typem, podczas gdy Null jest obiektem.

3. Javascript może sam zainicjować dowolną nieprzypisaną zmienną na niezdefiniowaną, ale nigdy nie może ustawić wartości zmiennej na null. Należy to zrobić programowo.