JavaScript prüft ob Variable existiert (ist definiert / initialisiert)


Welche Methode zur Überprüfung, ob eine Variable initialisiert wurde, ist besser / richtig? (Angenommen die Variable könnte alles enthalten (string, int, object, function, etc.))

if (elem) { // or !elem

oder

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

oder

if (elem != null) {


Answers



Sie wollen den typeof Operators . Speziell:

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



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

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

Der Operator typeof 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 typeof null "object" typeof null . Wir müssen vorsichtig sein, um den Fehler zu vermeiden, eine Variable auf null initialisieren. Um sicherzugehen, könnten wir stattdessen Folgendes verwenden:

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

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




In JavaScript kann eine Variable definiert werden, die den Wert jedoch nicht undefined , sodass die häufigste Antwort technisch nicht korrekt ist. Stattdessen wird Folgendes ausgefü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 window ein Name für das globale Objekt ist). Aber wenn Sie mit Globals wie diesem herum mucking, sind Sie wahrscheinlich in einem Browser. Subjektiv ist die Verwendung von 'name' in window stilistisch konsistent mit der Verwendung von window.name , um auf globale window.name zu verweisen. Wenn Sie auf Globals als Eigenschaften von window statt als Variablen zugreifen, können Sie die Anzahl nicht deklarierter Variablen, auf die Sie in Ihrem Code verweisen (zum Vorteil von Linting), minimieren und vermeiden, dass Ihre globale Beschattung durch eine lokale Variable erfolgt. Wenn Globals Ihre Haut kriechen lassen, fühlen Sie sich wohler, wenn Sie sie nur mit diesem relativ langen Stick berühren.




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

elem != null

Im Gegensatz zu einem einfachen if (elem) erlaubt es 0 , false , NaN und '' , lehnt aber null oder undefined , was es zu einem guten allgemeinen Test für das Vorhandensein eines Arguments oder einer Eigenschaft eines Objekts macht.

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

  • if (elem) : kann verwendet werden, wenn elem garantiert ein Objekt ist, oder wenn false , 0 usw. als "Standard" -Werte betrachtet werden (daher gleichbedeutend mit undefined oder null ).

  • typeof elem == 'undefined' kann in Fällen verwendet werden, in denen eine angegebene null eine eindeutige Bedeutung zu einer nicht initialisierten Variablen oder Eigenschaft hat.

    • Dies ist die einzige Prüfung, die keinen Fehler elem wenn elem nicht deklariert ist (dh keine var elem , keine Eigenschaft von window oder kein Funktionsargument). Das ist meiner Meinung nach ziemlich gefährlich, da Tippfehler unbemerkt passieren können. Um dies zu vermeiden, lesen Sie die folgende Methode.

Auch nützlich ist ein strikter Vergleich gegen undefined :

if (elem === undefined) ...

Da das globale undefined jedoch mit einem anderen Wert überschrieben werden kann, empfiehlt es sich, die Variable vor der Verwendung im aktuellen Gültigkeitsbereich zu deklarieren:

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

Oder:

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

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




Wie überprüfe ich, ob eine Variable existiert

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

var setOrNot = typeof variable !== typeof undefined;

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

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

Probleme mit der Verkapselung

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

Sie könnten an etwas wie das denken:

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

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

Unbekannter ReferenceError: foo ist nicht definiert

Testen, ob Funktionsparameter undefiniert sind

Während unsere isset Funktion nicht verwendet werden kann, um zu testen, ob eine Variable existiert oder nicht (aus den oben erläuterten Gründen), erlaubt sie uns zu 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

Auch wenn kein Wert für y an den Funktionstest übergeben test , funktioniert unsere Funktion isset in diesem Zusammenhang perfekt, da y im Funktionstest als undefined Wert bekannt ist.




Überprüfen Sie, ob ein Objekt hasOwnProperty()

Eine Alternative zu den typeof Antworten ist die Verwendung von hasOwnProperty() die natürlich prüft, ob ein Objekt (so gut wie alles in JS) eine Eigenschaft hat, dh eine Variable (unter anderem).

Die Methode hasOwnProperty() gibt einen booleschen hasOwnProperty() zurück, der angibt, ob das Objekt die angegebene Eigenschaft als eigene (nicht geerbte) Eigenschaft hat.

Jedes Objekt, das von Object abstammt, erbt die hasOwnProperty() -Methode. Diese Methode kann verwendet werden, um zu bestimmen, ob ein Objekt die angegebene Eigenschaft als direkte Eigenschaft dieses Objekts hat. Anders als der Operator In überprüft diese Methode nicht die Prototypkette des Objekts.

// 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
    { foo: [], bar: 0 }.hasOwnProperty( "bar" ) // true
] );

Was toll an hasOwnProperty() ist, dass wir beim Aufruf keine Variable verwenden, die vielleicht noch undefiniert ist - was natürlich an erster Stelle das halbe Problem ist.

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




Es gibt einen anderen kurzen Weg, dies zu überprüfen, wenn Sie einfache Zuweisungen und zugehörige Prüfungen durchführen. Verwenden Sie einfach einen bedingten (ternären) Operator.

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

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

Wenn Sie überprüfen möchten, sollte die Variable nicht undefined oder null . Dann führen Sie unter Kontrolle durch.

Wenn die Variable deklariert ist und Sie den Wert überprüfen möchten, ist dies sogar einfach: Sie führt nicht undefined oder null zusammen aus.

var values = variable ? variable : '';



undefined, Boolean, String, Zahl, Funktion

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

}

Objekt, Array

if( foo instanceof Array ) { 

}



Es kommt darauf an, ob Sie sich nur darum kümmern, dass die Variable definiert wurde oder ob sie einen aussagekräftigen Wert haben soll.

Wenn Sie prüfen, ob der Typ nicht definiert ist, wird geprüft, ob die Variable bereits definiert wurde.

=== null oder !== null prüft nur, ob der Wert der Variablen genau null .

== null oder != null prüft, ob der Wert undefined oder null .

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




In vielen Fällen verwenden Sie:

if (elem) { // or !elem

wird die Arbeit für Sie erledigen ... dies wird diese folgenden Fälle überprüfen:

  1. undefined : wenn der Wert nicht definiert ist und undefined
  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 wird also eine Art aller Fälle abdecken, aber es gibt immer seltsame Fälle, die wir ebenfalls behandeln möchten, zum Beispiel eine Zeichenkette mit Leerzeichen, wie diese ' ' , diese wird in Javascript definiert, da sie Leerzeichen innerhalb der Zeichenkette hat. .. in diesem Fall fügen Sie einen weiteren Check mit trim () hinzu, wie:

if(elem) {

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

Ich erstelle auch das Bild unten, um eine kurze Zusammenfassung der Antwort zu zeigen:




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

Was ich jedoch darauf hinweisen wollte, war, dass JavaScript in undefined (aus einem gottlosen Grund) veränderbar ist. Also einfach eine Prüfung für varName !== undefined hat das Potential, nicht immer so zurückzukehren, wie Sie es erwarten, da sich andere Bibliotheken undefiniert geändert haben könnten. Ein paar Antworten (zum Beispiel Skalee's) scheinen es vorzuziehen, typeof nicht zu verwenden, und das könnte einen in Schwierigkeiten bringen.

Der "alte" Weg, dies zu behandeln, wurde als undefiniert deklariert, um ein mögliches Muting / Overriding von undefined zu kompensieren. Der beste Weg ist jedoch immer noch, typeof zu verwenden, da es das Überschreiben von undefined von anderem Code ignoriert. Vor allem, wenn Sie Code für den Einsatz in freier Wildbahn schreiben, wer weiß, was sonst noch auf der Seite laufen könnte ...




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

Oder besser

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

Funktioniert in allen Browsern




Es ist schwierig, zwischen undefined 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. Undefined ist ein spezieller Wert, der der Standardwert von nicht zugewiesenen Variablen sein wird.


var _undefined;
var _null = null;

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




Das robusteste 'ist es definiert' Check ist mit typeof

if (typeof elem === 'undefined')

Wenn Sie nur nach einer definierten Variablen suchen, um eine Vorgabe zuzuweisen, können Sie dies für eine einfach zu lesende Zwischenlage oft tun:

elem = elem || defaultElem;

Es ist oft gut zu benutzen, siehe: Idiomatische Art, Standardwert in Javascript zu setzen

Es gibt auch diesen einen Liner mit dem Typ des Schlüsselworts:

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



Sie können den Operator typeof .

Beispielsweise,

var dataSet;

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

Das obige Code-Snippet gibt die Ausgabe wie

Variable dataSet ist: undefiniert.




Null ist ein Wert in JavaScript und typeof null gibt "object"

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

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



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

Angenommen, ich brauche meinen variableName; um einen undefined Wert zu tragen, und daher wurde er auf eine Weise deklariert wie zum Beispiel var variableName; was bedeutet, dass es bereits initialisiert ist ; - Wie überprüfe ich, ob es bereits deklariert ist?

Oder noch besser - wie prüfe ich sofort, ob "Book1.chapter22.paragraph37" mit einem einzigen Aufruf existiert, aber keinen Referenzfehler?

Wir machen es mit dem leistungsfähigsten JasvaScript-Operator, dem in- Operator:

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

In Zeiten von AJAX Peaking Popularität habe ich eine Methode geschrieben (später benannt) isNS (), die in der Lage ist zu bestimmen, ob der Namespace existiert einschließlich Deep Tests für Eigenschaftsnamen wie "Book1.chapter22.paragraph37" und vieles mehr.

Aber da es bereits veröffentlicht wurde und wegen seiner großen Wichtigkeit es verdient, in einem separaten Thread veröffentlicht zu werden, werde ich es hier nicht veröffentlichen, sondern Schlüsselwörter liefern ( javascript + isNS ), die Ihnen helfen werden, den Quellcode zu finden. notwendige Erklärungen.




In der besonderen Situation in der Frage,

typeof window.console === "undefined"

ist identisch mit

window.console === undefined

Ich bevorzuge letzteres, da es kürzer ist.

Bitte beachten Sie, dass wir nur im globalen Umfang nach console suchen (in allen Browsern ein window ). In dieser speziellen Situation ist es wünschenswert. Wir möchten nicht, dass die console anderer Stelle definiert wird.

@BrianKelley erklärt in seiner tollen Antwort technische Details. Ich habe nur fehlende Schlussfolgerung hinzugefügt und es in etwas leichter zu lesen verdaut.




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

Wie auch immer Sie sich entscheiden, erwägen Sie den Check in eine Funktion wie

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

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

Wo Sie wissen, dass die Variable deklariert ist, aber möglicherweise nicht existiert, könnten Sie

existy(elem) && doSomething(elem);

Die Variable, die Sie überprüfen, kann manchmal eine geschachtelte Eigenschaft sein. Du kannst Prop verwenden || {} um die Zeile zu überprüfen, die die Existenz der betreffenden Eigenschaft überprüft:

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 existy(o) && existy(op) && existy(opq) && doSomething(opq)




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

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

(Dort ist keine strikte Gleichheit erforderlich, da typeof immer eine Zeichenfolge zurückgibt.) Wenn Sie jedoch Argumente für eine Funktion haben, die übergeben wurde oder nicht, werden sie immer definiert, aber null, wenn sie weggelassen wird.

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



Um zu der Debatte beizutragen, wenn ich weiß, dass die Variable eine Zeichenkette oder ein Objekt sein sollte, bevorzuge ich immer if (!variable) , also überprüfe ob es falsch ist. Dies kann zu mehr sauberem Code führen, 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); 
}

..könnte reduziert werden auf:

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



Ich verwende je nach Objekt zwei verschiedene Möglichkeiten.

if( !variable ){
  // variable is either
  // 1. empty string i.e. '';
  // 2. Integer 0;
  // 3. undefined;
  // 4. null;
}

Manchmal möchte ich keine leere Zeichenkette als False bewerten, also 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, dann wird in der ersten Instanz! Variable zu !! Variable und in der ungültigen Funktion === werden! = Und die Funktionsnamen werden zu notInvalid.




Ein bisschen funktioneller und einfacher zu bedienen:

function exist(obj)
{
    return (typeof obj !== 'undefined');
}

Die Funktion gibt true zurück, falls vorhanden, andernfalls false, wenn sie nicht existiert.




Wenn Sie möchten, dass der definierte Block etwas

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

Wenn Sie möchten, dass ein nicht definierter Block etwas tut oder die Variable zuweist oder definiert, verwenden Sie diese

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



Was ist mit einem einfachen:

if(!!variable){
  //the variable is defined
}



Um zu überprüfen, ob eine Variable deklariert / gesetzt wurde, habe ich diesen dreckigen 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");
}



Unsicher, ob dies helfen wird, musste ich überprüfen, ob ein Var, der auf der Seite definiert wurde, abgeholt wurde, bevor die entsprechenden Skripte ausgeführt wurden, und das Folgende funktionierte für mich gut.

if (window.myvar) { // run scripts here }

Es ist ein bisschen einfach, aber gut für One-Offs oder dergleichen.




Ich kann das in den obigen Antworten nicht sehen, also schlage ich es hier vor.

function isDefined(x) { return !!x }

if( isDefined(x) ) {
    //The variable is defined
}

! x gibt true zurück iff x ist entweder null oder undefiniert , also !! x gibt nur dann true zurück, wenn x weder undefiniert noch null ist.

Mir ist klar, dass dies auch für den Nullfall spricht, aber hier ist eine angemessene Warnung.