Dlaczego null jest obiektem i jaka jest różnica między null A undefined?

Różnicę można podsumować w tym fragmencie:

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

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

Sprawdzanie

object == null jest inny do sprawdzenia if ( !object ).

Ten ostatni jest równy ! Boolean(object), ponieważ operator uniary ! automatycznie wrzuca prawy operand do logiki logicznej.

Since Boolean(null) równa się false then !false === true.

Więc jeśli twój obiekt jest nie null, Ale false lub 0 lub "", czek przejdzie ponieważ:

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

null jest nie obiektem , jest prymitywną wartością . Na przykład nie można dodać do niego właściwości. Czasami ludzie błędnie zakładają, że jest to obiekt, ponieważ typeof null zwraca "object". Ale to jest rzeczywiście błąd (który może być nawet naprawiony w ECMAScript 6).

Różnica między null i undefined jest następująca:

• undefined: używany przez JavaScript i oznacza "brak wartości". Niezaliczone zmienne, brakujące parametry i nieznane zmienne mają tej wartości.

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

  Dostęp do nieznanych zmiennych powoduje jednak wyjątek:

  > unknownVariable
  ReferenceError: unknownVariable is not defined
  

• null: używany przez programistów do wskazania "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

Ogólnie rzecz biorąc, należy zawsze używać = = = i nigdy = = w JavaScript (== wykonuje wszystkie rodzaje konwersji, które mogą przynieść nieoczekiwane wyniki). Sprawdzanie x == null jest przypadkiem krawędzi, ponieważ działa zarówno dla null i undefined:

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

Powszechnym sposobem sprawdzania, czy zmienna ma wartość, jest przekonwertowanie jej na wartość logiczną i sprawdzenie, czy jest ona true. Konwersja ta jest wykonywana przez polecenie if i operator boolean ! ("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ą się na false, więc trzeba być ostrożnym(np. powyższe kontrole nie rozróżniają undefined i 0).

• undefined, null
• Booleans: false
• liczby: +0, -0, NaN
• ciągi: ""

Możesz przetestować konwersję na boolean używając Boolean jako funkcji (zwykle jest to Konstruktor, do użycia z new):

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

Jaka jest różnica między null A undefined??

Właściwość, gdy nie ma definicji, jest niezdefiniowana. null jest obiektem. Jego typem jest obiekt. null jest wartością specjalną, co oznacza " brak wartości. undefined nie jest obiektem, jego typ jest niezdefiniowany.

Możesz zadeklarować zmienną, ustawić ją na null, a zachowanie jest identyczne z tym, że zobaczysz" null "wydrukowane w porównaniu do "undefined". Można nawet porównać zmienną, która jest niezdefiniowana do null lub odwrotnie, a warunek będzie prawdziwy:

 undefined == null
 null == undefined

Zobacz JavaScript różnica między null i undefined aby uzyskać więcej szczegółów.

I z nowym edytuj Tak

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

Podczas testowania jeśli obiekt jest fałszywy, oba spełniają warunek tylko podczas testowania if false , ale nie gdy true

Sprawdź tutaj: Javascript gotcha

Pierwsza część pytania:

Dlaczego null jest uważany za obiekt w JavaScript?

Jest to błąd projektu JavaScript, którego nie mogą teraz naprawić. Powinien być typu null, Nie typu obiektu, lub nie mieć go w ogóle. Wymaga dodatkowego sprawdzenia (czasami zapomnianego) 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

Te dwie kontrole są zawsze Fałszywe, z wyjątkiem:

• Obiekt jest undefined lub null: both true.

• Obiekt jest prymitywny, a 0, "", lub false: pierwsze sprawdzenie false, drugie true.

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

Więc jeśli' obiekt ' jest interpretowany jako obiekt rzeczywisty, to oba sprawdzania są zawsze to samo. Jeśli dozwolone są prymitywy, to kontrole są różne dla 0, "" I false.

W przypadkach takich jak object==null, nieoczywiste wyniki mogą być źródłem błędów. Nie zaleca się stosowania ==, zamiast tego należy stosować ===.

Trzecia część pytania:

A także:

Jaka jest różnica między null A undefined?

W JavaScript jedną z różnic jest to, że null jest typu object, a undefined jest typu undefined.

W JavaScript, null==undefined jest prawdziwe i traktowane jako równe, Jeśli typ jest ignorowany. Dlaczego tak zdecydowali, ale 0, "" I false nie są równe, Nie wiem. Wydaje się, że to arbitralna opinia.

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

W rzeczywistości null i undefined są identyczne, ponieważ oba reprezentują nieistnienie. Więc zrób 0, i "" dla tej sprawy też, i może puste pojemniki [] i {}. Tak wielu rodzaje tego samego nic to przepis na błędy. Jeden typ lub żaden w ogóle jest lepszy. Postaram się użyć jak najmniej.

'false', 'true ' i'!"czy kolejny worek robaków, który można uprościć, na przykład, if(!x) i if(x) same są wystarczające, nie potrzebujesz prawdy i fałszu.

Zadeklarowana var x jest typu undefined, jeśli nie podano żadnej wartości, ale powinna być taka sama, jak gdyby x w ogóle nie został zadeklarowany. Innym źródłem błędu jest pusty kontener nothing. Więc najlepiej jest zadeklarować i zdefiniować razem, jak var x=1.

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

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

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

typeof null;      // object
typeof undefined; // undefined

Wartość null reprezentuje zamierzony brak jakiejkolwiek wartości obiektu. Jest to jedna z prymitywnych wartości JavaScript i jest traktowana jako falsy dla operacji logicznych.

var x = null;
var y;

X jest zadeklarowane i zdefiniowane jako null

Y jest zadeklarowane, ale nie zdefiniowane. Jest zadeklarowana bez wartości, więc jest niezdefiniowana.

Z nie jest zadeklarowane, więc będzie również niezdefiniowane, jeśli spróbujesz użyć z.

Jednym ze sposobów na zrozumienie null i undefined jest zrozumienie, gdzie każde z nich występuje.

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

• Metody zapytujące DOM

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

• Odpowiedzi JSON otrzymane z żądania Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• Nowa funkcjonalność, która jest w stanie zmian. Następujące zwraca null:

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

       // But this returns undefined:

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

Wszystkie inne przypadki nie-istnienie jest oznaczane przez undefined (jak zauważył @Axel). Każdy z następujących wydruków "undefined":

    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 unitialized = null; lub samemu zwrócić null Z metody, wtedy masz null występujące w innych sytuacjach. Ale to powinno być dość oczywiste.

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

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

In summary check dla null, gdy manipulujesz DOM, radzisz sobie z Ajaxem lub używasz pewnych funkcji ECMAScript 5. Dla wszystkich innych przypadków można bezpiecznie sprawdzić undefined ze ścisłą równością:

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

Porównanie wielu różnych sprawdzeń null 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

Aby dodać do odpowiedzi Jaka jest różnica między undefined a null, z JavaScript Definitive Guide 6th Edition, str. 41 na tej stronie :

Możesz rozważyć undefined reprezentowanie poziomu systemowego, nieoczekiwanego, lub błędny brak wartości i null do reprezentowania poziomu programu, normalny lub oczekiwany brak wartości. Jeśli chcesz przypisać jeden z tych wartości do zmiennej lub Właściwości lub przekazać jedną z tych wartości do funkcja, {[1] } jest prawie zawsze dobry wybór.

Null i undefined są zarówno false dla równości wartości (null==undefined): obie zapadają się do wartości logicznej false. Nie są one tym samym obiektem (null!= = undefined).

Undefined jest właściwością obiektu globalnego ("window" w przeglądarkach), ale jest typem prymitywnym, a nie samym obiektem. Jest to wartość domyślna dla niezainicjalizowanych zmiennych i funkcji kończących się bez instrukcji return.

Null jest instancją obiektu. null jest używany do metod DOM zwracających obiekty kolekcji aby wskazać pusty wynik, który dostarcza wartość false bez wskazywania błędu.

Niektóre precyzje:

Null i undefined to dwie różne wartości. Jedna reprezentuje brak wartości dla nazwy, a druga reprezentuje brak nazwy.

Co dzieje się w if dla if( o ) wygląda następująco:

Wyrażenie w nawiasach o jest obliczane, a następnie if rozpoczyna Typ-wymuszając wartość wyrażenia w nawiasach-w naszym przypadku o.

Falsy (które zostaną wymuszone na false) wartości w JavaScript to: ", null, undefined, 0 I false .

null jest przedmiotem. Jego typ to null. undefined nie jest obiektem; jego typ jest niezdefiniowany.

Następująca funkcja pokazuje dlaczego i jest w stanie obliczyć różnicę:

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

Jeśli zadzwonisz

test();

Dostajesz

Undefined

Null

Pierwszy console.log(...) próbuje uzyskać myProperty z myObj, gdy nie jest jeszcze zdefiniowany - więc wraca "undefined". Po przypisaniu null, drugi console.log(...) zwraca oczywiście "null", ponieważ myProperty istnieje, ale ma przypisaną do niego wartość null.

Aby móc odpytywać ta różnica, JavaScript ma null i undefined: podczas gdy null jest - podobnie jak w innych językach obiekt, undefined nie może być obiektem, ponieważ nie ma instancji (nawet nie ma instancji null) dostępnej.

Na przykład window.someWeirdProperty jest niezdefiniowany, więc

"window.someWeirdProperty === null" evaluates to false while

"window.someWeirdProperty === undefined" / align = "left" /

Ponadto checkif if (!o) nie jest tym samym co checkif if (o == null) dla o jest false.

In Javascript null nie jest typem object jest typem primitave.

Co za różnica? Undefined odnosi się do wskaźnika, który nie został ustawiony. Null odnosi się do wskaźnika null, na przykład coś ręcznie ustawiło zmienną typu null

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 "zasad Obiektowego Javascript" Nicholasa C. Zakasa

Ale dlaczego Obiekt, gdy typ jest null? (W rzeczywistości zostało to uznane za błąd przez tc39, komitet, który projektuje i utrzymuje JavaScript. Można wywnioskować, że null jest pustym wskaźnikiem obiektu, co czyni" obiekt " logiczną wartością zwracaną, ale nadal jest to mylące.)

To powiedział:

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ślony przypadek:

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 myślenia o 'null' jest przypomnienie, jak podobne pojęcie jest używane w bazach danych, gdzie oznacza, że pole zawiera " żadnej wartości."

• tak, wartość elementu jest znana; jest zdefiniowana jako.'It has been initialized.
• wartość elementu to: "nie ma wartości."

Jest to bardzo przydatna technika do pisania programów, które są łatwiejsze do debugowania. Zmienna 'undefined' może być wynikiem błędu ... (skąd wiesz?) ... ale jeśli zmienna zawiera wartość 'null', wiesz, że " ktoś, gdzieś w tym programie, ustawić na 'null.'"Dlatego sugeruję, aby, gdy trzeba pozbyć się wartości zmiennej, nie "kasować"... Ustaw NA "null".'Stara wartość zostanie osierocona i wkrótce będzie zbierana; nowa wartość to:" nie ma wartości (teraz)."W obu przypadkach stan zmiennej jest pewien:" oczywiście, celowo, tak się stało."

Inną zabawną rzeczą w null, w porównaniu do undefined, jest to, że może być zwiększana.

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

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

1. Undefined oznacza, że zmienna została zadeklarowana, ale nie została jej przypisana żadna wartość, podczas gdy Null może być przypisana do zmiennej reprezentującej "brak wartości".(Null jest operatorem przypisania)

2.Undefined jest samym typem, podczas gdy null jest obiektem.

3.Javascript może sam zainicjalizować dowolną zmienną bez przypisania do undefined, ale nigdy nie może ustawić wartości zmiennej NA null. Trzeba to zrobić programowo.

TLDR

undefined jest prymitywną wartością w JavaScript, która wskazuje na niejawny brak wartości. Zmienne niezaliczane automatycznie mają tę wartość, a funkcje bez jawnej instrukcji return zwracają undefined.

null jest również prymitywną wartością w JavaScript. Wskazuje celowy brak wartości obiektu . null w JavaScript został zaprojektowany, aby umożliwić interoperacyjność z Java.

typeof null zwraca "object" ponieważ specyfika w projektowaniu języka, wynikająca z żądania, aby JavaScript był interoperacyjny z Javą. Nie oznacza to, że null jest instancją obiektu. Oznacza to: biorąc pod uwagę drzewo typów prymitywnych w JavaScript, null jest częścią poddrzewa "obiektowego typu prymitywnego". Zostało to dokładniej wyjaśnione poniżej.

Szczegóły

undefined jest prymitywną wartością, która reprezentuje Ukryty brak wartości. Zauważ, że undefined nie było bezpośrednio dostępne do JavaScript 1.3 w 1998 roku. To mówi nam, że null miała być wartością używaną przez programistów, gdy wyraźnie wskazywała brak wartości. Niezainicjalizowane zmienne automatycznie mają wartość undefined. undefined jest typem jedynym w swoim rodzaju w specyfikacji ECMAScript.

null jest prymitywną wartością, która reprezentuje celowy brak wartości obiektu. null jest również jedynym w swoim rodzaju typem W Ecmascripcie Specyfikacja.

null w JavaScript został zaprojektowany z myślą o umożliwieniu współdziałania z Java, w 2006 roku, w ramach programu LiveConnect Java/js bridge, uruchomiony został program LiveConnect Java / js bridge. Brendan Eich i inni od tego czasu wyrazili niechęć do włączenia dwóch "braku wartości" wartości, ale w 1995 roku Eich byłpod rozkazami , aby "sprawić, by [JavaScript] wyglądał jak Java".

Brendan Eich :

Gdybym nie miał "Make it look like Java" jako zlecenie od kierownictwa, i miałem więcej czasu (trudno było odkryć te dwa czynniki przyczynowe), wtedy wolałbym samo-podobne " wszystko jest przedmiotem" podejście: no Boolean, Number, String wrappers. No undefined and null. Westchnienie.

W celu uwzględnienia koncepcji Javy null, która ze względu na silnie typowaną naturę Javy może być przypisana tylko do zmiennych typowanych do typu odniesienia (raczej prymitywne), Eich zdecydował się umieścić specjalną wartość null na górze łańcucha prototypów obiektu (tj. top of the reference types), oraz włączenie typu null jako części zbioru "obiektowych pierwiastków".

Operator typeof został dodany wkrótce potem w JavaScript 1.1 , wydanym 19 sierpnia 1996 roku.

From The V8 blog :

typeof null zwraca object, a nie null, mimo że null jest swego rodzaju. Zrozumieć dlaczego, rozważ, że zbiór wszystkich Typy JavaScript są podzielone na dwie grupy:

1. obiekty (tzn. typ obiektu)
2. primitives (tj. dowolna wartość nieobiektowa)

Jako takie, null oznacza "brak wartości obiektu", podczas gdy undefined oznacza " nie wartość".

Zgodnie z tą linią myślenia, Brendan Eich zaprojektował JavaScript, aby make typeof return 'object' dla wszystkich wartości po prawej stronie, czyli wszystkie obiektów i wartości null, w duchu Javy. Dlatego typeof null === 'object' pomimo, że spec ma odrębny typ null.

Niespodzianka wyrażony przez programistów JavaScript w typeof null === "object" jest wynikiem niedopasowania impedancji (lub wycieku abstrakcji) pomiędzy słabo wpisywanym językiem (JavaScript), który ma zarówno null, jak i undefined, a innym, silnie wpisywanym językiem (Java), który ma tylko null i w którym null jest ściśle zdefiniowanym, aby odnosić się do typu odniesienia (nie prymitywnego).

Zauważ, że to wszystko jest logiczne, rozsądne i możliwe do obrony. typeof null === "object" to nie błąd, ale efekt drugiego rzędu konieczności dostosuj interoperacyjność Javy.

Pojawiło się wiele niedoskonałych wstecznych racjonalizacji i/lub konwencji, w tym, że undefined wskazujeimplicit brak wartości, i że null wskazujeintencjonalny brak wartości; lub że undefined jest brakiem wartości, a null jest konkretnie brakiemobiektu wartość.

Istotna rozmowa z Brendanem Eichem, screenshoty dla potomność:

Użyj null, aby zdefiniować coś jako nie posiadające wartości, użyj undefined, gdy oczekujesz, że coś może nie być zdefiniowane w ogóle.

Na przykład, jeśli zmienna nie ma wartości, przypisz ją jako null.

var weDontHaveAValue = null;

Jeśli spodziewasz się, że coś może nie być w ogóle zdefiniowane, np. opcjonalny argument options, użyj undefined.

if (typeof args.optionalParam !== 'undefined') { }