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

StackOverflow https://stackoverflow.com/questions/801032

Frage

Warum ist null als object in JavaScript?

Ist die überprüfung 

if ( object == null )
      Do something

das gleiche wie 

if ( !object )
      Do something

?

Und auch:

Was ist der Unterschied zwischen null und undefined?

War es hilfreich?

Lösung 

(name is undefined)

Sie: Was ist name (*)
JavaScript: name? Was ist ein name? Ich weiß nicht, was du redest. Sie haben nicht immer, bevor Sie name erwähnt. Sind Sie eine andere Skriptsprache auf der (client-) Seite sehen? 

name = null;

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

Kurz gesagt; undefined ist, wo keine Ahnung von dem, was existiert; es hat keine Art, und es ist noch nie zuvor in diesem Umfang Bezug genommen worden ist; null ist, wo die Sache bekannt ist, zu existieren, aber es ist nicht bekannt, was der Wert ist.

Eine Sache zu erinnern ist, dass null ist nicht konzeptionell die gleiche wie false oder "" oder so, auch wenn sie nach Art Casting gleichsetzen, d. 

name = false;

Sie: Was ist name
? JavaScript. Boolean false 

name = '';

Sie: Was ist name
? JavaScript: Leere Zeichenfolge

*: name in diesem Zusammenhang wird als Variable gemeint, die nie definiert wurde. Es könnte ein nicht definiert Variable sein, aber Name ist eine Eigenschaft von fast jedem HTML-Formularelement. Es geht weit, weit zurück und wurde gut vor id eingeleitet. Es ist nützlich, weil ids eindeutig sein müssen, aber Namen sein müssen nicht.

Andere Tipps

Der Unterschied kann in diesen Schnipsel zusammenfassen: 

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

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

Überprüfen

object == null unterscheidet if ( !object ) zu überprüfen.

Das letztere ist gleich ! Boolean(object), weil der einstellige ! Operator automatisch den rechten Operanden in einen Booleschen gegossen.

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

Also, wenn Ihr Ziel ist es nicht null , und false oder 0 oder "" , wird der Scheck übergeben weil: 

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

null ist kein Objekt , es ist ein Grundwert . Zum Beispiel können Sie Eigenschaften, um es nicht hinzuzufügen. Manchmal nehmen die Menschen an zu Unrecht, dass es ein Objekt ist, weil typeof null "object" zurückgibt. Aber das ist eigentlich ein Fehler (das könnte auch in ECMAScript 6 fixiert werden).

Der Unterschied zwischen null und undefined ist wie folgt:

  • undefined: verwendet von JavaScript und bedeutet „keinen 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

    unbekannte Variablen Zugriff erzeugt jedoch eine Ausnahme: 

    > unknownVariable
ReferenceError: unknownVariable is not defined

  • null: von Programmierern verwendet, um anzuzeigen, „keinen Wert“, z.B. als Parameter an eine Funktion.

Prüfungs eine Variable: 

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

Als allgemeine Regel sollten Sie immer === und == nie in JavaScript (== führt alle Arten von Umwandlungen das kann zu unerwarteten Ergebnissen) erzeugen. Die Prüfung x == null ist ein Grenzfall, da es sowohl für null und undefined funktioniert: 

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

Ein üblicher Weg, zu überprüfen, ob eine Variable einen Wert hat, ist es zu konvertieren zu boolean und zu sehen, ob es true ist. Diese Umwandlung wird durch die if Anweisung und der Booleschen Operator ausgefü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 auswerten false, so muss man vorsichtig sein (zum Beispiel können die obigen Prüfungen nicht unterscheiden zwischen undefined und 0)

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

Sie die Konvertierung testen können mit Boolean als Funktion boolean (in der Regel ist es ein Konstruktor, mit new verwendet werden): 

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

Was ist der Unterschied zwischen null und undefined ??

Eine Eigenschaft, wenn es keine Definition hat, ist nicht definiert. null ist ein Objekt. Seine Art ist Gegenstand. Null ist ein spezieller Wert „keinen Wert bedeutet. undefiniert ist kein Objekt, es ist Typ ist nicht definiert.

Sie können eine Variable deklarieren, setzen Sie ihn auf Null zu bringen, und das Verhalten ist identisch mit der Ausnahme, dass Sie „null“ ausgedruckt versus „undefined“ sehen. Sie können sogar eine Variable vergleichen, die auf Null oder umgekehrt nicht definiert ist, und der Zustand wird wahr sein: 

 undefined == null
 null == undefined

Siehe JavaScript Der Unterschied zwischen null und undefined für mehr Details.

und mit Ihrem neuen Bearbeiten Ja 

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

bei der Prüfung, wenn das Objekt falsch ist, sie beide nur die Bedingung erfüllen, wenn bei der Prüfung, ob false , aber nicht, wenn true

Überprüfen Sie hier: Javascript Gotcha

Der erste Teil der Frage:

  

Warum ist null ein Objekt in JavaScript?

betrachtet

Es ist ein JavaScript-Design-Fehler sie jetzt nicht beheben können. Es sollte Typ null gewesen, nicht Objekt ein, oder es gar nicht haben. Es erfordert eine zusätzliche Kontrolle (manchmal vergessen), wenn reale Objekte zu erfassen und ist Fehlerquelle.

Der zweite Teil der Frage:

  

prüft
  
  if (object == null)
  Do something
  
  die gleiche wie
  
  if (!object)
  Do something

Die beiden Kontrollen sind immer beide falsch ausgenommen:

  • Objekt ist nicht definiert oder null. Beide true

  • Objekt ist primitiv und 0, "" oder falsch. Zuerst falsch überprüfen, zweiter true

Wenn das Objekt nicht ein primitives ist, sondern ein reales Objekt, wie new Number(0), new String("") oder new Boolean(false), dann beide Überprüfungen sind falsch.

Also, wenn ‚Objekt‘ interpretiert wird ein reales Objekt zu verstehen, dann sind beide Kontrollen immer gleich. Wenn Primitive erlaubt ist, dann sind die Kontrollen unterschiedlich für 0, "" und falsch.

In Fällen wie object==null könnten die nicht offensichtlichen Ergebnisse eine Fehlerquelle sein. Die Verwendung von == nicht immer, verwenden === stattdessen empfohlen.

Der dritte Teil der Frage:

  

Und auch:
  
  Was ist der Unterschied zwischen null und undefined?

In JavaScript ein Unterschied ist, dass null vom Typ Objekt ist und nicht definiert ist vom Typ nicht definiert.

In JavaScript null==undefined ist wahr, und als gleich betrachtet, wenn der Typ ignoriert. Warum sie entschieden, dass, aber 0, "" und falsch nicht gleich sind, weiß ich nicht. Es scheint eine willkürliche Meinung zu sein.

In JavaScript null===undefined ist nicht wahr, da der Typ in === gleich sein müssen.

In Wirklichkeit null und undefined identisch sind, da sie beide nicht-Existenz darstellen. So tun 0 und "" was das betrifft auch, und vielleicht die leeren Behälter [] und {}. So viele Arten von derselben nichts sind ein Rezept für Fehler. Eine Art oder gar keine ist besser. Ich würde versuchen, so wenig wie möglich zu nutzen.

'falsch', 'true' und '!' vereinfacht, beispielsweise if(!x) und if(x), brauchen Sie allein ausreichend sind konnte nicht wahr und falsch sind eine andere Tasche von Würmern, die.

Ein erklärtes var x undefiniert geben, wenn kein Wert angegeben wird, aber es soll das gleiche sein wie bei x überhaupt nicht erklärt wurde. Ein weiterer Fehler Quelle ist ein leerer Behälter nichts. So ist es am besten, um es zusammen zu erklären und zu definieren, wie var x=1.

Die Menschen sind rund und im Kreis versuchen, all diese verschiedenen Arten von nichts, um herauszufinden, aber es ist alles nur die gleiche Sache 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 definieren 

if (!x)

null wird als falsch ausgewertet

Eine Möglichkeit, Sinn für null und undefined zu machen, ist zu verstehen, wo jeder auftritt.

Erwarten Sie eine Nullrückgabewert in den folgenden Situationen:

  • Methoden, die den DOM

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

  • JSON Antworten von einer Ajax-Anforderung empfangen 


    {
      name: "Bob",
      address: null
    }

  • RegEx.exec .

  • Neue Funktionen, die in einem Zustand des Flusses ist. Der folgende Code gibt null: 


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

       // But this returns undefined:

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

Alle anderen Fälle von Nicht-Existenz durch undefinierte bezeichnet (wie durch @Axel angegeben). Jede der folgenden prints "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 null zurück von einer Methode, sich dann in anderen Situationen auftreten Sie null haben. Aber das sollte ziemlich offensichtlich sein.

Ein dritter Fall ist, wenn Sie eine Variable zugreifen möchten, aber Sie wissen nicht einmal, wenn er erklärt wurde. Für diesen Fall verwenden typeof einen Referenzfehler zu vermeiden: 

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

Insgesamt Check für null, wenn Sie das DOM manipulieren, die sie mit Ajax oder der Verwendung bestimmten ECMAScript 5-Funktionen. In allen anderen Fällen ist es sicher für undefinierte mit strikter Gleichheit zu überprüfen: 

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

Vergleich von vielen verschiedenen null Kontrollen 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

JavaScript Null überprüft Vergleichstabelle

null und nicht definiert sind beide falsch für Wertgleichheit (null == undefined): sie beide Zusammenbruch falsch boolean. Sie sind nicht das gleiche Objekt (null! == undefined).

undefiniert ist eine Eigenschaft des globalen Objekts ( „Fenster“ in Browsern), sondern ist eine primitive Art und kein Objekt selbst. Es ist der Standardwert für nicht initialisierte Variablen und Funktionen ohne return-Anweisung beendet wird.

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

Einige Präzisierungen:

null und undefined sind zwei verschiedene Werte. Man vertritt das Fehlen eines Werts für einen Namen und die andere, die die Abwesenheit eines Namens.

Was in einem if geschieht geht wie für if( o ) folgt:

Der Ausdruck in der Klammer o ausgewertet wird, und dann werden die if Tritte in Typ-Nötigung den Wert des Ausdrucks in den Klammern -. In unserem Fall o

Falsy (das auf false erhält dazu gezwungen werden) Werte in JavaScript sind: '', null, nicht definiert, 0 und false .

auf die Antwort von Hinzufügen Was ist die differrence zwischen undefined und null , von JavaScript Definitive Guide auf dieser Seite :

  

Sie könnten undefined betrachten zu Systemebene darstellen, unerwartet,   oder fehler wie absense von Wert und null Programmebene darstellen,   normal, oder das Fehlen von Wert zu erwarten. Wenn Sie zuerst eine zuweisen   oder diese Werte einer Variable oder Eigenschaft passieren einen dieser Werte zu   eine Funktion, null ist fast immer die richtige Wahl.

Die folgende Funktion zeigt, warum und ist in der Lage für den Unterschied Ausarbeiten: 

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

Wenn Sie anrufen 

test();

Sie bekommen

  

undefined

     

null

Der erste console.log(...) versucht myProperty von myObj zu bekommen, während es noch nicht definiert ist - so ist es „undefiniert“ zurückkommt. Nach der Zuordnung es null, gibt die zweite console.log(...) offensichtlich „null“, weil myProperty existiert, aber es hat den Wert null ihm zugeordneten.

Um in der Lage sein, diesen Unterschied abzufragen, ist Javascript null und undefined: Während null ist - genau wie in anderen Sprachen ein Objekt, undefined kann nicht ein Objekt sein, weil es keine Instanz ist (auch keine null Instanz) zur Verfügung.

null ist ein Objekt. Seine Art ist null. undefined ist kein Objekt; seine Art ist nicht definiert.

Zum Beispiel window.someWeirdProperty ist nicht definiert, so

"window.someWeirdProperty === null" das Ergebnis falsch, während

"window.someWeirdProperty === undefined" true ausgewertet.

Darüber hinaus checkif if (!o) ist nicht die gleiche wie if (o == null) für o sein false zu überprüfen.

Die andere lustige Sache über null, im Vergleich zu unbestimmt, ist, dass sie erhöht werden kann. 

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

Dies ist nützlich für Standard-Zahlenwerte für Zähler einstellen. Wie oft haben Sie eine Variable in ihrer Erklärung auf -1?

Javascript null ist kein object Typ es ist ein primitave Typ.

Was ist der Unterschied? Nicht definiert bezieht sich auf einen Zeiger, der nicht gesetzt worden ist. NULL bezieht sich auf den Null-Zeiger zum Beispiel hat ein etwas manuell variabel ist vom Typ null gesetzt

Blick auf diese: 

   <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

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

  

Aber warum ein Objekt, wenn der Typ null ist? (In der Tat wird dies durch TC39 als Fehler anerkannt, der Ausschuß, entwirft und unterhält JavaScript. Sie könnten, dass null Grund ist ein leeres Objekt Zeiger, so dass „Objekt“ ein logischen Rückgabewert, aber das ist immer noch verwirrend.)

Zakas, Nicholas C. (2014.02.07). Die Prinzipien der objektorientierten JavaScript (Kindle Standorte 226-227). No Starch Press. Kindle Edition.

Wie 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;

Nicht definiert 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, zu denken, über die 'null' ist, daran zu erinnern, wie der ähnliche Konzept in Datenbanken, wo es zeigt an, dass ein Feld enthält "keinen Wert."

  • Ja, der Wert der Sache bekannt ist;es ist 'definiert.' Es hat initialisiert wurde.
  • Der Wert der Sache ist: "es ist kein Wert."

Dies ist eine sehr nützliche Technik für die Programme zu schreiben, die besser Debuggen.Ein 'undefined' variable könnte das Ergebnis eines Fehlers ... (wie würden Sie wissen?) ...aber wenn die variable enthält den Wert 'null,' Sie wissen, dass "jemand, irgendwo in diesem Programm legen Sie es auf 'null.'" Ich empfehle daher, dass Sie, wenn Sie benötigen, um loszuwerden, den Wert einer Variablen, nicht "löschen" ...stellen Sie 'null.' Der alte Wert, werden verwaiste und bald wird die Müll-gesammelt;der neue Wert wird, "es gibt keinen Wert, der (jetzt)." In beiden Fällen wird die variable state ist sicher:"es ist offensichtlich, absichtlich, bekam auf diese Weise."

  1. Undefinierte bedeutet eine Variable erklärt worden, aber es wurde nicht zugewiesen beliebigen Wert Null während einer Variablen zugewiesen werden kann „keinen Wert“ darstellt. (Null ein Zuweisungsoperator)

2.Undefined ist eine Art selbst während Null ein Objekt ist.

3.Javascript kann dabei selbst nicht zugewiesene Variable nicht definiert initialisieren, aber es kann nie Wert einer Variablen auf null gesetzt. Dies hat programmatisch durchgeführt werden.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top