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


Answers

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?

Question

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) {



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;



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"



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.




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

Oder besser

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

Funktioniert in allen Browsern




undefined, Boolean, String, Zahl, Funktion

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

}

Objekt, Array

if( foo instanceof Array ) { 

}



Ü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!




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.




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.




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
}



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.




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");
}



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
}



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: