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

Chcę wiedzieć, jaka jest różnica między nulli undefinedw JavaScript.

W JavaScript undefinedoznacza , że zmienna została zadeklarowana, ale nie przypisano jej jeszcze wartości, takiej jak:

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

nulljest wartością przypisania. Może być przypisany do zmiennej jako reprezentacja bez wartości:

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

Z powyższych przykładów, jest oczywiste, że undefinedi nulldwa różne typy: undefinedto samo (nieokreślony) typu, a nullcelem.

null === undefined // false
null == undefined // true
null === null // true

i

null = 'value' // ReferenceError
undefined = 'value' // 'value'

Wybrałem to stąd

Niezdefiniowana wartość jest pierwotną wartością używaną, gdy zmiennej nie została przypisana wartość.

Wartość null jest pierwotną wartością, która reprezentuje odwołanie null, puste lub nieistniejące.

Kiedy zadeklarujesz zmienną przez var i nie podasz jej wartości, wartość będzie niezdefiniowana. Samo, jeśli spróbujesz WScript.Echo () lub alert () tę wartość, nic nie zobaczysz. Jeśli jednak dodasz do niego pusty ciąg, nagle pojawi się:

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

Możesz zadeklarować zmienną, ustawić ją na null, a zachowanie jest identyczne, z wyjątkiem tego, że zobaczysz wydruk „null” i „niezdefiniowany”. To naprawdę niewielka różnica.

Możesz nawet porównać zmienną niezdefiniowaną do wartości null lub odwrotnie, a warunek będzie spełniony:

undefined == null
null == undefined

Uważa się je jednak za dwa różne typy. Choć niezdefiniowany jest typem samym w sobie, null jest uważany za specjalną wartość obiektu. Możesz to zobaczyć za pomocą typeof (), który zwraca ciąg reprezentujący ogólny typ zmiennej:

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

Uruchomienie powyższego skryptu spowoduje następujące wyniki:

undefined
object

Bez względu na to, że są różnymi typami, będą nadal działać tak samo, jeśli spróbujesz uzyskać dostęp do członka jednego z nich, np. Oznacza to, że zgłoszą wyjątek. Dzięki WSH zobaczysz, że przerażające „zmienna” ma wartość zerową lub nie jest przedmiotem ”, i jeśli masz szczęście (ale to temat na inny artykuł).

Możesz jawnie ustawić zmienną na niezdefiniowaną, ale odradzam ją. Polecam tylko ustawić zmienne na null i pozostawić niezdefiniowaną wartość rzeczy, o których zapomniałeś ustawić. Jednocześnie naprawdę zachęcam do ustawiania każdej zmiennej. JavaScript ma łańcuch zasięgu inny niż w językach w stylu C, łatwo myląc nawet doświadczonych programistów, a ustawienie zmiennych na null jest najlepszym sposobem na uniknięcie błędów opartych na nim.

Innym przykładem, w którym zobaczysz niezdefiniowane wyskakujące okienko, jest użycie operatora usuwania. Ci z nas ze świata C mogą błędnie interpretować to jako niszczenie obiektu, ale tak nie jest. Operacja ta polega na usunięciu indeksu dolnego z tablicy lub elementu z obiektu. W przypadku tablic nie ma to wpływu na długość, ale raczej 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ż niezdefiniowany zwrot podczas czytania indeksu dolnego lub członka, który nigdy nie istniał.

Różnica między wartością null a niezdefiniowaną jest taka: JavaScript nigdy nie ustawi niczego na null, zwykle to robimy. Chociaż możemy ustawić zmienne na niezdefiniowane, wolimy null, ponieważ nie jest to coś, co kiedykolwiek zostało zrobione dla nas. Kiedy debugujesz, oznacza to, że wszystko ustawione na null należy do ciebie, a nie JavaScript. Poza tym te dwie specjalne wartości są prawie równoważne.

(dodawanie znaków z powodu braku znaków, więc mogę to opublikować).

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

myśl o tym jako o wartości, takiej jak:

• „foo” to ciąg znaków,
• prawda jest logiczna,
• 1234 to liczba,
• null jest niezdefiniowany.

undefined właściwość wskazuje, że zmiennej nie przypisano również wartości null. Lubić

var foo;

zdefiniowana pusta zmienna ma nulltyp danychundefined

Oba reprezentują wartość zmiennej bez wartości

AND null nie reprezentuje ciągu, który nie ma wartości - pusty ciąg-

Lubić

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 zmiennej typu danych

null użyj go do opróżnienia wartości zmiennej

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

null : brak wartości dla zmiennej; nieokreślony : brak samej zmiennej;

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

JS może być na tyle uprzejmy, że domyślnie inicjuje nowo zadeklarowane zmienne z wartością null , ale tak nie jest.

Przeczytaj uważnie następujące informacje. Spowoduje to usunięcie wszystkich wątpliwości dotyczących różnicy między wartością null a niezdefiniowaną w JavaScript. Możesz także użyć funkcji użyteczności podanej poniżej, aby dokładnie określić typy.

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

1. Niezadeklarowane zmienne
2. Zadeklarowane, ale nieprzypisane zmienne
3. Zmienne przypisane dosłownie niezdefiniowane
4. Zmienne przypisane dosłownie null
5. Zmienne przypisane do niczego innego niż niezdefiniowany lub zerowy

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

1. Niezadeklarowane zmienne : Poniższe odnosi się do niezadeklarowanych zmiennych

   • Można to sprawdzić tylko za pomocą typeof (), który zwraca ciąg „undefined”
   • Nie można tego sprawdzić za pomocą == lub === albo operatora if lub warunkowego ? (zgłasza błąd odniesienia)

2. Zadeklarowane, ale nieprzypisane zmienne

   • typeof zwraca ciąg „undefined”
   • == sprawdź, czy null zwraca true
   • == sprawdź z niezdefiniowanymi zwrotami true
   • === sprawdzenie z wartością null zwraca false
   • === sprawdź z niezdefiniowanymi zwrotami true
   • czy czy operator warunkowy ? zwraca false

3. Zmienne przypisane dosłownie niezdefiniowanym : Zmienne te są traktowane podobnie jak Zmienne zadeklarowane, ale nieprzypisane .

4. Zmienne przypisane dosłownie null

   • typeof zwraca ciąg „object”
   • == sprawdź, czy null zwraca true
   • == sprawdź z niezdefiniowanymi zwrotami true
   • === sprawdź, czy null zwraca true
   • === sprawdź z niezdefiniowanym zwraca false
   • czy czy operator warunkowy ? zwraca false

5. Zmienne przypisane do niczego innego niż niezdefiniowany lub zerowy

   • typeof zwraca jeden z następujących ciągów: „ciąg” , „liczba” , „boolean” , „funkcja” , „obiekt” , „symbol”

Poniżej przedstawiono algorytm poprawnego sprawdzania typu zmiennej:

1. Sprawdź niezadeklarowane / nieprzypisane / przypisane z niezdefiniowanym za pomocą typeof . return, jeśli zwracany jest ciąg „undefined” .
2. Sprawdź wartość null za pomocą === . zwróć „null”, jeśli true .
3. Sprawdź rzeczywisty typ za pomocą typeof . zwracany typ, jeśli nie jest równy „obiektowi”
4. Wywołaj Object.prototype.toString.call (o), aby określić rzeczywisty typ obiektu. Zwraca ciąg typu „[object ObjectType]” dla wszystkich wbudowanych obiektów JavaScript lub DOM zdefiniowanych. W przypadku obiektów zdefiniowanych przez użytkownika zwraca „[Object Object]”

Możesz także użyć następującej funkcji narzędzia 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 
}

Można uznać, że niezdefiniowany reprezentuje brak wartości na poziomie systemu, nieoczekiwany lub podobny do błędu, a null reprezentuje brak wartości na poziomie programu, normalny lub oczekiwany.

przez JavaScript: Przewodnik definitywny

Wytłumaczę undefined, nulli 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 została zainicjowana
3 - null: Zmienna zadeklarowana i jest pustą wartością

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

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

Null to zadanie:

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

null i undefined to dwa różne typy obiektów, które mają następujące wspólne cechy:

• oba mogą zawierać tylko jedną wartość, odpowiednio zerową i niezdefiniowaną ;
• obie nie mają właściwości ani metod, a próba odczytania którejkolwiek z nich spowoduje błąd w czasie wykonywania (dla wszystkich innych obiektów wartość będzie niezdefiniowana, jeśli spróbujesz odczytać nieistniejącą właściwość);
• Wartości NULL i nieokreślone są uznawane za równe sobie nawzajem i do niczego innego przez ==i !=operatorów.

Podobieństwa jednak kończą się tutaj. Po raz pierwszy istnieje zasadnicza różnica w sposobie implementacji słów kluczowych null i 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 Infinity to tylko nazwy wstępnie zainicjowanych zmiennych „superglobalnych” - są one inicjalizowane w czasie wykonywania i mogą zostać zastąpione przez normalną zmienną globalną lub lokalną o tych samych nazwach.

Teraz spróbujmy tego samego z zerą :

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

Ups! null , true i false są zastrzeżonymi słowami kluczowymi - kompilator nie pozwoli na użycie ich jako nazw zmiennych lub właściwości

Inna różnica polega na tym, że niezdefiniowany jest typ pierwotny, a null jest typem obiektu (co wskazuje na brak odwołania do obiektu). Rozważ 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 traktowania wartości null i undefined w kontekście numerycznym:

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 numerycznych - podobnie jak false , jest to po prostu specjalny rodzaj „zero”. z drugiej strony undefined jest prawdziwym „niczym” i staje się NaN („nie liczbą”), gdy próbujesz go użyć w kontekście numerycznym.

Zauważ, że wartość null i niezdefiniowanych otrzymać specjalne traktowanie ze ==i !=operatorów, ale można przetestować prawdziwej równości numeryczną i B z ekspresją .(a >= b && a <= b)

tl; dr

Użyj nulldo ustawienia zmiennej, o której wiesz, że jest obiektem.

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

To jest moje użycie zarówno 5 prymitywów, jak i typu Object, i to wyjaśnia różnicę między «przypadkiem użycia» undefinedlub null.

Strunowy

Jeśli wiesz, że zmienna jest tylko łańcuchem 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ć, aby 0(lub NaNjeśli 0jest to ważna wartość w 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 wartością logiczną podczas całego cyklu życia, zgodnie z konwencją, możesz ją zainicjować, aby false:

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

Obiekt

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

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

Uwaga: inteligentne użycie off null ma być fałszywą wersją Object, ponieważ Object jest zawsze truei ponieważ typeof nullreturn object. Oznacza to typeof myVarObjectzwrócenie spójnej wartości zarówno dla typu Object, jak i null.

Wszystko

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

nullto specjalna wartość oznaczająca „brak wartości”. nulljest obiektem specjalnym, ponieważ typeof nullzwraca „obiekt”.

Z drugiej strony undefinedoznacza, że ​​zmienna nie została zadeklarowana lub nie otrzymała żadnej wartości.

Najlepszym sposobem na zrozumienie różnicy jest najpierw oczyszczenie umysłu z wewnętrznego działania JavaScript i zrozumienie różnic w znaczeniu między:

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 ostatnie dwa przypadki za pomocą dwóch różnych wartości nulloraz undefined. Możesz swobodnie wykorzystywać te wartości, aby przekazać te znaczenia.

Więc jakie są niektóre problemy specyficzne dla JavaScript, które powstają z powodu tej filozoficznej podstawy?

1. Zadeklarowana zmienna bez inicjatora otrzymuje wartość, undefinedponieważ nigdy nie mówiłeś nic o tym, jaka była zamierzona wartość.

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

2. Ocenia się właściwość obiektu, który nigdy nie został ustawiony, undefinedponieważ nikt nigdy nie powiedział nic o tej właściwości.

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

3. nulli undefinedsą do siebie „podobni”, ponieważ tak powiedziała Brendan Eich. Ale zdecydowanie nie są sobie równi.

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

4. nulli na undefinedszczęście mają różne typy. nullnależy do typu Nulli undefineddo typu Undefined. To jest specyfikacja, ale nigdy nie dowiesz się tego z powodu typeofdziwności, której nie powtórzę tutaj.

5. Funkcja osiągająca koniec swojego ciała bez wyraźnej instrukcji return zwraca, undefinedponieważ nic nie wiesz o tym, co zwróciła.

Nawiasem mówiąc, istnieją inne formy „nicości” w JavaScript (dobrze jest studiować filozofię ....)

• NaN
• Korzystanie ze zmiennej, która nigdy nie została zadeklarowana, i odbieranie ReferenceError
• Użycie letlub constzdefiniowanej zmiennej lokalnej w jej czasowej martwej strefie i otrzymanie aReferenceError

• Puste komórki w rzadkich tablicach. Tak, nie są one nawet undefinedporównywalne ===z niezdefiniowanymi.

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

W języku JavaScript istnieje 5 prymitywnych typów danych: String, Number, Boolean, null i undefined. Spróbuję wyjaśnić na prostym przykładzie

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, jeśli (a == null) jest taki sam jak if (! a)

teraz, gdy wywołujemy tę funkcję bez podania 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); 

da to niezdefiniowane; zadeklarowaliśmy zmienną, ale nie przypisaliśmy żadnej wartości do tej zmiennej; ale jeśli napiszemy

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

więc null jest obiektem. w sposób, w jaki przypisaliśmy wartość null do „a”

Dla undefinedtypu, istnieje jedna i tylko jedna wartość: undefined.

Dla nulltypu, istnieje jedna i tylko jedna wartość: null.

Tak więc dla obu z nich etykieta jest zarówno rodzajem, jak i wartością.

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

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

Lub:

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

W rzeczywistości nulljest to specjalne słowo kluczowe , a nie identyfikator, dlatego nie można traktować go jako zmiennej do przypisania.

Jednak undefinedjest identyfikator . Jednak zarówno w non-stricttrybie, jak i stricttrybie można utworzyć lokalną zmienną o nieokreślonej nazwie. Ale to 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 wartość undefined. Oznacza to, że zmienna jest nietknięta i można jej przypisać dowolną wartość w przyszłości. Oznacza to również, że nie znasz wartości, którą ta zmienna będzie przechowywać w momencie deklaracji.

Teraz możesz jawnie przypisać zmienną null. Oznacza to, że zmienna nie ma żadnej wartości. Na przykład - niektóre osoby nie mają drugiego imienia. W takim przypadku lepiej jest przypisać wartość null do zmiennej środkowej nazwy obiektu osoby.

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

zarówno null, jak i undefined są używane do reprezentowania braku pewnej wartości.

var a = null;

a jest inicjowany i definiowany.

typeof(a)
//object

null to obiekt w JavaScript

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

var b;

b jest niezdefiniowany i niezainicjowany

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

Zasadniczo przypisujemy null zmiennym niezdefiniowanym.

Dokładny artykuł Per Ryana Morra na ten temat ...

„Ogólnie rzecz biorąc, jeśli musisz przypisać wartość inną do zmiennej lub właściwości, przekazać ją do funkcji lub zwrócić z funkcji, null jest prawie zawsze najlepszą opcją. Mówiąc prosto, JavaScript używa niezdefiniowanej i programiści powinni użyj null. ”

Zobacz Eksplorowanie wiecznej otchłani zerowej i niezdefiniowanej

Zarówno Null, jak i niezdefiniowane w JavaScript wskazują brak wartości.

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

Pomimo faktu, że oba istnieją z powodu braku wartości, ale: Niezdefiniowane w rzeczywistości oznacza, że ​​zmienna nie jest inicjowana. Funkcje, które nic nie zwracają, i parametry funkcji, dla których nie podano żadnej wartości, zwracana jest niezdefiniowana wartość. Użyj operatora ścisłej równości ===, aby odróżnić wartość null od niezdefiniowanej.

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

OK, możemy się mylić, gdy słyszymy o null, a undefined, ale zacznijmy to proste, oboje są falsy i podobne pod wieloma względami, ale dziwne część JavaScript, uczynić je kilka istotnych różnic, na przykład, typeof null jest 'object'natomiast typeof undefined jest 'undefined'.

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

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

null==undefined; //true

Możesz także przypisać nullwłaściwość obiektu lub element pierwotny, a undefinedpo prostu można to osiągnąć, nie przypisując niczego.

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

Ponieważ typeof zwraca undefined, undefined jest typem, w którym null jest inicjatorem, który wskazuje, że zmienna wskazuje na żaden obiekt (praktycznie wszystko w Javascript jest obiektem).

W javascript wszystkie zmienne są przechowywane jako pary klucz-wartość. Każda zmienna jest przechowywana jako nazwa zmiennej: wartość_zmiennej / referencja .

undefined oznacza, że ​​zmienna otrzymała miejsce w pamięci, ale nie przypisano jej żadnej wartości. Jako najlepszą praktykę nie należy używać tego typu jako zadania.

W takim przypadku, jak określić, kiedy zmienna ma być bez wartości w późniejszym punkcie kodu? Możesz użyć typu null , który jest także typem używanym do zdefiniowania tej samej rzeczy, braku wartości, ale nie jest to to samo, co niezdefiniowane, ponieważ w tym przypadku faktycznie masz wartość w pamięci. Ta wartość jest zerowa

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

Chcę dodać bardzo subtelną różnicę pomiędzy nulli undefinedktóry jest dobry, aby wiedzieć, kiedy próbuje się nauczyć Vanilla JavaScript (JS) od podstaw:

• nulljest zarezerwowanym słowem kluczowym w JS, podczas gdy undefinedjest zmienną globalnego obiektu środowiska wykonawczego, w którym się znajdujesz.

Podczas pisania kodu tej różnicy nie można zidentyfikować jako obu nulli undefinedzawsze są one używane w RHS instrukcji JavaScript. Ale kiedy używasz ich w LHS wyrażenia, możesz łatwo zauważyć tę różnicę. Dlatego interpreter JS interpretuje poniższy kod jako błąd:

var null = 'foo'

Daje poniżej błędu:

Uncaught SyntaxError: Nieoczekiwany token null

Chociaż poniższy kod działa poprawnie, chociaż nie polecam tego robić w prawdziwym życiu:

var undefined = 'bar'

Działa undefinedto, ponieważ jest zmienną obiektu globalnego (obiekt okna przeglądarki w przypadku JS po stronie klienta)

Różnica między undefinedi nulljest minimalna, ale jest różnica. Zmienna, której wartość undefinednigdy nie została zainicjowana. Zmienna, której wartość nullzostała jawnie podana wartość null, co oznacza, że ​​zmienna została jawnie ustawiona na brak wartości. Jeśli porównasz undefinedi nullużywając null==undefinedwyrażenia, będą one równe.

Zasadniczo Undefined jest zmienną globalną, którą javascript tworzy w czasie wykonywania, niezależnie od tego, czy null oznacza, że ​​żadna wartość nie została przypisana do zmiennej (w rzeczywistości sam null jest 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

Niezdefiniowane , to otrzymasz jako wynik.

Teraz,

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

a otrzymasz 5 jako wynik. To główna różnica między niezdefiniowanym a zerowym

null - Jest to wartość przypisania, która jest używana ze zmienną do reprezentowania żadnej wartości (jest to obiekt).

undefined - jest to zmienna, która nie ma przypisanej żadnej wartości, więc JavaScript przypisze jej niezdefiniowaną wartość (jest to typ danych).

niezadeklarowana - jeśli zmienna w ogóle nie zostanie utworzona, jest znana jako niezadeklarowana.

Spójrz na to. Wynik jest wart tysiąca słów.

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

Zobacz też:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

Twoje zdrowie!

Obie wartości specjalne oznaczają stan pusty.

Główną różnicą jest to, że niezdefiniowana reprezentuje wartość zmiennej, która nie została jeszcze zainicjowana, a null oznacza celową nieobecność obiektu.

Numer zmiennej jest zdefiniowany, jednak nie ma przypisanej wartości początkowej:

let number;
number; // => undefined

zmienna liczbowa jest niezdefiniowana, co wyraźnie wskazuje na niezainicjowaną zmienną

Ta sama niezainicjowana koncepcja ma miejsce, gdy uzyskuje się dostęp do nieistniejącej właściwości obiektu:

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

Ponieważ właściwość lastName nie istnieje w obj, JavaScript poprawnie ocenia obj.lastName na niezdefiniowany.

W innych przypadkach wiadomo, że zmienna oczekuje, że zatrzyma obiekt lub funkcję, aby zwrócić obiekt. Ale z jakiegoś powodu nie można utworzyć instancji obiektu. W takim przypadku wartość null jest znaczącym wskaźnikiem brakującego obiektu.

Na przykład clone () to funkcja, która klonuje zwykły obiekt JavaScript. Oczekuje się, że funkcja zwróci obiekt:

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

Jednak funkcja clone () może zostać wywołana z argumentem nieobiektywnym: 15 lub null (lub ogólnie prymitywną wartością, null lub undefined). W takim przypadku funkcja nie może utworzyć klonu, więc zwraca null - wskaźnik brakującego obiektu.

operator typeof rozróżnia dwie wartości:

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

Operator ścisłej jakości === poprawnie odróżnia niezdefiniowane od null:

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

Oprócz innego znaczenia istnieją inne różnice:

1. Niszczenie obiektów działa inaczej dla tych dwóch wartości:

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null

2. JSON.stringify () zachowuje, nullale pomijaundefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}

3. operator typeof

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"

Jeśli zmienna nie zostanie zainicjowana, wówczas jest niezdefiniowana. niezdefiniowany nie jest przedmiotem. Przykład: var MyName; console.log (typeof MyName);

Sprawdź narzędzie do programowania logowania do konsoli, zostanie wydrukowane jako niezdefiniowane.

null jest obiektem. Jeśli chcesz, aby jakaś zmienna była null, wówczas używana jest null. zmienna null istnieje, ale wartość nie jest znana. Powinna być przypisana do zmiennej programowo. wartość null nie jest automatycznie inicjowana.

Przykład: var MyName = null; console.log (typeof MyName); Sprawdź dziennik csole w narzędziu programistycznym, będzie to obiekt.