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

Wybrałem to z tutaj

Wartość undefined jest prymitywną wartością używaną, gdy zmienna nie ma przypisano wartość.

Wartość null jest prymitywną wartością, która reprezentuje null, empty, lub nieistniejące odniesienie.

Gdy zadeklarujesz zmienną za pomocą var i nie nadasz jej wartości, będzie ona miała wartość undefined. Sam, jeśli spróbujesz WScript.Echo() lub alert() ta wartość, nic nie zobaczysz. Jednakże, jeśli Dodaj do niego pusty ciąg znaków, a wtedy nagle się pojawi:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

Możesz zadeklarować zmienną, ustawić ją na null, a zachowanie jest identyczne z tym, że zobaczysz" null "wydrukowane w porównaniu do "undefined". To naprawdę niewielka różnica.

Możesz nawet porównać zmienną, która jest niezdefiniowana do null lub odwrotnie, a warunek będzie true:

undefined == null
null == undefined

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

Uruchomienie powyższego skryptu spowoduje następujące wyjście:

undefined
object

Niezależnie od tego, czy są różnymi typami, zachowują się tak samo, jeśli spróbujesz uzyskać dostęp do jednego z nich, np. wyrzucą wyjątek. Z WSH zobaczysz przerażające "'varname' is null or not an object " i to jeśli masz szczęście (ale to temat na inny artykuł).

Można jednoznacznie ustawić zmienną na niezdefiniowaną, ale zdecydowanie odradzam. Polecam tylko ustawienie zmiennych na null i pozostawić undefined wartość dla rzeczy, które zapomniałeś ustawić. Jednocześnie naprawdę zachęcam do ustawiania każdej zmiennej. JavaScript ma łańcuch zakresów inny niż w językach w stylu C, łatwo dezorientuje nawet doświadczonych programistów, a ustawienie zmiennych na null jest najlepszym sposobem zapobiegania błędom w oparciu o to.

Innym przypadkiem, w którym zobaczysz wyskakujące okienko undefined, jest użycie operatora delete. Ci z nas ze świata C mogą błędnie zinterpretować to jako zniszczenie obiektu, ale tak nie jest. Operacja ta polega na usunięciu indeksu dolnego z tablicy lub elementu z obiektu. W przypadku tablic nie wpływa to na długość, lecz raczej na to, że indeks dolny jest teraz uważany za niezdefiniowany.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

Wynikiem powyższego skryptu jest:

0.) a
1.) undefined
2.) c

Otrzymasz również undefined zwracane podczas czytania indeksu lub elementu, który nigdy nie istniał.

Różnica między null i undefined jest taka: JavaScript nigdy nie ustawi niczego na null, to zwykle robimy. Chociaż możemy ustawić zmienne NA undefined, wolimy null, ponieważ nigdy nie jest to coś, co jest dla nas robione. Podczas debugowania oznacza to, że wszystko ustawione na null jest twoim własnym dziełem, a nie JavaScript. Poza tym te dwie specjalne wartości są prawie równoważne.

Null jest specjalnym słowem kluczowym, które wskazuje na brak wartości.

Pomyśl o tym jako o wartości, jak:

• "foo" to string,
• prawda jest logiczna,
• 1234 jest liczbą,
• null jest niezdefiniowana.

Undefined właściwość wskazuje, że zmiennej nie przypisano również wartości zawierającej null . Jak

var foo;

zdefiniowana pusta zmienna to null typu danych undefined

Oba reprezentują wartość zmiennej bez wartości

i null nie przedstawia ciągu, który nie ma wartości - pusty łańcuch -

Jak

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

Teraz jeśli

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

Ale

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

Więc każdy ma swój własny sposób użycia

Undefined Użyj go do porównania typu danych zmiennej

Null Użyj go, aby opróżnić wartość zmiennej

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

Null : Brak wartości dla zmiennej; undefined : Brak samej zmiennej;

..gdzie zmienna jest nazwą symboliczną powiązaną z wartością.

JS może być na tyle uprzejmy, że domyślnie init nowo zadeklarowanych zmiennych z null , ale tak nie jest.

Prosimy o uważne zapoznanie się z poniższymi informacjami. Usunie wszelkie wątpliwości dotyczące różnica między null i undefined w JavaScript. Możesz również użyć funkcji użytkowej podanej poniżej, aby dokładnie określić typy.

W JavaScript możemy mieć następujące typy zmiennych.

1. Zmienne Nierejestrowane
2. zadeklarowane, ale niepodpisane zmienne
3. zmienne przypisane literalnie undefined
4. przypisane zmienne with literal null
5. zmienne przypisane z czymkolwiek innym niż undefined lub null

Poniżej wyjaśniamy każdy z tych przypadków jeden po drugim

1. Zmienne Nierejestrowane : następujące wartości są prawdziwe dla zmiennych nierejestrowanych

   • może być sprawdzane tylko przez typeof () , który zwraca string 'undefined'
   • nie można sprawdzić za pomocą == lub === lub przez if lub operator warunkowy ? (wyrzuca błąd odniesienia)

2. Deklarowane, ale niepodpisane zmienne

   • typeof zwraca string 'undefined'
   • == Sprawdź za pomocą null zwraca true
   • == Sprawdź za pomocą undefined zwraca true
   • === Sprawdź za pomocą null zwraca false
   • === Sprawdź z undefined zwraca true
   • if czy operator warunkowy ? zwraca false

3. Zmienne przypisane literalnie undefined: zmienne te są traktowane podobnie jak zadeklarowane, ale niepodpisane zmienne .

4. Zmienne przypisane literalnie null

   • typeof zwraca łańcuch 'obiekt'
   • == Sprawdź za pomocą null zwraca true
   • == Sprawdź za pomocą undefined zwraca true
   • === Sprawdź za pomocą null zwraca true
   • === Sprawdź za pomocą undefined zwraca false
   • if czy operator warunkowy ? zwraca false

5. Zmienne przypisane z czymkolwiek innym niż undefined lub null

   • typeof zwraca jeden z następujących łańcuchów: 'string','numer','boolean','Funkcja', 'obiekt','symbol"

Poniżej przedstawiono algorytm poprawnego sprawdzania typu zmiennej:

1. sprawdź na /unassigned/przypisany z undefined za pomocą typeof . return if String 'undefined' jest zwracany.
2. Sprawdź null używając ===. return 'null' if true .
3. Sprawdź rzeczywisty Typ za pomocą typeof . return type if not equal to 'object'
4. Wywołanie Obiektu.prototyp.toString.call (o) aby określić rzeczywisty typ obiektu. Zwraca łańcuch typu '[object ObjectType] ' dla wszystkich wbudowanych w Javascript lub DOM zdefiniowanych obiektów. Dla zdefiniowanych przez użytkownika obiektów zwraca '[object Object] '

Możesz również użyć następującej funkcji użytkowej do określania typów. Obecnie obsługuje WSZYSTKIE TYPY ECMA 262 2017.

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

Undefined oznacza, że zmienna została zadeklarowana, ale nie ma wartości:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Null jest przypisaniem:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

Możesz rozważyć undefined, aby reprezentować brak wartości na poziomie systemu, nieoczekiwany lub podobny do błędu, a null, aby reprezentować brak wartości na poziomie programu, normalny lub oczekiwany.

Via JavaScript: The Definitive Guide

Wyjaśnię undefined, null i Uncaught ReferenceError:

1 - Uncaught ReferenceError : zmienna nie została zadeklarowana w Twoim skrypcie, nie ma odniesienia do tej zmiennej
2 - undefined: zmienna zadeklarowana, ale nie zainicjalizowana
3 - null: zmienna zadeklarowana i jest wartością pustą

Null i undefined są dwoma odrębnymi typami obiektów, które mają ze sobą wspólną cechę:

• oba mogą zawierać tylko jedną wartość, null i undefined ;
• oba obiekty nie mają żadnych właściwości ani metod, a próba odczytania dowolnej z nich spowoduje błąd w czasie wykonywania (dla wszystkich innych obiektów, otrzymasz wartość undefined jeśli spróbujesz odczytać nieistniejącą właściwość);
• wartości null oraz undefined są uważane za równe sobie i niczym innym przez operatory == i !=.

Podobieństwa jednak kończą się tutaj. Po raz pierwszy istnieje zasadnicza różnica w sposobie implementacji słów kluczowych nulli undefined. Nie jest to oczywiste, ale rozważ następujący przykład:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

Undefined, NaN i nieskończoność to tylko nazwy preinicjalizowanych zmiennych "superglobalnych" - są są inicjalizowane w czasie wykonywania i mogą być nadpisywane przez zwykłą globalną lub lokalną zmienną o tych samych nazwach.

Teraz spróbujmy tego samego z null :

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Inna różnica polega na tym, że undefined jest typem prymitywnym, podczas gdy null jest typem obiektowym (wskazującym brak odniesienie do obiektu). Rozważmy następujące:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

Istnieje również istotna różnica w sposobie, w jaki null i undefined są traktowane w kontekście liczbowym:

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

Null staje się 0 gdy jest używany w wyrażeniach arytmetycznych lub porównaniach liczbowych-podobnie jak false , jest to w zasadzie tylko specjalny rodzaj "zero". undefined , z drugiej strony, jest prawdziwym "niczym" i staje się NaN ("Nie liczbą"), gdy spróbuj użyć go w kontekście liczbowym.

Zauważ, że null i undefined otrzymują specjalne traktowanie od operatorów == i !=, ale możesz sprawdzić prawdziwą równość liczbową a i b za pomocą wyrażenia (a >= b && a <= b).

Tl;dr

Użyj null aby ustawić zmienną, o której wiesz, że jest obiektem.

Użyj undefined do ustawienia zmiennej, której typ jest mieszany.

To jest moje użycie zarówno 5 primitives, jak i Object type, I to wyjaśnia różnicę między "przypadkiem użycia" undefined lub null.

String

Jeśli wiesz, że zmienna jest tylko ciągiem podczas całego cyklu życia, zgodnie z konwencją, możesz ją zainicjować, aby "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Numer

Jeśli wiesz, że zmienna jest tylko liczbą podczas całego cyklu życia, zgodnie z konwencją, możesz ją zainicjować do 0 (lub NaN Jeśli 0 jest ważną wartością w Twoim Użyciu):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

Lub

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

Boolean

Jeśli wiesz, że zmienna jest tylko logiczna, podczas gdy cały cykl życia, zgodnie z konwencją, możesz ją zainicjować do false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

Obiekt

Jeśli wiesz, że zmienna jest tylko obiekt podczas całego cyklu życia, zgodnie z konwencją, można go zainicjować do null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Uwaga: inteligentne użycie off null ma być falsy wersją obiektu, ponieważ obiekt jest zawsze true, a ponieważ typeof null return object. Oznacza to, że typeof myVarObject zwraca spójną wartość zarówno dla typu Object, jak i null.

Wszystkie

Jeśli wiesz, że zmienna ma typ mieszany (dowolny typ podczas całego cyklu życia), zgodnie z konwencją, możesz ją zainicjować, do undefined.

Null jest słowem kluczowym języka, które ocenia do specjalnej wartości, która jest zwykle używana do wskazuje brak wartości. Użycie operatora typeof NA null zwraca łańcuch "object", wskazując, że null może być traktowany jako specjalna wartość obiektu, która wskazuje "no object" W praktyce jednak null jest zazwyczaj uważany za jedynego członka jego własny typ i może być używany do wskazania "brak wartości" dla liczb i łańcuchów, a także obiektów. Większość języków programowania ma odpowiednik null JavaScript: możesz bądź znany jako null lub nil.

JavaScript ma również drugą wartość, która wskazuje na brak wartości. Wartość undefined reprezentuje głębszy rodzaj nieobecności. Jest to wartość zmiennych, które nie zostały initialized oraz wartość otrzymaną podczas zapytania o wartość właściwości obiektu lub tablicy element, który nie istnieje. Wartość undefined jest zwracana również przez funkcje, które mają brak zwracanej wartości, a wartość funkcji parametry, dla których nie podano żadnego argumentu. undefined to predefiniowana zmienna globalna (Nie słowo kluczowe języka, takie jak null), która jest inicjalizowana na wartość undefined. W ECMAScript 3 undefined jest zmienną odczytu/zapisu, i można go ustawić na dowolną wartość. Błąd ten został poprawiony w ECMAScript 5 i undefined jest tylko do odczytu w tej wersji języka. Jeśli zastosujesz operator typeof do niezdefiniowanej wartości zwraca "undefined", wskazując, że ta wartość jest jedyną członek specjalnego Typ.

Pomimo tych różnic, zarówno null jak i undefined wskazują brak wartości i może być często używany zamiennie. Operator równości = = uważa je za równe. (Użyj ścisłego operatora równości===, aby je rozróżnić.) Obie są wartościami fałszywymi-są zachowuj się jak false, gdy wymagana jest wartość logiczna. Ani null, ani undefined nie mają wszelkie właściwości lub metody. W rzeczywistości, za pomocą . lub [], aby uzyskać dostęp do Właściwości lub metody tych wartość powoduje TypeError.

You might Uznaj, że undefined reprezentuje poziom systemowy, nieoczekiwany lub podobny do błędu brak wartości i null do reprezentowania na poziomie programu, normalnego lub oczekiwanego braku wartość. Jeśli chcesz przypisać jedną z tych wartości do zmiennej lub Właściwości lub przekazać jedną z wartości te do funkcji, null jest prawie zawsze właściwym wyborem.

null jest wartością specjalną oznaczającą "brak wartości". null jest obiektem specjalnym, ponieważ typeof null zwraca 'object'.

Z drugiej strony, undefined oznacza, że zmienna nie została zadeklarowana lub nie otrzymała wartości.

W Javassripcie istnieje 5 prymitywnych typów danych String, Number , Boolean, null i undefined. Postaram się wyjaśnić prostym przykładem

Powiedzmy, że mamy prostą funkcję

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

Również w powyższej funkcji if (a = = null) jest takie samo jak if(!a)

Teraz, gdy wywołamy tę funkcję bez przekazywania parametru a

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

Również

var a;
alert(typeof a); 

To da undefined; zadeklarowaliśmy zmienną, ale nie przypisaliśmy żadnej wartości do tej zmiennej; ale jeśli piszemy

var a = null;
alert(typeof a); will give alert as object

Więc null jest obiektem. w pewnym sensie przypisaliśmy wartość null do ' a '

Zarówno null, jak i undefined w JavaScript wskazują brak wartości.

var a = null; //variable assigned null value
var b;  // undefined

Pomimo faktu, że oba istnieją dla braku wartości, ale: Undefined w rzeczywistości oznacza, że zmienna nie jest inicjalizowana. Funkcje, które zwracają nic i parametry funkcji, dla których nie podano wartości, zwracana jest wartość undefined. Użyj ścisłego operatora równości = = = do rozróżnij null i undefined.

Odniesienie: http://www.thesstech.com/javascript/null-and-undefined

OK, możemy się mylić, gdy słyszymy o null i undefined, ale zacznijmy od prostych, oba są fałszywe i podobne pod wieloma względami, ale dziwna część JavaScript, sprawiają, że kilka istotnych różnic, na przykład, typeof null jest 'object', podczas gdy typeof undefined jest 'undefined'.

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

Ale jeśli sprawdzisz je za pomocą == jak poniżej, zobaczysz, że oba są fałszywe:

null==undefined; //true

Można również przypisać null do Właściwości obiektu lub do prymitywu, natomiast {[3] } można po prostu osiągnąć przez nie przypisując się do niczego.

Tworzę szybki obraz, aby pokazać różnice dla Ciebie na pierwszy rzut oka.

Jako typeof zwraca undefined, undefined jest typem, w którym jako NULL jest inicjalizator wskazuje, że zmienna nie wskazuje na żaden obiekt (praktycznie wszystko w Javascript jest obiektem).

Null i undefined są używane do reprezentowania braku pewnej wartości.

var a = null;

A jest inicjalizowana i zdefiniowana.

typeof(a)
//object

Null jest obiektem w JavaScript

Object.prototype.toString.call(a) // [object Object]

var b;

B jest niezdefiniowany i niezainicjalizowany

Niezdefiniowane właściwości obiektu są również niezdefiniowane. Na przykład "x" nie jest zdefiniowane w obiekcie c i jeśli spróbujesz uzyskać dostęp do c. x, zwróci undefined.

Zazwyczaj przypisujemy null do zmiennych, które nie są niezdefiniowane.

Dla typu undefined istnieje tylko jedna wartość: undefined.

Dla typu null istnieje tylko jedna wartość: null.

Więc dla obu z nich, etykieta jest zarówno jej typem, jak i wartością.

Różnica między nimi. Na przykład:

• null jest wartością pustą
• undefined jest brakującą wartością

Lub:

• undefined nie ma jeszcze wartości
• null miał wartość i nie anymore

W rzeczywistości null jest specjalnym słowem kluczowym, a nie identyfikatorem, dlatego nie można traktować go jako zmiennej do przypisania.

Jednak undefined jest identyfikatorem . W trybie non-strict i strict można jednak utworzyć zmienną lokalną o nazwie undefined. Ale to jest jeden okropny pomysł!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

Kiedy deklarujesz zmienną w javascript, przypisywana jest jej wartość undefined. Oznacza to, że zmienna jest nietknięta i może być przypisana dowolna wartość w przyszłości. Oznacza to również, że nie znasz wartości, którą ta zmienna będzie posiadać w momencie deklaracji.

Teraz możesz jawnie przypisać zmienną null. To znaczy, że zmienna nie posiada żadnej wartości. Na przykład - niektórzy ludzie nie mają drugiego imienia. Więc w takim przypadku lepiej przypisać wartość null do zmienna middlename obiektu person.

Przypuśćmy teraz, że ktoś uzyskuje dostęp do zmiennej middlename Twojego obiektu person i ma ona wartość undefined. Nie wiedziałby, czy programista zapomniał zainicjować tę zmienną lub czy nie ma żadnej wartości. Jeśli ma wartość null, wtedy użytkownik może łatwo wywnioskować, że middlename nie ma żadnej wartości i nie jest nietkniętą zmienną.

Najlepszym sposobem, aby zrozumieć różnicę, jest najpierw oczyszczenie umysłu z wewnętrznego działania JavaScript i po prostu zrozumienie różnic w znaczeniu między: {27]}

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

Istnieje różnica w znaczeniu między tymi trzema przypadkami, a JavaScript rozróżnia dwa ostatnie przypadki z dwiema różnymi wartościami, null i undefined. Możesz używać tych wartości jawnie, aby przekazać te znaczenia.

Więc jakie są niektóre z problemów specyficznych dla JavaScript, które powstają z powodu to filozoficzne podstawy?

1. Zadeklarowana zmienna bez inicjalizatora otrzymuje wartość undefined, ponieważ nigdy nie powiedziałeś nic o zamierzonej wartości.

   let supervisor;
   assert(supervisor === undefined);
   

2. Właściwość obiektu, który nigdy nie został ustawiony, ocenia się na undefined, ponieważ nikt nigdy nie powiedział nic o tej właściwości.

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);
   

3. null i undefined są "podobni" do siebie, ponieważ Brendan Eich tak powiedział. Ale dobitnie nie są równe każdemu inne.

   assert(null == undefined);
   assert(null !== undefined);
   

4. null i undefined na szczęście mają różne typy. null należy do typu Null i undefined do typu Undefined. To jest w specyfikacji, ale nigdy byś się o tym nie dowiedział z powodu dziwności, której Nie będę tutaj powtarzał.

5. Funkcja osiągająca koniec ciała bez wyraźnej instrukcji return zwraca undefined, ponieważ nie wiesz nic o tym, co zwracała.

Przy okazji, są inne formy "nicość" w JavaScript (dobrze jest studiować filozofię....)

• NaN
• użycie zmiennej, która nigdy nie została zadeklarowana i otrzymanie ReferenceError
• używając let lub const zdefiniowanej zmiennej lokalnej w swojej czasowej strefie martwej i otrzymując ReferenceError

• Puste komórki w rzadkich tablicach. Tak, nie są one nawet undefined, chociaż porównują === do niezdefiniowanych.

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]
  

Null - jest to wartość przypisania. Który jest używany ze zmienną do reprezentowania żadnej wartości. (its an object)

Undefined - jest zmienną, która nie ma przypisanej wartości. Tak więc javascript przypisze do niego undefined. (its an typ danych)

Undeclared - jeśli zmienna nie jest w ogóle tworzona, jest ona znana jako undeclared.

Różnica między undefined i null jest minimalna, ale jest różnica. Zmienna, której wartością jest undefined, nigdy nie została zainicjowana. Zmienna, której wartością jest null, otrzymała jawnie wartość null, co oznacza, że zmienna została jawnie ustawiona na brak wartości. Jeśli porównasz undefined i {[1] } używając wyrażenia null==undefined, będą one równe.

Za dokładny artykuł Ryana Morra na ten temat...

"Ogólnie rzecz biorąc, jeśli chcesz przypisać inną wartość zmiennej lub właściwości, przekazać ją funkcji lub zwrócić z funkcji, null jest prawie zawsze najlepszą opcją. Mówiąc prościej, JavaScript używa undefined, a programiści powinni używać null."

Zobacz odkrywanie wiecznej Otchłani Null i Undefined

W JavaScript, null jest dla obiektów, undefined jest dla zmiennych, właściwości i metod.

Aby mieć wartość null, obiekt musi zostać zdefiniowany, w przeciwnym razie będzie niezdefiniowany.

Jeśli chcesz sprawdzić, czy obiekt istnieje, spowoduje to wyświetlenie błędu, jeśli obiekt jest niezdefiniowany:

Niepoprawne:

if (myObj !== null && typeof myObj !== "undefined") 

Z tego powodu musisz najpierw przetestować typeof ():

Poprawny:

if (typeof myObj !== "undefined" && myObj !== null) 

Gdy wartość jest null, jest niczym i nie zawiera niczego. Pusta wartość lub zmienna jest nadal pełna; jest po prostu pełna pustki. Pustka różni się od null, czyli po prostu niczym. Na przykład zdefiniowanie zmiennej i ustawienie jej wartości na pusty łańcuch wygląda tak:

 var myVariable = ''; 

Zmienna myVariable jest pusta, ale nie jest null.

Undefined jest stanem, czasami używanym jako wartość, do reprezentowania zmiennej, która nie zawiera jeszcze wartości. takie jak var abcd;. Ten stan różni się od null, chociaż zarówno null, jak i undefined mogą oceniać w ten sam sposób.

• undefined oznacza, że zmienna została zadeklarowana, ale nie została jeszcze przypisana wartość.
• null jest wartością przypisania. Może być przypisany do zmiennej jako reprezentacja bez wartości.
• undefined I null są dwoma odrębnymi typami:

Undefined jest typem (undefined) podczas gdy null jest obiektem.

• zmienne Nieprzypisane są inicjalizowane przez JavaScript z domyślną wartością undefined.
• JavaScript nigdy nie ustawia wartości na null. Trzeba to zrobić programowo.

Zasadniczo, Undefined jest globalną zmienną, którą javascript tworzy w czasie wykonywania, bez względu na to, czy null oznacza, że żadna wartość nie została przypisana do zmiennej (w rzeczywistości null jest sama w sobie obiektem).

Weźmy przykład:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

Undefined to jest to, co otrzymasz jako wyjście.

Teraz,

        x=5;
        y=null;
        z=x+y;

I dostaniesz 5 jako wyjście. To główna różnica między Undefined i null

W javascript wszystkie zmienne są przechowywane jako pary wartości klucza. Każda zmienna jest przechowywana jako variable_name: variable_value/reference .

Undefined oznacza, że zmiennej nadano miejsce w pamięci, ale nie przypisano do niej żadnej wartości. Jako najlepsza praktyka, nie powinieneś używać tego typu jako zadania.

W takim przypadku jak określić, gdy chcesz, aby zmienna była bez wartości w późniejszym punkcie kodu? Możesz użyć typu null , która jest również typ, który jest używany do zdefiniowania tej samej rzeczy, brak wartości, ale nie jest to to samo co undefined, ponieważ w tym przypadku rzeczywiście masz wartość w pamięci. Ta wartość to null

Oba są podobne, ale użycie i znaczenie są różne.

Jeśli zmienna nie jest inicjalizowana, to jest niezdefiniowana. undefined nie jest obiektem. Przykład: var MyName; konsola.log (typeof MyName);

Sprawdź narzędzie programistyczne console log in, zostanie ono wydrukowane jako undefined.

Null jest obiektem A.Jeśli chcesz, aby jakaś zmienna była null, to null jest używane.zmienna null istnieje, ale wartość nie jest known.It powinien być przypisany do zmiennej pro gramatycznie. null nie jest inicjowana automatycznie.

Przykład: var MyName = null; konsola.log(rodzaj nazwy); Sprawdź narzędzie programistyczne csole log in, będzie to obiekt.

Aby dodać moje poglądy -

Zmienna, która jest zadeklarowana i nigdy nigdzie nie używana, jest usuwana przez kompilator optymalizujący w przypadku skompilowanych języków, takich jak C++[lub ostrzeżenie jest oznaczone w IDE]. Ostatecznie oznacza to, że zmienna nie istnieje, ponieważ jej pamięć nigdy nie jest przydzielana.

W przypadku interpretera javascript, [domyślam się] zmienna jest traktowana jako istniejąca tylko od punktu, w którym otrzymuje wartość. Przed tym punktem jest to typ "undefined" i nie jest przydzielana do niego pamięć. A więc jego typ jest nieokreślony.

Null w javascript jest wartością, która reprezentuje adres, ale ten adres nie wskazuje jeszcze na nic [nieistniejące odniesienie]. Niemniej jednak, jego wartość.