Warum ist null ein Objekt und was ist der Unterschied zwischen null und undefiniert?

Warum ist nullein als objectin JavaScript?

Überprüft

if ( object == null )
      Do something

das Gleiche wie

if ( !object )
      Do something

?

Und auch:

Was ist der Unterschied zwischen nullund undefined?

(name is undefined)

Sie: Was ist name? ^(*)
JavaScript : name ? Was ist ein name? Ich weiß nicht, wovon du sprichst. Sie haben noch nie zuvor erwähnt name. Sehen Sie eine andere Skriptsprache auf der (Client-) Seite?

name = null;

Sie: Was ist name?
JavaScript: Ich weiß es nicht.

Zusamenfassend; undefinedist dort, wo keine Vorstellung von der Sache existiert; Es hat keinen Typ und wurde in diesem Bereich noch nie referenziert. nullHier ist bekannt, dass das Ding existiert, aber es ist nicht bekannt, was der Wert ist.

Eine Sache, an die man sich erinnern sollte, nullist, dass sie konzeptionell nicht mit der einen falseoder anderen identisch ist "", selbst wenn sie nach dem Typgießen gleichgesetzt werden , d. H.

name = false;

Sie: Was ist name?
JavaScript: Boolean false.

name = '';

Sie: Was ist name?
JavaScript: Leere Zeichenfolge

^{*: nameIn diesem Zusammenhang ist eine Variable gemeint, die nie definiert wurde. Es kann sich um eine beliebige undefinierte Variable handeln. Der Name ist jedoch eine Eigenschaft nahezu aller HTML-Formularelemente. Es geht weit zurück und wurde lange vor id eingeführt. Dies ist nützlich, da IDs eindeutig sein müssen, Namen jedoch nicht.}

Der Unterschied kann in diesem Ausschnitt zusammengefasst werden:

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

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

Überprüfung

object == nullist anders zu überprüfen if ( !object ).

Letzteres ist gleich ! Boolean(object), weil der unäre !Operator den richtigen Operanden automatisch in einen Booleschen Wert umwandelt.

Da ist dann Boolean(null)gleich falsch !false === true.

Wenn Ihr Objekt also nicht null , sondern false oder 0 oder "" ist , wird die Prüfung bestanden, weil:

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

nullist kein Objekt , es ist ein primitiver Wert . Beispielsweise können Sie keine Eigenschaften hinzufügen. Manchmal nehmen die Leute fälschlicherweise an, dass es sich um ein Objekt handelt, weil es typeof nullzurückkehrt "object". Aber das ist tatsächlich ein Fehler (der möglicherweise sogar in ECMAScript 6 behoben wurde).

Der Unterschied zwischen nullund undefinedist wie folgt:

• undefined: Wird von JavaScript verwendet und bedeutet "kein Wert". Nicht initialisierte Variablen, fehlende Parameter und unbekannte Variablen haben diesen Wert.

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

  Der Zugriff auf unbekannte Variablen führt jedoch zu einer Ausnahme:

  > unknownVariable
  ReferenceError: unknownVariable is not defined

• null: Wird von Programmierern verwendet, um "kein Wert" anzuzeigen, z. B. als Parameter für eine Funktion.

Untersuchen einer Variablen:

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

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

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

In der Regel sollten Sie in JavaScript immer === und niemals == verwenden (== führt alle Arten von Konvertierungen durch , die zu unerwarteten Ergebnissen führen können). Die Prüfung x == nullist ein Randfall, da sie sowohl für nullals auch für undefined:

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

Eine übliche Methode, um zu überprüfen, ob eine Variable einen Wert hat, besteht darin, ihn in einen Booleschen Wert zu konvertieren und festzustellen, ob dies der Fall ist true. Diese Konvertierung wird von der ifAnweisung und dem booleschen Operator durchgeführt! ("nicht").

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

Nachteil dieses Ansatzes: Alle folgenden Werte werden mit bewertet false, daher müssen Sie vorsichtig sein (z. B. können die obigen Überprüfungen nicht zwischen undefinedund unterscheiden 0).

• undefined, null
• Boolesche Werte: false
• Zahlen: +0, -0,NaN
• Saiten: ""

Sie können die Konvertierung in Boolesche Werte testen, indem Sie sie Booleanals Funktion verwenden (normalerweise handelt es sich um einen Konstruktor, mit dem verwendet werden soll new):

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

Was ist der Unterschied zwischen null und undefiniert?

Eine Eigenschaft, die keine Definition hat, ist undefiniert. null ist ein Objekt. Sein Typ ist Objekt. null ist ein spezieller Wert, der "kein Wert" bedeutet. undefined ist kein Objekt, sein Typ ist undefined.

Sie können eine Variable deklarieren, auf null setzen und das Verhalten ist identisch, außer dass "null" im Vergleich zu "undefiniert" ausgedruckt wird. Sie können sogar eine undefinierte Variable mit null vergleichen oder umgekehrt, und die Bedingung ist wahr:

 undefined == null
 null == undefined

Weitere Informationen finden Sie unter JavaScript-Unterschied zwischen null und undefiniert .

und mit deiner neuen edit ja

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

Beim Testen, ob das Objekt falsch ist, erfüllen beide nur die Bedingung beim Testen, ob es falsch ist, nicht jedoch, wenn es wahr ist

Überprüfen Sie hier: Javascript gotcha

Erster Teil der Frage:

Warum wird null in JavaScript als Objekt betrachtet?

Es ist ein JavaScript-Designfehler, den sie jetzt nicht beheben können. Es sollte vom Typ null sein, kein Objekt oder überhaupt nicht. Es erfordert eine zusätzliche Überprüfung (manchmal vergessen) bei der Erkennung realer Objekte und ist die Quelle von Fehlern.

Zweiter Teil der Frage:

Überprüft


if (object == null)
Do something

das gleiche wie

if (!object)
Do something

Die beiden Prüfungen sind immer beide falsch, außer:

• Objekt ist undefiniert oder null: beide wahr.

• Objekt ist primitiv und 0 ""oder falsch: Überprüfen Sie zuerst false, zweitens true.

Wenn das Objekt nicht eine primitive, aber ein reales Objekt, wie new Number(0), new String(""), oder new Boolean(false), dann sind beide Kontrollen falsch.

Wenn also 'Objekt' als echtes Objekt interpretiert wird, sind beide Prüfungen immer gleich. Wenn Grundelemente zulässig sind, unterscheiden sich die Überprüfungen für 0 ""und false.

In Fällen wie object==nullkönnen die nicht offensichtlichen Ergebnisse eine Fehlerquelle sein. Die Verwendung von ==wird niemals empfohlen, ===stattdessen verwenden.

Dritter Teil der Frage:

Und außerdem:

Was ist der Unterschied zwischen null und undefiniert?

In JavaScript besteht ein Unterschied darin, dass null vom Typ object und undefined vom Typ undefined ist.

In JavaScript null==undefinedist true und wird als gleich angesehen, wenn der Typ ignoriert wird. Warum sie das entschieden haben, aber 0 ""und false sind nicht gleich, weiß ich nicht. Es scheint eine willkürliche Meinung zu sein.

In JavaScript null===undefinedist dies nicht der Fall, da der Typ in identisch sein muss ===.

In Wirklichkeit sind null und undefiniert identisch, da beide Nichtexistenz darstellen. Also mach 0, und ""das auch, und vielleicht die leeren Behälter []und {}. So viele Arten des gleichen Nichts sind ein Rezept für Fehler. Ein Typ oder gar keiner ist besser. Ich würde versuchen, so wenig wie möglich zu verwenden.

'falsch', 'wahr' und '!' sind eine weitere Tüte Würmer, die zum Beispiel vereinfacht werden könnten, if(!x)undif(x) allein ausreichen, Sie brauchen nicht wahr und falsch.

Ein deklarierter var xTyp ist undefiniert, wenn kein Wert angegeben wird. Er sollte jedoch derselbe sein, als ob x niemals deklariert worden wäre. Eine andere Fehlerquelle ist ein leerer Nichts-Container. Also ist es am besten, es zusammen zu deklarieren und zu definieren, wie var x=1.

Die Leute drehen sich im Kreis und versuchen, all diese verschiedenen Arten von Nichts herauszufinden, aber es ist alles nur dasselbe in komplizierten verschiedenen Kleidern. Die Realität ist

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

Und vielleicht sollten alle Ausnahmen werfen.

var x = null;

x ist als null definiert

y ist nicht definiert; // weil ich es nicht definiert habe

if (!x)

null wird als falsch ausgewertet

Eine Möglichkeit, null und undefiniert zu verstehen, besteht darin, zu verstehen, wo die einzelnen Vorkommen auftreten.

Erwarten Sie in den folgenden Situationen einen Rückgabewert von Null:

• Methoden, die das DOM abfragen

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

• JSON-Antworten von einer Ajax-Anfrage

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• Neue Funktionalität im Wandel. Folgendes gibt null zurück:

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

       // But this returns undefined:

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

Alle anderen Fälle von Nichtexistenz werden mit undefiniert bezeichnet (wie von @Axel angegeben). Jeder der folgenden Ausdrucke ist "undefiniert":

    var uninitalised;
    console.log(uninitalised);

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

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

    missingParam();

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

Natürlich, wenn Sie sich entscheiden, var unitialised = null zu schreiben; oder geben Sie von einer Methode selbst null zurück, dann tritt in anderen Situationen null auf. Das sollte aber ziemlich offensichtlich sein.

Ein dritter Fall ist, wenn Sie auf eine Variable zugreifen möchten, aber nicht einmal wissen, ob sie deklariert wurde. Verwenden Sie in diesem Fall typeof, um einen Referenzfehler zu vermeiden:

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

Überprüfen Sie zusammenfassend, ob Sie null sind, wenn Sie das DOM bearbeiten, mit Ajax arbeiten oder bestimmte ECMAScript 5-Funktionen verwenden. In allen anderen Fällen ist es sicher, mit strikter Gleichheit auf undefiniert zu prüfen:

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

Vergleich vieler verschiedener Nullprüfungen in JavaScript:

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

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

...trim...

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

null und undefined sind beide falsch für die Wertgleichheit (null == undefined): Beide kollabieren zu boolean false. Sie sind nicht dasselbe Objekt (null! == undefiniert).

undefined ist eine Eigenschaft des globalen Objekts ("Fenster" in Browsern), aber ein primitiver Typ und kein Objekt selbst. Dies ist der Standardwert für nicht initialisierte Variablen und Funktionen, die ohne return-Anweisung enden.

null ist eine Instanz von Object. null wird für DOM-Methoden verwendet, die Sammlungsobjekte zurückgeben, um ein leeres Ergebnis anzuzeigen, das einen falschen Wert liefert, ohne einen Fehler anzugeben.

Einige Präzisionen:

null und undefiniert sind zwei verschiedene Werte. Einer repräsentiert das Fehlen eines Wertes für einen Namen und der andere repräsentiert das Fehlen eines Namens.

Was in einem passiert, ist ifwie folgt für if( o ):

Der Ausdruck in den Klammern o wird ausgewertet, und dann wird der ifWert des Ausdrucks in den Klammern vom Typ erzwungen - in unserem Fall o.

Falsche Werte (die zu false gezwungen werden) in JavaScript sind: '', null, undefined, 0 und false .

Um die Antwort von Was ist der Unterschied zwischen undefinedundnull , aus JavaScript Definitive Guide 6th Edition, S.41 auf dieser Seite hinzuzufügen :

Sie können in Betracht ziehen undefined, das Fehlen eines Werts nullauf Systemebene, ein unerwartetes oder fehlerhaftes Fehlen von Wert und das Fehlen eines Werts auf Programmebene, ein normales oder ein erwartetes Fehlen darzustellen. Wenn Sie einen dieser Werte einer Variablen oder Eigenschaft zuweisen oder einen dieser Werte an eine Funktion übergeben müssen, nullist dies fast immer die richtige Wahl.

nullist ein Objekt. Sein Typ ist null. undefinedist kein Objekt; sein Typ ist undefiniert.

Die folgende Funktion zeigt, warum und in der Lage ist, den Unterschied herauszufinden:

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

Wenn Sie anrufen

test();

Du bekommst

nicht definiert

Null

Die ersten console.log(...)Versuche zu bekommen myPropertyaus , myObjwährend es noch nicht definiert ist - so es wird „undefined“ zurück. Nach dem Zuweisen von null gibt der zweite console.log(...)offensichtlich "null" zurück, da er myPropertyexistiert, aber ihm ist der Wert nullzugewiesen.

Um diesen Unterschied abfragen zu können, hat JavaScript nullund undefined: While nullist - genau wie in anderen Sprachen ein Objekt, undefinedkann kein Objekt sein, da keine Instanz (auch keine nullInstanz) verfügbar ist.

Zum Beispiel window.someWeirdPropertyist so undefiniert

"window.someWeirdProperty === null" wird währenddessen als falsch ausgewertet

"window.someWeirdProperty === undefined" bewertet als wahr.

Außerdem ist checkif if (!o)nicht dasselbe wie checking if (o == null)for obeing false.

Das andere lustige an null im Vergleich zu undefiniert ist, dass es inkrementiert werden kann.

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

Dies ist nützlich, um numerische Standardwerte für Zähler festzulegen. Wie oft haben Sie eine Variable in ihrer Deklaration auf -1 gesetzt?

In Javascript null ist kein objectTyp, es ist ein primitaveTyp.

Was ist der Unterschied? Undefiniert bezieht sich auf einen Zeiger, der nicht gesetzt wurde. Null bezieht sich auf den Nullzeiger. Beispielsweise hat etwas manuell eine Variable vom Typ gesetztnull

Schau dir das an:

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

Aus "Die Prinzipien des objektorientierten Javascript" von Nicholas C. Zakas

Aber warum ein Objekt, wenn der Typ null ist? (Tatsächlich wurde dies von TC39, dem Ausschuss, der JavaScript entwirft und verwaltet, als Fehler anerkannt. Sie könnten argumentieren, dass null ein leerer Objektzeiger ist, wodurch "Objekt" zu einem logischen Rückgabewert wird, aber das ist immer noch verwirrend.)

Zakas, Nicholas C. (07.02.2014). Die Prinzipien von objektorientiertem JavaScript (Kindle Locations 226-227). Keine Stärkepresse. Kindle Edition.

Das gesagt:

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

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

Undefinierter Fall:

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

Der beste Weg, um über 'null' nachzudenken, besteht darin, sich daran zu erinnern, wie das ähnliche Konzept in Datenbanken verwendet wird, wobei es angibt, dass ein Feld "überhaupt keinen Wert" enthält.

• Ja, der Wert des Artikels ist bekannt. es ist 'definiert'. Es wird initialisiert.
• Der Wert des Artikels lautet: "Es gibt keinen Wert."

Dies ist eine sehr nützliche Technik zum Schreiben von Programmen, die einfacher zu debuggen sind. Eine 'undefinierte' Variable könnte das Ergebnis eines Fehlers sein ... (woher wissen Sie das?) ... aber wenn die Variable den Wert 'null' enthält, wissen Sie, dass "jemand, irgendwo in diesem Programm, ihn auf gesetzt hat 'null.' "Daher schlage ich vor, dass Sie, wenn Sie den Wert einer Variablen entfernen müssen, nicht" löschen "... auf 'null' setzen. Der alte Wert wird verwaist sein und bald wird Müll gesammelt; Der neue Wert lautet "Es gibt (jetzt) ​​keinen Wert." In beiden Fällen ist der Zustand der Variablen sicher: "Es ist offensichtlich absichtlich so gekommen."

1. Undefiniert bedeutet, dass eine Variable deklariert wurde, ihr jedoch kein Wert zugewiesen wurde, während Null einer Variablen zugewiesen werden kann, die "kein Wert" darstellt. (Null ist ein Zuweisungsoperator.)

2.Undefined ist ein Typ selbst, während Null ein Objekt ist.

3.Javascript kann jede nicht zugewiesene Variable selbst auf undefiniert initialisieren, aber niemals den Wert einer Variablen auf null setzen. Dies muss programmatisch erfolgen.