Was ist der Unterschied zwischen null und undefiniert in JavaScript?

Ich möchte wissen, was der Unterschied zwischen nullund undefinedin JavaScript ist.

In JavaScript undefinedbedeutet dies , dass eine Variable deklariert wurde, aber noch kein Wert zugewiesen wurde, z.

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

nullist ein Zuweisungswert. Es kann einer Variablen als Darstellung ohne Wert zugewiesen werden:

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

Aus den vorstehenden Beispielen ist es klar , dass undefinedund nullzwei verschiedene Typen: undefinedein Typ selbst (nicht definiert) , während nullein Objekt ist.

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

und

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

Ich habe das hier ausgewählt

Der undefinierte Wert ist ein primitiver Wert, der verwendet wird, wenn einer Variablen kein Wert zugewiesen wurde.

Der Nullwert ist ein primitiver Wert, der die Null-, leere oder nicht vorhandene Referenz darstellt.

Wenn Sie eine Variable über var deklarieren und ihr keinen Wert geben, ist der Wert undefiniert. Wenn Sie versuchen, diesen Wert für WScript.Echo () oder alert () zu verwenden, wird an sich nichts angezeigt. Wenn Sie jedoch eine leere Zeichenfolge anhängen, wird plötzlich Folgendes angezeigt:

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

Sie können eine Variable deklarieren, auf null setzen und das Verhalten ist identisch, außer dass "null" im Vergleich zu "undefiniert" ausgedruckt wird. Dies ist in der Tat ein kleiner Unterschied.

Sie können sogar eine undefinierte Variable mit null vergleichen oder umgekehrt, und die Bedingung ist wahr:

undefined == null
null == undefined

Es werden jedoch zwei verschiedene Typen betrachtet. Während undefined ein eigenständiger Typ ist, wird null als spezieller Objektwert betrachtet. Sie können dies sehen, indem Sie typeof () verwenden, das eine Zeichenfolge zurückgibt, die den allgemeinen Typ einer Variablen darstellt:

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

Das Ausführen des obigen Skripts führt zu der folgenden Ausgabe:

undefined
object

Unabhängig davon, ob es sich um unterschiedliche Typen handelt, verhalten sie sich immer noch gleich, wenn Sie versuchen, auf ein Mitglied eines der beiden zuzugreifen, z. B., dass sie eine Ausnahme auslösen. Mit WSH werden Sie sehen, dass der gefürchtete "'varname' ist null oder kein Objekt" und das ist, wenn Sie Glück haben (aber das ist ein Thema für einen anderen Artikel).

Sie können eine Variable explizit als undefiniert festlegen, aber ich rate dringend davon ab. Ich empfehle, nur Variablen auf null zu setzen und den Wert für Dinge, die Sie vergessen haben, undefiniert zu lassen. Gleichzeitig ermutige ich Sie wirklich, immer jede Variable festzulegen. JavaScript hat eine andere Bereichskette als die Sprachen im C-Stil, die selbst erfahrene Programmierer leicht verwirrt. Das Setzen von Variablen auf Null ist der beste Weg, um darauf basierende Fehler zu vermeiden.

Eine andere Instanz, in der ein undefiniertes Popup angezeigt wird, ist die Verwendung des Löschoperators. Diejenigen von uns aus einer C-Welt könnten dies fälschlicherweise als Zerstörung eines Objekts interpretieren, aber es ist nicht so. Mit dieser Operation wird ein Index aus einem Array oder ein Mitglied aus einem Objekt entfernt. Bei Arrays wirkt sich dies nicht auf die Länge aus, sondern darauf, dass der Index jetzt als undefiniert betrachtet wird.

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

Das Ergebnis des obigen Skripts ist:

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

Sie erhalten auch eine undefinierte Rückgabe, wenn Sie einen Index oder ein Mitglied lesen, das noch nie existiert hat.

Der Unterschied zwischen null und undefiniert ist: JavaScript setzt niemals etwas auf null, das ist normalerweise das, was wir tun. Während wir Variablen auf undefiniert setzen können, bevorzugen wir null, da dies nie für uns getan wird. Wenn Sie debuggen, bedeutet dies, dass alles, was auf null gesetzt ist, von Ihnen selbst und nicht von JavaScript ausgeführt wird. Darüber hinaus sind diese beiden Sonderwerte nahezu gleichwertig.

(Hinzufügen von Zeichen aufgrund fehlender Zeichen, daher darf ich dies posten.)

null ist ein spezielles Schlüsselwort, das auf das Fehlen eines Werts hinweist.

Betrachten Sie es als einen Wert, wie:

• "foo" ist string,
• wahr ist boolesch,
• 1234 ist Nummer,
• null ist undefiniert.

Eine undefinierte Eigenschaft gibt an, dass einer Variablen kein Wert einschließlich Null zugewiesen wurde. Mögen

var foo;

Die definierte leere Variable ist nullvom Datentypundefined

Beide repräsentieren einen Wert einer Variablen ohne Wert

AND null stellt keine Zeichenfolge dar , die keinen Wert hat - leere Zeichenfolge-

Mögen

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

Nun wenn

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

ABER

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

SO hat jeder seine eigene Art zu benutzen

undefined Verwenden Sie diese Option, um den variablen Datentyp zu vergleichen

null Verwenden Sie diese Option, um einen Wert einer Variablen zu leeren

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

null : fehlender Wert für eine Variable; undefiniert : Fehlen der Variablen selbst;

..where Variable ist ein symbolischer Name, der einem Wert zugeordnet ist.

JS könnte so freundlich sein, neu deklarierte Variablen implizit mit null zu initiieren , tut dies jedoch nicht.

Bitte lesen Sie Folgendes sorgfältig durch. Es wird alle Ihre Zweifel bezüglich des Unterschieds zwischen null und undefiniert in JavaScript beseitigen . Sie können auch die unten angegebene Dienstprogrammfunktion verwenden, um die Typen genau zu bestimmen.

In JavaScript können wir folgende Arten von Variablen haben.

1. Nicht deklarierte Variablen
2. Deklarierte, aber nicht zugewiesene Variablen
3. Mit undefiniertem Literal zugewiesene Variablen
4. Mit Literal null zugewiesene Variablen
5. Variablen, denen etwas anderes als undefiniert oder null zugewiesen wurde

Im Folgenden wird jeder dieser Fälle einzeln erläutert

1. Nicht deklarierte Variablen : Das Folgende gilt für nicht deklarierte Variablen

   • Kann nur von typeof () überprüft werden, das die Zeichenfolge 'undefined' zurückgibt.
   • Kann nicht mit == oder === oder von if oder bedingtem Operator überprüft werden ? (wirft Referenzfehler)

2. Deklarierte, aber nicht zugewiesene Variablen

   • typeof gibt die Zeichenfolge 'undefined' zurück
   • == check with null gibt true zurück
   • == check with undefined gibt true zurück
   • === check with null gibt false zurück
   • === check with undefined gibt true zurück
   • ob oder bedingter Operator ? gibt false zurück

3. Mit undefiniertem Literal zugewiesene Variablen : Diese Variablen werden ähnlich wie die deklarierten, aber nicht zugewiesenen Variablen behandelt .

4. Mit Literal null zugewiesene Variablen

   • typeof gibt die Zeichenfolge 'object' zurück
   • == check with null gibt true zurück
   • == check with undefined gibt true zurück
   • === check with null gibt true zurück
   • === check with undefined gibt false zurück
   • ob oder bedingter Operator ? gibt false zurück

5. Variablen, denen etwas anderes als undefiniert oder null zugewiesen wurde

   • typeof gibt eine der folgenden Zeichenfolgen zurück: 'string' , 'number' , 'boolean' , 'function' , 'object' , 'symbol'

Im Folgenden finden Sie den Algorithmus für die korrekte Typprüfung einer Variablen:

1. Überprüfen Sie mit typeof , ob nicht deklariert / nicht zugewiesen / mit undefiniert zugewiesen wurde . Rückgabe, wenn die Zeichenfolge 'undefined' zurückgegeben wird.
2. Überprüfen Sie mit === auf Null . Geben Sie 'null' zurück, wenn true .
3. Überprüfen Sie den tatsächlichen Typ mit typeof . Rückgabetyp, wenn nicht gleich 'Objekt'
4. Rufen Sie Object.prototype.toString.call (o) auf, um den tatsächlichen Objekttyp zu bestimmen. Es wird eine Zeichenfolge vom Typ '[object ObjectType]' für alle in Javascript oder DOM definierten Objekte zurückgegeben. Für benutzerdefinierte Objekte wird '[Objekt Objekt]' zurückgegeben.

Sie können auch die folgende Dienstprogrammfunktion zum Bestimmen von Typen verwenden. Derzeit werden alle ECMA 262 2017-Typen unterstützt.

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 
}

Sie können undefiniert als Darstellung eines unerwarteten oder fehlerhaften Fehlens eines Werts auf Systemebene und null als Darstellung eines normalen oder erwarteten Fehlens eines Werts auf Programmebene betrachten.

via JavaScript: Der endgültige Leitfaden

Ich werde erklären undefined, nullund Uncaught ReferenceError:

1 - Uncaught ReferenceError: Variable wurde in Ihrem Skript nicht deklariert , es gibt keinen Verweis auf diese Variable.
2 - undefined: Variable deklariert, aber nicht initialisiert.
3 - null: Variable deklariert und ist ein leerer Wert

Undefiniert bedeutet, dass eine Variable deklariert wurde, aber keinen Wert hat:

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

Null ist eine Aufgabe:

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

null und undefiniert sind zwei unterschiedliche Objekttypen, die Folgendes gemeinsam haben:

• beide können nur einen einzigen Wert enthalten, null bzw. undefiniert ;
• Beide haben keine Eigenschaften oder Methoden, und der Versuch, Eigenschaften von beiden zu lesen, führt zu einem Laufzeitfehler (für alle anderen Objekte erhalten Sie einen undefinierten Wert, wenn Sie versuchen, eine nicht vorhandene Eigenschaft zu lesen).
• Werte null und undefiniert werden von ==und !=Operatoren als gleich und zu nichts anderem betrachtet .

Die Ähnlichkeiten enden jedoch hier. Ausnahmsweise gibt es einen grundlegenden Unterschied in der Art und Weise, wie Schlüsselwörter null und undefiniert implementiert werden. Dies ist nicht offensichtlich, aber betrachten Sie das folgende Beispiel:

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

undefined , NaN und Infinity sind nur Namen von vorinitialisierten "superglobalen" Variablen - sie werden zur Laufzeit initialisiert und können von normalen globalen oder lokalen Variablen mit denselben Namen überschrieben werden.

Versuchen wir jetzt dasselbe mit null :

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

Hoppla! null , true und false sind reservierte Schlüsselwörter. Der Compiler lässt Sie nicht als Variablen- oder Eigenschaftsnamen verwenden

Ein weiterer Unterschied ist der undefined ein primitiver Typ ist, während null ein Objekttyp ist (was auf das Fehlen einer Objektreferenz hinweist). Folgendes berücksichtigen:

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

Es gibt auch einen wichtigen Unterschied in der Art und Weise und null und undefiniert im numerischen Kontext behandelt werden:

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 wird 0 wenn es in arithmetischen Ausdrücken oder numerischen Vergleichen verwendet wird - ähnlich wie false ist es im Grunde nur eine spezielle Art von "Null". undefined hingegen ist ein wahres "Nichts" und wird zu NaN ("keine Zahl"), wenn Sie versuchen, es im numerischen Kontext zu verwenden.

Beachten Sie, dass null und undefiniert eine Sonderbehandlung von ==und !=Operatoren erhalten, Sie jedoch die wahre numerische Gleichheit von a und b mit dem Ausdruck testen können(a >= b && a <= b) .

tl; dr

Verwenden nullSie diese Option, um eine Variable festzulegen, von der Sie wissen, dass es sich um ein Objekt handelt.

Verwenden Sie diese Option, undefinedum eine Variable festzulegen, deren Typ gemischt ist.

Dies ist meine Verwendung von 5 Grundelementen und Objekttyp, und das erklärt den Unterschied zwischen «Anwendungsfall» von undefinedoder null.

String

Wenn Sie wissen, dass eine Variable während des gesamten Lebenszyklus nur eine Zeichenfolge ist, können Sie sie gemäß Konvention wie folgt initialisieren "":

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

Nummer

Wenn Sie wissen, dass eine Variable während des gesamten Lebenszyklus nur eine Zahl ist, können Sie sie gemäß Konvention initialisieren, um 0(oder NaNwenn dies 0ein wichtiger Wert in Ihrer Verwendung ist):

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

oder

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

Boolescher Wert

Wenn Sie wissen, dass eine Variable während des gesamten Lebenszyklus nur ein Boolescher Wert ist, können Sie sie gemäß Konvention wie folgt initialisieren false:

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

Objekt

Wenn Sie wissen, dass eine Variable während des gesamten Lebenszyklus nur ein Objekt ist, können Sie sie gemäß Konvention wie folgt initialisieren null:

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

Hinweis: Die intelligente Verwendung von null soll die falsche Version eines Objekts sein, da ein Objekt immer trueist und weil typeof nullreturn object. Dies bedeutet typeof myVarObject, dass sowohl für den Objekt- als auch für den Nulltyp ein konsistenter Wert zurückgegeben wird.

Alle

Wenn Sie wissen, dass eine Variable einen gemischten Typ hat (einen beliebigen Typ während des gesamten Lebenszyklus), können Sie ihn gemäß Konvention auf initialisieren undefined.

nullist ein spezieller Wert, der "kein Wert" bedeutet. nullist ein spezielles Objekt, da typeof null'Objekt' zurückgegeben wird.

Andererseits undefinedbedeutet dies, dass die Variable nicht deklariert wurde oder keinen Wert erhalten hat.

Der beste Weg, um den Unterschied zu verstehen, besteht darin, sich zunächst über das Innenleben von JavaScript zu informieren und nur die Bedeutungsunterschiede zu verstehen zwischen:

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.

Es gibt einen Unterschied in der Bedeutung zwischen diesen drei Fällen, und JavaScript unterscheidet die beiden letztgenannten Fälle mit zwei unterschiedlichen Werten nullund undefined. Es steht Ihnen frei, diese Werte explizit zu verwenden, um diese Bedeutungen zu vermitteln.

Was sind also einige der JavaScript-spezifischen Probleme, die aufgrund dieser philosophischen Grundlage auftreten?

1. Eine deklarierte Variable ohne Initialisierer erhält den Wert, undefinedweil Sie nie etwas über den beabsichtigten Wert gesagt haben.

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

2. Eine Eigenschaft eines Objekts, die noch nie festgelegt wurde, wird ausgewertet, undefinedda niemand jemals etwas über diese Eigenschaft gesagt hat.

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

3. nullund undefinedsind einander "ähnlich", weil Brendan Eich es gesagt hat. Aber sie sind einander nachdrücklich nicht gleich.

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

4. nullund zum undefinedGlück haben verschiedene Arten.nullgehört zum Typ Nullund undefinedzum Typ Undefined. Dies ist in der Spezifikation, aber Sie würden dies nie wegen der typeofVerrücktheit wissen, die ich hier nicht wiederholen werde.

5. Eine Funktion, die ohne explizite return-Anweisung das Ende ihres Körpers erreicht, wird zurückgegeben, undefinedda Sie nichts darüber wissen, was sie zurückgegeben hat.

Übrigens gibt es in JavaScript andere Formen des "Nichts" (es ist gut, Philosophie studiert zu haben ...)

• NaN
• Verwenden einer nie deklarierten Variablen und Empfangen einer ReferenceError
• Verwendung einer let oder einer constdefinierten lokalen Variablen in ihrer zeitlichen Totzone und Empfangen von aReferenceError

• Leere Zellen in spärlichen Arrays. Ja, das sind nicht einmal, undefinedobwohl sie ===mit undefiniert verglichen werden .

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

In JavasSript gibt es 5 primitive Datentypen: String, Number, Boolean, null und undefined. Ich werde versuchen, dies anhand eines einfachen Beispiels zu erklären

Nehmen wir an, wir haben eine einfache Funktion

 function test(a) {

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

auch in der obigen Funktion, wenn (a == null) dasselbe ist wie wenn (! a)

Jetzt, wenn wir diese Funktion aufrufen, ohne den Parameter a zu übergeben

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

ebenfalls

var a;
alert(typeof a); 

dies wird undefiniert geben; Wir haben eine Variable deklariert, dieser Variablen jedoch keinen Wert zugewiesen. aber wenn wir schreiben

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

also ist null ein Objekt. In gewisser Weise haben wir 'a' den Wert null zugewiesen.

Für den undefinedTyp gibt es nur einen Wert : undefined.

Für den nullTyp gibt es nur einen Wert : null.

Für beide ist das Etikett sowohl der Typ als auch der Wert.

Der Unterschied zwischen ihnen. Zum Beispiel:

• null ist ein leerer Wert
• undefined ist ein fehlender Wert

Oder:

• undefined hat noch keinen Wert gehabt
• null hatte einen Wert und tut es nicht mehr

Eigentlich nullist ein spezielles Schlüsselwort , nicht um einen Bezeichner. Daher können Sie es nicht als Variable behandeln, der Sie zuweisen möchten.

Ist undefinedjedoch eine Kennung . Sowohl im non-strictModus als auch im strictModus können Sie jedoch eine lokale Variable mit dem Namen undefined erstellen. Aber das ist eine schreckliche Idee!

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

foo();

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

foo();

Wenn Sie eine Variable in Javascript deklarieren, wird ihr der Wert zugewiesen undefined. Dies bedeutet, dass die Variable unberührt bleibt und zukünftig einem beliebigen Wert zugewiesen werden kann. Dies bedeutet auch, dass Sie den Wert, den diese Variable zum Zeitpunkt der Deklaration enthalten wird, nicht kennen.

Jetzt können Sie explizit eine Variable zuweisen null . Dies bedeutet, dass die Variable keinen Wert hat. Zum Beispiel - Einige Leute haben keinen zweiten Vornamen. In einem solchen Fall ist es daher besser, der mittleren Namensvariablen eines Personenobjekts den Wert null zuzuweisen.

Angenommen, jemand greift auf die Mittelnamenvariable Ihres Personenobjekts zu und sie hat den Wert undefined. Er würde nicht wissen, ob der Entwickler vergessen hat, diese Variable zu initialisieren, oder ob sie keinen Wert hatte. Wenn es den Wert hat null, kann der Benutzer leicht schließen, dass der mittlere Name keinen Wert hat und keine unberührte Variable ist.

null und undefiniert werden beide verwendet, um das Fehlen eines Wertes darzustellen.

var a = null;

a wird initialisiert und definiert.

typeof(a)
//object

null ist ein Objekt in JavaScript

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

var b;

b ist undefiniert und nicht initialisiert

undefinierte Objekteigenschaften sind ebenfalls undefiniert. Zum Beispiel ist "x" für Objekt c nicht definiert. Wenn Sie versuchen, auf cx zuzugreifen, wird undefiniert zurückgegeben.

Im Allgemeinen weisen wir Variablen, die nicht undefiniert sind, null zu.

Per Ryan Morrs ausführlicher Artikel zu diesem Thema ...

"Wenn Sie einer Variablen oder Eigenschaft einen Nichtwert zuweisen, ihn an eine Funktion übergeben oder von einer Funktion zurückgeben müssen, ist null im Allgemeinen fast immer die beste Option. Einfach ausgedrückt verwendet JavaScript undefiniert und Programmierer sollten dies tun." benutze null. "

Siehe Erkundung des ewigen Abgrunds von Null und Undefiniert

Sowohl Null als auch undefiniert in JavaScript zeigen an, dass kein Wert vorhanden ist.

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

Trotz der Tatsache, dass beide für das Fehlen von Wert existieren, aber: Undefiniert bedeutet tatsächlich, dass die Variable nicht initialisiert wird. Funktionen, die nichts zurückgeben, und Funktionsparameter, für die kein Wert angegeben wird, undefinierter Wert werden zurückgegeben. Verwenden Sie den strengen Gleichheitsoperator ===, um zwischen null und undefiniert zu unterscheiden.

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

OK, so können wir verwirrt, wenn wir hören , nullund undefined, aber wir beginnen , es einfach, sie sind beide falsy und in vielerlei Hinsicht ähnlich, aber seltsame Teil JavaScript, sie machen ein paar wesentliche Unterschiede zum Beispiel typeof null ist 'object'während typeof undefined ist 'undefined'.

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

Wenn Sie ==sie jedoch wie folgt überprüfen , sehen Sie, dass beide falsch sind :

null==undefined; //true

Sie können auch nulleine Objekteigenschaft oder ein Grundelement zuweisen , währendundefined dies einfach erreicht werden kann, indem Sie nichts zuweisen.

Ich erstelle ein schnelles Bild, um Ihnen die Unterschiede auf einen Blick zu zeigen.

Da typeof undefined zurückgibt, ist undefined ein Typ, bei dem null als Initialisierer angibt, dass die Variablen auf kein Objekt verweisen (praktisch alles in Javascript ist ein Objekt).

In Javascript werden alle Variablen als Schlüsselwertpaare gespeichert. Jede Variable wird als Variablenname gespeichert : Variablenwert / Referenz .

nicht definiert bedeutet, dass einer Variablen ein Leerzeichen im Speicher zugewiesen wurde, ihr jedoch kein Wert zugewiesen wurde. Als bewährte Methode sollten Sie diesen Typ nicht als Zuweisung verwenden.

Wie kann in diesem Fall angegeben werden, wann eine Variable zu einem späteren Zeitpunkt im Code wertlos sein soll? Sie können den Typ null verwenden , bei dem es sich auch um einen Typ handelt, mit dem dasselbe definiert wird, wenn kein Wert vorhanden ist, der jedoch nicht mit undefiniert identisch ist, da Sie in diesem Fall den Wert tatsächlich im Speicher haben. Dieser Wert ist null

Beide sind ähnlich, aber Verwendung und Bedeutung sind unterschiedlich.

Ich möchte einen sehr subtilen Unterschied zwischen nullund hinzufügen, undefinedder gut zu wissen ist, wenn Sie versuchen, Vanilla JavaScript (JS) von Grund auf zu lernen:

• nullist ein reserviertes Schlüsselwort in JS, während undefinedes sich um eine Variable für das globale Objekt der Laufzeitumgebung handelt, in der Sie sich befinden.

Beim Schreiben von Code ist dieser Unterschied nicht als beides erkennbar nullund undefinedwird immer in RHS einer JavaScript-Anweisung verwendet. Wenn Sie sie jedoch in LHS eines Ausdrucks verwenden, können Sie diesen Unterschied leicht beobachten. Der JS-Interpreter interpretiert den folgenden Code als Fehler:

var null = 'foo'

Es gibt unten Fehler:

Nicht erfasster SyntaxError: Unerwartetes Token null

Während der folgende Code erfolgreich ausgeführt wird, obwohl ich dies im wirklichen Leben nicht empfehlen werde:

var undefined = 'bar'

Dies funktioniert, weil undefinedes sich um eine Variable für das globale Objekt handelt (Browserfensterobjekt bei clientseitigem JS).

Der Unterschied zwischen undefinedund nullist minimal, aber es gibt einen Unterschied. Eine Variable mit dem Wert undefinedwurde nie initialisiert. Eine Variable, deren Wert nullexplizit angegeben ist, hat den Wert von null. Dies bedeutet, dass die Variable explizit so festgelegt wurde, dass sie keinen Wert hat. Wenn Sie vergleichen undefinedund nullden null==undefinedAusdruck verwenden, sind sie gleich.

Grundsätzlich ist Undefined eine globale Variable, die Javascript zur Laufzeit erstellt, unabhängig davon, ob der Variablen null zugewiesen wurde (tatsächlich ist null selbst ein Objekt).

Nehmen wir ein Beispiel:

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

Undefiniert erhalten Sie diese Ausgabe.

Jetzt,

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

und Sie erhalten 5 als Ausgabe. Das ist der Hauptunterschied zwischen Undefiniert und Null

null - Dies ist ein Zuweisungswert, der mit einer Variablen verwendet wird, um keinen Wert darzustellen (es ist ein Objekt).

undefiniert - Dies ist eine Variable, der kein Wert zugewiesen ist, daher weist JavaScript ihr einen undefinierten Wert zu (es ist ein Datentyp).

nicht deklariert - Wenn eine Variable überhaupt nicht erstellt wird, wird sie als nicht deklariert bezeichnet.

Überprüfen Sie dies heraus. Die Ausgabe sagt mehr als tausend Worte.

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>

Siehe auch:

• 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

Prost!

Beide Sonderwerte implizieren einen leeren Zustand.

Der Hauptunterschied besteht darin, dass undefined den Wert einer Variablen darstellt, die noch nicht initialisiert wurde, während null das absichtliche Fehlen eines Objekts darstellt.

Die Variablennummer ist definiert, jedoch nicht mit einem Anfangswert versehen:

let number;
number; // => undefined

Die Zahlenvariable ist undefiniert, was eindeutig auf eine nicht initialisierte Variable hinweist

Das gleiche nicht initialisierte Konzept tritt auf, wenn auf eine nicht vorhandene Objekteigenschaft zugegriffen wird:

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

Da die Eigenschaft lastName in obj nicht vorhanden ist, wertet JavaScript obj.lastName korrekt als undefiniert aus.

In anderen Fällen wissen Sie, dass eine Variable erwartet, ein Objekt oder eine Funktion zu halten, um ein Objekt zurückzugeben. Aus irgendeinem Grund können Sie das Objekt jedoch nicht instanziieren. In einem solchen Fall ist null ein aussagekräftiger Indikator für ein fehlendes Objekt.

Zum Beispiel ist clone () eine Funktion, die ein einfaches JavaScript-Objekt klont. Es wird erwartet, dass die Funktion ein Objekt zurückgibt:

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

Clone () kann jedoch mit einem Nicht-Objekt-Argument aufgerufen werden: 15 oder null (oder im Allgemeinen einem primitiven Wert, null oder undefiniert). In diesem Fall kann die Funktion keinen Klon erstellen und gibt daher null zurück - den Indikator für ein fehlendes Objekt.

Der Typ des Operators unterscheidet zwischen den beiden Werten:

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

Der strenge Qualitätsoperator === unterscheidet undefiniert korrekt von null:

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

Neben einer anderen Bedeutung gibt es noch andere Unterschiede:

1. Die Objektzerstörung funktioniert für diese beiden Werte unterschiedlich:

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

2. JSON.stringify () behält nullaber beiundefined

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

3. Art des Bedieners

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

Wenn eine Variable nicht initialisiert ist, ist sie undefiniert. undefined ist kein Objekt. Beispiel: var MyName; console.log (Typ von MyName);

Überprüfen Sie das Entwicklungstool für die Konsolenanmeldung. Es wird als undefiniert gedruckt.

null ist ein Objekt. Wenn eine Variable null sein soll, wird null verwendet. Es gibt keine Variable, aber der Wert ist nicht bekannt. Sie sollte einer Variablen programmatisch zugewiesen werden. null wird nicht automatisch initialisiert.

Beispiel: var MyName = null; console.log (Typ von MyName); Überprüfen Sie das csole-Protokoll im Entwicklungstool, es wird ein Objekt sein.