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


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

if (elem) { // or !elem

oder

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

oder

if (elem != null) {

1281
2018-02-25 03:44


Ursprung


Antworten:


Sie wollen das typeof Operator. Speziell:

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

2502
2018-02-06 04:56



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

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

Das typeof Operator, im Gegensatz zu den anderen Betreibern, wirft keine Referenzfehler Ausnahme bei Verwendung einer nicht deklarierten Variablen.

Beachten Sie das jedoch typeof null wird zurückkehren "object". Wir müssen vorsichtig sein, um den Fehler zu vermeiden, eine Variable zu initialisieren null. Um sicherzugehen, können wir stattdessen Folgendes verwenden:

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

Für weitere Informationen über den strikten Vergleich === anstelle von einfacher Gleichheit ==, sehen:
Welcher Gleichheitsoperator (== vs ===) sollte in JavaScript-Vergleichen verwendet werden?


691
2018-06-28 16:00



In JavaScript kann eine Variable definiert werden, aber den Wert beibehalten undefinedDaher ist die gebräuchlichste Antwort technisch nicht korrekt und führt stattdessen Folgendes aus:

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 (wo window ist ein Name für das globale Objekt). Aber wenn du mit solchen Globalen herumkommst, bist du wahrscheinlich in einem Browser. Subjektiv, mit 'name' in window ist stilistisch konsistent mit der Verwendung window.name sich auf Globals beziehen. Zugriff auf Globals als Eigenschaften von window anstatt als Variablen können Sie die Anzahl nicht deklarierter Variablen minimieren, die Sie in Ihrem Code referenzieren (zum Vorteil von Linting), und vermeiden, dass Ihr Global durch eine lokale Variable beschattet wird. Auch wenn Globals Ihre Haut krabbeln lassen, fühlen Sie sich vielleicht bequemer, sie nur mit diesem relativ langen Stock zu berühren.


182
2017-10-22 15:47



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

elem != null

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


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

  • if (elem): Kann verwendet werden, wenn elem ist garantiert ein Objekt, oder wenn false, 0usw. gelten als "Standardwerte" (also äquivalent zu undefined oder null).

  • typeof elem == 'undefined' Kann in Fällen verwendet werden, in denen angegeben ist null hat eine eindeutige Bedeutung für eine nicht initialisierte Variable oder Eigenschaft.

    • Dies ist die einzige Überprüfung, die Es wird kein Fehler ausgegeben ob elem ist nicht erklärt (d.h. nein var Aussage, keine Eigenschaft von windowoder kein Funktionsargument). Das ist meiner Meinung nach ziemlich gefährlich, da Tippfehler dadurch unbemerkt verschwinden können. Um dies zu vermeiden, sehen Sie sich die folgende Methode an.

Sinnvoll ist auch ein strenger Vergleich gegen undefined:

if (elem === undefined) ...

Weil das globale undefinedkann mit einem anderen Wert überschrieben werden, ist es am besten, die Variable zu deklarieren undefined im aktuellen Umfang vor der Verwendung:

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

Oder:

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

Ein sekundärer Vorteil dieser Methode ist, dass JS-Minifier das reduzieren können undefined Variable zu einem einzelnen Zeichen, speichern Sie jedes Mal ein paar Bytes.


112
2018-02-25 03:48



In vielen Fällen verwenden Sie:

if (elem) { // or !elem

macht die Arbeit für Sie! ... das wird diese folgenden Fälle überprüfen:

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

Es wird also alle Fälle abdecken, aber es gibt immer seltsame Fälle, die wir ebenfalls behandeln möchten, zum Beispiel eine Zeichenfolge mit Leerzeichen ' ' ein, das wird in Javascript definiert, da es Leerzeichen innerhalb von String hat ... zum Beispiel fügen Sie in diesem Fall einen weiteren Check mit trim () hinzu, wie:

if(elem) {

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

Auch diese Überprüfungen sind für Werte Nur, da Objekte und Arrays in Javascript anders arbeiten, leeres Array [] und leeres Objekt {} sind immer wahr.

Ich erstelle das Bild unten, um eine kurze Beschreibung der Antwort anzuzeigen:

undefined, null, etc


80
2017-09-01 06:15



Wie überprüft man, 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ärer Betreiber um einen Standardwert 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 Check nicht einfach in eine Funktion kapseln.

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 zB anrufen. isset(foo) und variabel foo wurde nicht definiert, weil Sie eine nicht existierende Variable nicht an eine Funktion übergeben können:

Uncaught ReferenceError: foo ist nicht definiert


Testen, ob Funktionsparameter nicht definiert sind

Während unserer isset Funktion kann nicht verwendet werden, um zu testen, ob eine Variable existiert oder nicht (aus Gründen, die oben erläutert wurden), erlaubt es uns zu testen, ob die Parameter einer Funktion nicht definiert 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 y wird weitergegeben, um zu funktionieren test, unser isset Funktion funktioniert in diesem Zusammenhang perfekt, weil y ist in Funktion bekannt test als undefined Wert.


59
2018-02-19 11:54



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

Eine Alternative zu der Fülle von typeof Antworten, ist die Verwendung von hasOwnProperty() was natürlich überprüft, ob ein Objekt (so ziemlich alles in JS) eine Eigenschaft hat d.h. eine Variable (unter anderem).

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

Jedes Objekt stammt von Objekt erbt die hasOwnProperty() Methode. Diese Methode kann verwendet werden, um zu bestimmen, ob ein Objekt die angegebene Eigenschaft als direkte Eigenschaft dieses Objekts besitzt. im Gegensatz zu den im Operator ü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 ist großartig? hasOwnProperty() Wenn wir es nennen, verwenden wir keine Variable, die noch undefiniert sein könnte - was natürlich das halbe Problem ist.

Obwohl nicht immer das perfekt oder Ideal Lösung, unter bestimmten Umständen ist es nur der Job!


42
2018-05-02 14:07



Es gibt eine weitere Möglichkeit, dies zu überprüfen, wenn Sie einfache Zuweisungen und damit verbundene Prüfungen durchführen. Einfach benutzen Bedingter (ternärer) 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 du die Variable überprüfen willst, sollte das nicht sein undefined oder null. Führen Sie dann die folgende Überprüfung durch.

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

var values = variable ? variable : '';

38
2018-02-19 05:26



undefined, Boolean, String, Zahl, Funktion

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

}

Objekt, Array

if( foo instanceof Array ) { 

}

27
2017-07-26 02:08