Wie kann ich in JavaScript nach einer undefinierten oder Null-Variablen suchen?

In unserem JavaScript-Code verwenden wir häufig das folgende Codemuster

if (typeof(some_variable) != 'undefined' && some_variable != null)
{
    // Do something with some_variable
}

Gibt es eine weniger ausführliche Methode zur Überprüfung, die den gleichen Effekt hat?

Nach einigen Foren und Literatur sollte einfach das Folgende den gleichen Effekt haben.

if (some_variable)
{
    // Do something with some_variable
}

Leider wertet Firebug eine solche Anweisung als Fehler zur Laufzeit aus, wenn sie nicht some_variabledefiniert ist, während die erste für sie in Ordnung ist. Ist dies nur ein (unerwünschtes) Verhalten von Firebug oder gibt es wirklich einen Unterschied zwischen diesen beiden Möglichkeiten?

Sie müssen zwischen Fällen unterscheiden:

1. Variablen können deklariertundefined oder nicht deklariert sein . Sie erhalten eine Fehlermeldung, wenn Sie in einem anderen Kontext als auf eine nicht deklarierte Variable zugreifen typeof.

if(typeof someUndeclaredVar == whatever) // works
if(someUndeclaredVar) // throws error

Eine Variable, die deklariert, aber nicht initialisiert wurde, ist undefined.

let foo;
if (foo) //evaluates to false because foo === undefined

2. Undefinierte Eigenschaften , wie someExistingObj.someUndefProperty. Eine undefinierte Eigenschaft gibt keinen Fehler aus und gibt einfach zurück undefined, was bei der Konvertierung in einen Booleschen Wert ausgewertet wird false. Wenn Sie sich also nicht für 0und interessieren false, ist die Verwendung if(obj.undefProp)in Ordnung. Es gibt eine gemeinsame Redewendung, die auf dieser Tatsache basiert:

   value = obj.prop || defaultValue

   Dies bedeutet "Wenn objdie Eigenschaft vorhanden ist prop, weisen Sie sie zu value, andernfalls weisen Sie den Standardwert zu defautValue".

   Einige Leute halten dieses Verhalten für verwirrend und argumentieren, dass es zu schwer zu findenden Fehlern führt, und empfehlen stattdessen die Verwendung des inOperators

   value = ('prop' in obj) ? obj.prop : defaultValue

Ich denke, der effizienteste Weg, um auf "Wert ist nulloder undefined" zu testen, ist

if ( some_variable == null ){
  // some_variable is either null or undefined
}

Diese beiden Zeilen sind also äquivalent:

if ( typeof(some_variable) !== "undefined" && some_variable !== null ) {}
if ( some_variable != null ) {}

Anmerkung 1

Wie in der Frage erwähnt, erfordert die kurze Variante, dass some_variabledeklariert wurde, andernfalls wird ein ReferenceError ausgelöst. In vielen Anwendungsfällen können Sie jedoch davon ausgehen, dass dies sicher ist:

Suchen Sie nach optionalen Argumenten:

function(foo){
    if( foo == null ) {...}

Suchen Sie nach Eigenschaften für ein vorhandenes Objekt

if(my_obj.foo == null) {...}

Auf der anderen Seite typeofkönnen nicht deklarierte globale Variablen behandelt werden (gibt einfach zurück undefined). Diese Fälle sollten jedoch aus guten Gründen auf ein Minimum reduziert werden, wie Alsciende erklärte.

Anmerkung 2

Diese - noch kürzere - Variante ist nicht gleichwertig:

if ( !some_variable ) {
  // some_variable is either null, undefined, 0, NaN, false, or an empty string
}

damit

if ( some_variable ) {
  // we don't get here if some_variable is null, undefined, 0, NaN, false, or ""
}

Notiz 3

Im Allgemeinen wird empfohlen, ===anstelle von zu verwenden ==. Die vorgeschlagene Lösung ist eine Ausnahme von dieser Regel. Die JSHint-Syntaxprüfung bietet eqnullaus diesem Grund sogar die Option.

Aus dem jQuery-Styleguide :

Strenge Gleichheitsprüfungen (===) sollten zugunsten von == verwendet werden. Die einzige Ausnahme ist die Überprüfung auf undefiniert und null über null.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

Wenn Sie null mit normaler Gleichheit aktivieren, wird auch true für undefined zurückgegeben.

if (window.variable == null) alert('variable is null or undefined');

In neueren JavaScript-Standards wie ES5 und ES6 kann man nur sagen

> Boolean(0) //false
> Boolean(null)  //false
> Boolean(undefined) //false

Alle geben false zurück, ähnlich wie Pythons Überprüfung leerer Variablen. Wenn Sie also eine bedingte Logik um eine Variable schreiben möchten, sagen Sie einfach

if (Boolean(myvar)){
   // Do something
}

hier wird "null" oder "leere Zeichenfolge" oder "undefiniert" effizient behandelt.

Wenn Sie versuchen, auf eine nicht deklarierte Variable zu verweisen, wird in allen JavaScript-Implementierungen ein Fehler ausgegeben.

Eigenschaften von Objekten unterliegen nicht denselben Bedingungen. Wenn keine Objekteigenschaft definiert wurde, wird kein Fehler ausgegeben, wenn Sie versuchen, darauf zuzugreifen. In dieser Situation könnten Sie also verkürzen:

 if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null)

zu

if (myObj.some_property != null)

Vor diesem Hintergrund und angesichts der Tatsache, dass auf globale Variablen als Eigenschaften des globalen Objekts zugegriffen werden kann ( windowim Fall eines Browsers), können Sie für globale Variablen Folgendes verwenden:

if (window.some_variable != null) {
    // Do something with some_variable
}

In lokalen Bereichen ist es immer nützlich, sicherzustellen, dass Variablen oben in Ihrem Codeblock deklariert sind. Dies spart bei wiederkehrenden Verwendungen von typeof.

Zunächst muss klar sein, was Sie testen. JavaScript bietet alle möglichen impliziten Konvertierungen und zwei verschiedene Arten von Gleichstellungskomparatoren: ==und ===.

Eine Funktion, die folgende Eigenschaften test(val)testet nulloder haben undefinedsollte:

 test(null)         => true
 test(undefined)    => true
 test(0)            => false
 test(1)            => false
 test(true)         => false
 test(false)        => false
 test('s')          => false
 test([])           => false

Mal sehen, welche der Ideen hier tatsächlich unseren Test bestehen.

Diese Arbeit:

val == null
val === null || val === undefined
typeof(val) == 'undefined' || val == null
typeof(val) === 'undefined' || val === null

Diese funktionieren nicht:

typeof(val) === 'undefined'
!!val

Ich habe einen jsperf-Eintrag erstellt, um die Richtigkeit und Leistung dieser Ansätze zu vergleichen . Die Ergebnisse sind vorerst nicht schlüssig, da auf verschiedenen Browsern / Plattformen nicht genügend Läufe durchgeführt wurden. Bitte nehmen Sie sich eine Minute Zeit, um den Test auf Ihrem Computer auszuführen!

Derzeit scheint der einfache val == nullTest die beste Leistung zu liefern. Es ist auch so ziemlich das kürzeste. Der Test kann negiert werden, val != nullwenn Sie die Ergänzung wünschen.

Dies ist der einzige Fall, in dem ==verwendet werden sollte:

if (val == null) console.log('val is null or undefined')

Da es keine vollständige und korrekte Antwort gibt, werde ich versuchen, Folgendes zusammenzufassen:

Im Allgemeinen ist der Ausdruck:

if (typeof(variable) != "undefined" && variable != null)

kann nicht vereinfacht werden, da das variablemöglicherweise nicht deklariert ist, so dass das Weglassen des typeof(variable) != "undefined"zu ReferenceError führen würde. Aber, können Sie den Ausdruck entsprechend dem Kontext vereinfachen :

Wenn das variableist global , können Sie vereinfachen:

if (window.variable != null)

Wenn es lokal ist , können Sie wahrscheinlich Situationen vermeiden, in denen diese Variable nicht deklariert ist, und auch vereinfachen, um:

if (variable != null)

Wenn es sich um eine Objekteigenschaft handelt , müssen Sie sich keine Gedanken über ReferenceError machen:

if (obj.property != null)

Sie können einfach überprüfen, ob die Variable einen Wert hat oder nicht. Bedeutung,

if( myVariable ) {
//mayVariable is not :
//null
//undefined
//NaN
//empty string ("")
//0
//false

}

Wenn Sie nicht wissen, ob eine Variable vorhanden ist (dh wenn sie deklariert wurde), wenden Sie sich an den Operator typeof. z.B

if( typeof myVariable !== 'undefined' ) {
    // myVariable will get resolved and it is defined
}

Ich habe dies mit dieser Methode gemacht

Speichern Sie die ID in einer Variablen

var someVariable = document.getElementById("someId");

Verwenden Sie dann die if-Bedingung

if(someVariable === ""){
 //logic
} else if(someVariable !== ""){
 //logic
}

Wie in einer der Antworten erwähnt, können Sie Glück haben, wenn Sie über eine Variable mit globalem Geltungsbereich sprechen. Wie Sie vielleicht wissen, werden die Variablen, die Sie global definieren, dem Windows-Objekt hinzugefügt. Sie können diese Tatsache ausnutzen. Nehmen wir also an, Sie greifen auf eine Variable namens bleh zu. Verwenden Sie einfach den doppelt invertierten Operator (!!).

!!window['bleh'];

Dies würde ein false zurückgeben, solange bleh nicht deklariert wurde UND ein Wert zugewiesen wurde.

Hier ist eine andere Möglichkeit, die Array include () -Methode zu verwenden:

[undefined, null].includes(value)

Dies ist ein Beispiel für eine sehr seltene Gelegenheit, bei der empfohlen wird, ==anstelle von zu verwenden ===. Der Ausdruck somevar == nullgibt für undefinedund true zurück null, für alles andere jedoch false (ein Fehler, wenn die Variable nicht deklariert ist).

Mit dem !=wird das Ergebnis wie erwartet umgedreht.

Moderne Editoren warnen nicht vor der Verwendung ==oder dem !=Bediener null, da dies fast immer das gewünschte Verhalten ist.

Häufigste Vergleiche:

undeffinedVar == null     // true
obj.undefinedProp == null // true
null == null              // true
0 == null                 // false
'0' == null               // false
'' == null                // false

Versuch es selber:

let undefinedVar;
console.table([
    { test : undefinedVar,     result: undefinedVar     == null },
    { test : {}.undefinedProp, result: {}.undefinedProp == null },
    { test : null,             result: null             == null },
    { test : false,            result: false            == null },
    { test : 0,                result: 0                == null },
    { test : '',               result: ''               == null },
    { test : '0',              result: '0'              == null },
]);

Was auch immer yyy undefiniert oder null ist, es wird true zurückgeben

if (typeof yyy == 'undefined' || !yyy) {
    console.log('yes');
} else {
    console.log('no');
}

Ja

if (!(typeof yyy == 'undefined' || !yyy)) {
    console.log('yes');
} else {
    console.log('no');
}

Nein

Öffnen Sie die Entwicklertools in Ihrem Browser und probieren Sie einfach den im folgenden Bild gezeigten Code aus.

Um dies zu verstehen, analysieren wir, welchen Wert die Javascript Engine beim Konvertieren von undefined, null und '' (auch eine leere Zeichenfolge) zurückgibt. Sie können dies direkt auf Ihrer Entwicklerkonsole überprüfen.

Sie können sehen, dass alle in falsch konvertieren, was bedeutet, dass alle diese drei von Javascript ausgehen, dass es keine Existenz gibt. Sie müssen also nicht alle drei in Ihrem Code wie unten explizit überprüfen.

if (a === undefined || a === null || a==='') {
    console.log("Nothing");
} else {
    console.log("Something");
}

Ich möchte noch auf eine Sache hinweisen.

Was ist das Ergebnis von Boolean (0)?

Natürlich falsch. Dies führt zu einem Fehler in Ihrem Code, wenn 0 ein gültiger Wert in Ihrem erwarteten Ergebnis ist. Stellen Sie daher sicher, dass Sie dies überprüfen, wenn Sie den Code schreiben.

Ähnlich wie bei dem, was Sie haben, könnten Sie so etwas tun

if (some_variable === undefined || some_variable === null) { do stuff }

Das Testen von nullity ( if (value == null)) oder non-nullity ( if (value != null)) ist weniger ausführlich als das Testen des Definitionsstatus einer Variablen.

Darüber hinaus schlägt das Testen if (value)(oder if( obj.property)), um sicherzustellen, dass Ihre Variable (oder Objekteigenschaft) vorhanden ist, fehl, wenn sie mit einem booleschen falseWert definiert ist. Vorbehalt Emptor :)

Beide Werte können mit dem strengen Vergleichsoperator leicht unterschieden werden:

Arbeitsbeispiel bei:

http://www.thesstech.com/tryme?filename=nullandundefined

Beispielcode:

function compare(){
    var a = null; //variable assigned null value
    var b;  // undefined
    if (a === b){
        document.write("a and b have same datatype.");
    }
    else{
        document.write("a and b have different datatype.");
    }   
}

Wenn der Zweck der if-Anweisung darin besteht, vor dem Zuweisen eines Werts zu einer Variablen nach nulloder nach undefinedWerten zu suchen , können Sie den Nullish Coalescing Operator verwenden , der schließlich in JavaScript verfügbar ist, obwohl die Browserunterstützung eingeschränkt ist. Nach Angaben von caniuse werden nur 48,34% der Browser unterstützt (Stand April 2020).

const a = some_variable ?? '';

Dadurch wird sichergestellt , dass die Variable auf eine leere Zeichenfolge zugewiesen wird (oder einem anderen Standardwert) , wenn some_variableist nulloder undefined.

Dieser Operator eignet sich am besten für Ihren Anwendungsfall, da er nicht den Standardwert für andere Arten von Falschwerten wie 0und zurückgibt ''.

Sie müssen eine Funktion dieses Formulars definieren:

validate = function(some_variable){
    return(typeof(some_variable) != 'undefined' && some_variable != null)
}

Wenn Sie es in ES5 oder ES6 mehrmals überprüfen müssen, müssen Sie Folgendes tun:

const excluded = [null, undefined, ''];

if (!exluded.includes(varToCheck) {
  // it will bee not null, not undefined and not void string
}

Mit Ramda können Sie einfach R.isNil(yourValue) Lodash ausführen und andere Hilfsbibliotheken haben dieselbe Funktion.