Welche Methode zur Überprüfung, ob eine Variable initialisiert wurde, ist besser / korrekt? (Angenommen, die Variable kann alles enthalten (Zeichenfolge, Int, Objekt, Funktion usw.))

if (elem) { // or !elem

oder

if (typeof(elem) !== 'undefined') {

oder

if (elem != null) {

Sie möchten den typeofOperator . Speziell:

if (typeof variable !== 'undefined') {
    // the variable is defined
}

Der typeofOperator prüft, ob die Variable wirklich undefiniert ist.

if (typeof variable === 'undefined') {
    // variable is undefined
}

Der typeofOperator löst im Gegensatz zu den anderen Operatoren keine ReferenceError- Ausnahme aus, wenn er mit einer nicht deklarierten Variablen verwendet wird.

Beachten Sie jedoch, dass dies typeof nullzurückkehren wird "object". Wir müssen vorsichtig sein, um den Fehler zu vermeiden, eine Variable mit zu initialisieren null. Um sicher zu gehen, könnten wir stattdessen Folgendes verwenden:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

Weitere Informationen zur Verwendung eines strengen Vergleichs ===anstelle einer einfachen Gleichheit ==finden Sie unter:
Welcher Gleichheitsoperator (== vs ===) sollte in JavaScript-Vergleichen verwendet werden?

In vielen Fällen wird Folgendes verwendet:

if (elem) { // or !elem

erledigt den Job für Sie! ... dies überprüft die folgenden Fälle:

1. undefined : wenn der Wert nicht definiert ist und es istundefined
2. null : wenn es null ist, zum Beispiel wenn ein DOM-Element nicht existiert ...
3. leere Zeichenfolge :''
4. 0 : Nummer Null
5. NaN : keine Nummer
6. falsch

Es werden also alle Fälle abgedeckt, aber es gibt immer seltsame Fälle, die wir auch behandeln möchten, zum Beispiel eine Zeichenfolge mit Leerzeichen, wie diese ' ', die in Javascript definiert wird, da sie Leerzeichen innerhalb der Zeichenfolge enthält ... in diesem Fall fügen Sie beispielsweise mit trim () eine weitere Prüfung hinzu, wie z.

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Außerdem gelten diese Überprüfungen nur für Werte , da Objekte und Arrays in Javascript unterschiedlich funktionieren. Leeres Array []und leeres Objekt {}sind immer wahr .

Ich erstelle das Bild unten, um einen kurzen Überblick über die Antwort zu geben:

In JavaScript kann eine Variable definiert werden, die jedoch den Wert enthält undefined, sodass die häufigste Antwort technisch nicht korrekt ist und stattdessen Folgendes ausführt:

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

Das kann für Ihre Zwecke ausreichen. Der folgende Test hat eine einfachere Semantik, die es einfacher macht, das Verhalten Ihres Codes genau zu beschreiben und es selbst zu verstehen (wenn Sie sich für solche Dinge interessieren):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

Dies setzt natürlich voraus, dass Sie in einem Browser ausgeführt werden (wobei windowein Name für das globale Objekt angegeben ist). Aber wenn Sie mit solchen Globals herumspielen, befinden Sie sich wahrscheinlich in einem Browser. Subjektiv ist die Verwendung 'name' in windowstilistisch konsistent mit der Verwendung, window.nameum sich auf Globale zu beziehen. Durch den Zugriff auf Globals als Eigenschaften windowund nicht als Variablen können Sie die Anzahl der nicht deklarierten Variablen minimieren, auf die Sie in Ihrem Code verweisen (zum Vorteil des Flusens), und die Möglichkeit vermeiden, dass Ihr Global von einer lokalen Variablen überschattet wird. Wenn Globals Ihre Haut kriechen lassen, fühlen Sie sich möglicherweise wohler, wenn Sie sie nur mit diesem relativ langen Stock berühren.

In den meisten Fällen würden Sie Folgendes verwenden:

elem != null

Im Gegensatz zu einem einfachen if (elem), ermöglicht es 0, false, NaNund '', aber Spuck nulloder undefinedihm einen guten, allgemeiner Test für das Vorhandensein eines Argument zu machen, oder Eigenschaft eines Objekts.

Die anderen Prüfungen sind ebenfalls nicht falsch, sie haben nur unterschiedliche Verwendungszwecke:

• if (elem): Kann verwendet werden , wenn elemein Objekt sein, oder wenn garantiert false, 0usw. „default“ Werte (daher gleichwertig betrachtet undefinedoder null).

• typeof elem == 'undefined'kann in Fällen verwendet werden, in denen eine Angabe nulleine eindeutige Bedeutung für eine nicht initialisierte Variable oder Eigenschaft hat.

  • Dies ist die einzige Prüfung, die keinen Fehler auslöst, wenn sie elemnicht deklariert ist (dh keine varAnweisung, keine Eigenschaft von windowoder kein Funktionsargument). Dies ist meiner Meinung nach ziemlich gefährlich, da Tippfehler unbemerkt vorbeiziehen können. Um dies zu vermeiden, lesen Sie die folgende Methode.

Nützlich ist auch ein strenger Vergleich mit undefined:

if (elem === undefined) ...

Da die globale undefinedVariable jedoch mit einem anderen Wert überschrieben werden kann, ist es am besten, die Variable undefinedim aktuellen Bereich zu deklarieren, bevor Sie sie verwenden:

var undefined; // really undefined
if (elem === undefined) ...

Oder:

(function (undefined) {
    if (elem === undefined) ...
})();

Ein sekundärer Vorteil dieser Methode besteht darin, dass JS-Minifizierer die undefinedVariable auf ein einzelnes Zeichen reduzieren können , wodurch Sie jedes Mal einige Bytes sparen.

Überprüfen Sie, ob window. hasOwnProperty( " varname" )

Eine Alternative zur Fülle von typeofAntworten;

Globale Variablen, die mit einer var varname = value;Anweisung im globalen Bereich deklariert wurden

kann als Eigenschaften des Fensterobjekts zugegriffen werden.

Als solche die hasOwnProperty()Methode, die

Gibt einen Booleschen Wert zurück, der angibt, ob das Objekt die angegebene Eigenschaft als eigene Eigenschaft hat (im Gegensatz zum Erben).

kann verwendet werden, um festzustellen, ob

a varvon "varname" wurde global deklariert, dh es ist eine Eigenschaft von window.

// Globally established, therefore, properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
//  window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ), // true
    window.hasOwnProperty( "bar" ), // true
    window.hasOwnProperty( "baz" ), // true
    window.hasOwnProperty( "qux" )  // false
] );

Das Tolle daran hasOwnProperty()ist, dass wir beim Aufrufen keine Variable verwenden, die möglicherweise noch nicht deklariert ist - was natürlich in erster Linie das halbe Problem ist.

Obwohl dies nicht immer die perfekte oder ideale Lösung ist, ist es unter bestimmten Umständen nur der Job!

Anmerkungen

Das Obige gilt für die varDefinition einer Variablen , im Gegensatz zu let:

deklariert eine lokale Variable für den Blockbereich und initialisiert sie optional mit einem Wert.

unterscheidet sich vom varSchlüsselwort, das eine Variable global oder lokal für eine gesamte Funktion unabhängig vom Blockbereich definiert.

Auf der obersten Ebene von Programmen und Funktionen wird letim Gegensatz dazu varkeine Eigenschaft für das globale Objekt erstellt.

Der Vollständigkeit const halber : Konstanten sind per Definition nicht wirklich variabel (obwohl ihr Inhalt sein kann); relevanter:

Globale Konstanten werden im Gegensatz zu varVariablen nicht zu Eigenschaften des Fensterobjekts . Ein Initialisierer für eine Konstante ist erforderlich. Das heißt, Sie müssen den Wert in derselben Anweisung angeben, in der er deklariert ist.

Der Wert einer Konstante kann sich durch Neuzuweisung nicht ändern und kann nicht neu deklariert werden.

Die const-Deklaration erstellt einen schreibgeschützten Verweis auf einen Wert. Dies bedeutet nicht, dass der darin enthaltene Wert unveränderlich ist, sondern dass die Variablenkennung nicht neu zugewiesen werden kann.

Da letVariablen oder constKonstanten niemals Eigenschaften eines Objekts sind, das die hasOwnProperty()Methode geerbt hat , kann sie nicht zur Überprüfung ihrer Existenz verwendet werden.

In Bezug auf die Verfügbarkeit und Verwendung von hasOwnProperty():

Jedes von Object abstammende Objekt erbt die hasOwnProperty()Methode. [...] Im Gegensatz zum inOperator überprüft diese Methode nicht die Prototypenkette des Objekts.

So überprüfen Sie, ob eine Variable vorhanden ist

Dies ist eine ziemlich kugelsichere Lösung zum Testen, ob eine Variable vorhanden ist und initialisiert wurde:

var setOrNot = typeof variable !== typeof undefined;

Es wird am häufigsten in Kombination mit einem ternären Operator verwendet , um einen Standard festzulegen, falls eine bestimmte Variable nicht initialisiert wurde:

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

Probleme mit der Kapselung

Leider können Sie Ihren Scheck nicht einfach in eine Funktion einkapseln.

Sie könnten daran denken, so etwas zu tun:

function isset(variable) {
    return typeof variable !== typeof undefined;
}

Dies führt jedoch zu einem Referenzfehler, wenn Sie z. isset(foo)und Variable foowurde nicht definiert, da Sie eine nicht vorhandene Variable nicht an eine Funktion weitergeben können:

Nicht gefangener Referenzfehler: foo ist nicht definiert

Testen, ob Funktionsparameter undefiniert sind

Während unsere issetFunktion nicht verwendet werden kann, um zu testen, ob eine Variable existiert oder nicht (aus den oben erläuterten Gründen), können wir damit testen, ob die Parameter einer Funktion undefiniert sind:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Obwohl kein Wert für yan function weitergegeben wird, funktioniert testunsere issetFunktion in diesem Zusammenhang einwandfrei, da ysie in function testals undefinedWert bekannt ist.

Es gibt eine andere kurze Möglichkeit, dies zu überprüfen, wenn Sie einfache Aufgaben und zugehörige Überprüfungen durchführen. Verwenden Sie einfach den bedingten (ternären) Operator.

var values = typeof variable !== 'undefined' ? variable : '';

Dies ist auch hilfreich, wenn Sie versuchen, die globale Variable mit Instanzzuweisung der Referenzvariablen zu deklarieren.

Wenn Sie überprüfen möchten, sollte die Variable nicht undefinedoder sein null. Führen Sie dann die folgende Prüfung durch.

Wenn die Variable deklariert ist und Sie den Wert überprüfen möchten, ist dies sogar einfach: und es würde zusammen ausgeführt undefinedund nullüberprüft.

var values = variable ? variable : '';

Kurzer Weg zum Testen einer Variablen ist nicht deklariert (nicht undefiniert)

if (typeof variable === "undefined") {
  ...
}

Ich fand es nützlich, um ein Skript zu erkennen, das außerhalb eines Browsers ausgeführt wird (ohne deklarierte windowVariable).

Es hängt davon ab, ob Sie sich nur darum kümmern, dass die Variable definiert wurde, oder ob Sie möchten, dass sie einen aussagekräftigen Wert hat.

Wenn Sie überprüfen, ob der Typ undefiniert ist, wird überprüft, ob die Variable noch definiert wurde.

=== nulloder !== nullprüft nur, ob der Wert der Variablen genau ist null.

== nulloder != nullprüft, ob der Wert undefinedoder ist null.

if(value)prüft , ob die Variable undefined, null, 0, oder eine leere Zeichenfolge.

Die höchste Antwort ist richtig, verwenden Sie typeof.

Ich wollte jedoch darauf hinweisen, dass JavaScript undefinedveränderlich ist (aus irgendeinem gottlosen Grund). Wenn Sie also einfach nach prüfen varName !== undefined, kann dies nicht immer so erfolgen, wie Sie es erwarten, da sich andere Bibliotheken möglicherweise undefiniert geändert haben. Ein paar Antworten (zum Beispiel @ skalee's) scheinen es vorzuziehen, sie nicht zu verwenden typeof, und das könnte einen in Schwierigkeiten bringen.

Die "alte" Art, damit umzugehen, bestand darin, undefiniert als var zu deklarieren, um mögliche Stummschaltungen / Überschreitungen von auszugleichen undefined. Der beste Weg ist jedoch immer noch, typeofda er das Überschreiben undefinedvon anderem Code ignoriert . Vor allem, wenn Sie Code für den Einsatz in freier Wildbahn schreiben, bei dem wer weiß, was sonst noch auf der Seite ausgeführt werden könnte ...

if (typeof console != "undefined") {    
   ...
}

Oder besser

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

Funktioniert in allen Browsern

Um zur Debatte beizutragen, wenn ich weiß, dass die Variable eine Zeichenfolge oder ein Objekt sein sollte, bevorzuge ich immer if (!variable), also überprüfe, ob sie falsch ist. Dies kann zu saubererem Code führen, so dass zum Beispiel:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

..kann reduziert werden auf:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 

Es ist schwierig, zwischen undefiniert und null zu unterscheiden. Null ist ein Wert, den Sie einer Variablen zuweisen können, wenn Sie angeben möchten, dass die Variable keinen bestimmten Wert hat. Undefiniert ist ein spezieller Wert, der der Standardwert nicht zugewiesener Variablen ist.

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

Null ist ein Wert in JavaScript und gibt typeof nullzurück"object"

Daher funktioniert die akzeptierte Antwort nicht, wenn Sie Nullwerte übergeben. Wenn Sie Nullwerte übergeben, müssen Sie eine zusätzliche Prüfung für Nullwerte hinzufügen:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

Die robusteste " Ist es definiert" -Prüfung erfolgt mit typeof

if (typeof elem === 'undefined')

Wenn Sie nur nach einer definierten Variablen suchen, um einen Standard zuzuweisen, können Sie für einen einfach zu lesenden Liner häufig Folgendes tun:

elem = elem || defaultElem;

Die Verwendung ist häufig in Ordnung, siehe: Idiomatische Methode zum Festlegen des Standardwerts in Javascript

Es gibt auch diesen einen Liner, der das Schlüsselwort typeof verwendet :

elem = (typeof elem === 'undefined') ? defaultElem : elem;

Sie können den typeofOperator verwenden.

Zum Beispiel,

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

Das obige Code-Snippet gibt die Ausgabe wie folgt zurück

Variable dataSet ist: undefiniert.

Um zu überprüfen, ob eine Variable deklariert / gesetzt wurde, habe ich diesen schmutzigen Trick gemacht.

Ich habe keine Möglichkeit gefunden, den Code in eine Funktion zu extrahieren, auch nicht mit eval.

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}

Diese Antworten (abgesehen von der Fred Gandt-Lösung) sind entweder falsch oder unvollständig.

Angenommen, ich muss variableName;einen undefinedWert tragen , und daher wurde er so deklariert var variableName;, dass er bereits initialisiert ist . - Wie überprüfe ich, ob es bereits deklariert ist?

Oder noch besser - wie überprüfe ich sofort, ob "Book1.chapter22.paragraph37" mit einem einzigen Aufruf vorhanden ist, ohne jedoch einen Referenzfehler auszulösen?

Dazu verwenden wir den leistungsstärksten JasvaScript-Operator, den In- Operator:

"[variable||property]" in [context||root] 
>> true||false

In Zeiten höchster Popularität von AJAX habe ich eine Methode (später genannt) isNS () geschrieben, mit der festgestellt werden kann, ob der Namespace vorhanden ist, einschließlich umfassender Tests für Eigenschaftsnamen wie "Book1.chapter22.paragraph37" und vieles mehr.

Aber da es bereits veröffentlicht wurde und aufgrund seiner großen Bedeutung es verdient, in einem separaten Thread veröffentlicht zu werden, werde ich es nicht hier veröffentlichen, sondern Schlüsselwörter ( Javascript + isNS ) bereitstellen, die Ihnen helfen, den Quellcode zu finden, der mit allen unterstützt wird notwendige Erklärungen.

In der in der Frage skizzierten besonderen Situation

typeof window.console === "undefined"

ist identisch mit

window.console === undefined

Ich bevorzuge letzteres, da es kürzer ist.

Bitte beachten Sie, dass wir consolenur im globalen Bereich suchen (was windowin allen Browsern ein Objekt ist). In dieser besonderen Situation ist es wünschenswert. Wir wollen nicht consoleanderswo definiert werden.

@BrianKelley erklärt in seiner großartigen Antwort technische Details. Ich habe nur fehlende Schlussfolgerungen hinzugefügt und es in etwas leichter zu lesendes verdaut.

Ich benutze je nach Objekt zwei verschiedene Möglichkeiten.

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

Manchmal möchte ich eine leere Zeichenfolge nicht als Falsey auswerten, daher verwende ich diesen Fall

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

Wenn Sie das Gegenteil benötigen, wird in erster Linie! Variable zu !! Variable und in der ungültigen Funktion === zu! = Und die Funktionsnamen ändern sich zu notInvalid.

Meine Präferenz ist typeof(elem) != 'undefined' && elem != null.

Wie auch immer Sie sich entscheiden, ziehen Sie in Betracht, den Scheck in eine solche Funktion einzufügen

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

Wenn Sie nicht wissen, dass die Variable deklariert ist, fahren Sie mit fort typeof (x) != 'undefined' && x != null;

Wenn Sie wissen, dass die Variable deklariert ist, aber möglicherweise nicht vorhanden ist, können Sie sie verwenden

existy(elem) && doSomething(elem);

Die Variable, die Sie überprüfen, kann manchmal eine verschachtelte Eigenschaft sein. Sie können prop || verwenden {}, um die Existenz der betreffenden Eigenschaft zu überprüfen:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

Verwenden Sie nach jeder Eigenschaft (... '|| {}'). NextProp, damit eine fehlende Eigenschaft keinen Fehler auslöst.

Oder Sie könnten existy wie verwenden existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Es hängt von der Situation ab. Wenn Sie nach etwas suchen, das möglicherweise global außerhalb Ihres Codes definiert wurde oder nicht (z. B. jQuery), möchten Sie Folgendes:

if (typeof(jQuery) != "undefined")

(Da keine strikte Gleichheit erforderlich ist, gibt typeof immer eine Zeichenfolge zurück.) Wenn Sie jedoch Argumente für eine Funktion haben, die möglicherweise übergeben wurde oder nicht, werden diese immer definiert, aber null, wenn sie weggelassen werden.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"

Try-Catch

Wenn die Variable überhaupt nicht definiert wurde, können Sie dies ohne Ausführung des Unterbrechungscodes mit dem try-catch-Block wie folgt überprüfen (Sie müssen nicht use strictmodifizieren).

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

BONUS: (unter Bezugnahme auf andere Antworten) Warum ===ist klarer als ==( Quelle )

if (a == b)

if (a === b)

Ich bin überrascht, dass dies noch nicht erwähnt wurde ...

Hier sind einige zusätzliche Variationen mit this['var_name']

Der Vorteil dieser Methode besteht darin, dass sie verwendet werden kann, bevor eine Variable definiert wird.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

Sie könnten einen try ... catch-Block wie folgt verwenden:

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

Ein Nachteil ist, dass Sie es nicht in eine Funktion einfügen können, da es einen ReferenceError auslösen würde

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))