Gibt es eine Standardfunktion, um in JavaScript nach null, undefinierten oder leeren Variablen zu suchen?

2260

Gibt es eine universelle JavaScript-Funktion, die überprüft, ob eine Variable einen Wert hat und ob dies nicht der Fall ist undefinedoder null? Ich habe diesen Code, bin mir aber nicht sicher, ob er alle Fälle abdeckt:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}
Alex
quelle
5
Mögliches Duplikat von Wie prüft man in JavaScript, ob eine Zeichenfolge leer ist?
Dour High Arch
78
Protip, niemals (truthy statement) ? true : false;. Tu es einfach (truthy statement);.
David Baucum
5
@GeorgeJempty kein Dup, da die andere Antwort insbesondere nach Strings fragt , während diese nach Variablen fragt .
Madbreaks
2
Jede richtige Antwort auf diese Frage hängt ganz davon ab, wie Sie "leer" definieren.
Madbreaks
3
@ Jay Es tut nichts weh, was die Ausführung Ihres Codes betrifft. Es ist einfach zu ausführlich. Sie würden nicht sagen: "Sind Sie hungrig, ist wahr?" Sie nur "Sind Sie hungrig" Also sagen Sie im Code einfach if (hungry) …statt if (hungry === true) …. Wie bei allen Codierungsvorgängen auf diese Weise ist es nur Geschmackssache. Genauer gesagt zu dem Beispiel des OP sagt er noch ausführlicher: "Wenn es wahr ist, dann wahr, wenn nicht falsch". Aber wenn es wahr ist, dann ist es bereits wahr. Und wenn es falsch ist, ist es bereits falsch. Dies ist vergleichbar mit der Aussage: "Wenn Sie hungrig sind, sind Sie es, und wenn nicht, sind Sie es nicht."
David Baucum

Antworten:

4379

Sie können einfach überprüfen, ob die Variable einen truthyWert hat oder nicht. Das bedeutet

if( value ) {
}

wird zu bewerten , truewenn valueist nicht :

  • Null
  • nicht definiert
  • NaN
  • leerer String ("")
  • 0
  • falsch

Die obige Liste enthält alle möglichen falsyWerte in ECMA- / Javascript. Finden Sie es in der Spezifikation im ToBooleanAbschnitt.

Wenn Sie nicht wissen, ob eine Variable vorhanden ist (dh wenn sie deklariert wurde ), sollten Sie sich beim typeofOperator erkundigen. Zum Beispiel

if( typeof foo !== 'undefined' ) {
    // foo could get resolved and it's defined
}

Wenn Sie sicher sein können, dass mindestens eine Variable deklariert ist, sollten Sie direkt prüfen, ob sie einen truthyWert wie oben gezeigt hat.

Lesen Sie weiter: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

jAndy
quelle
110
Was ist, wenn der Wert ein falscher Boolescher Wert ist, der beabsichtigt war? Manchmal möchten Sie einen Standardwert
angeben,
100
@ TruMan1: In einem solchen Fall (in dem Ihre Logik die Validierung vorschreibt) müssen Sie wie folgt vorgehen if( value || value === false ). Gleiches gilt für alle falschen Werte , die wir explizit validieren müssen.
jAndy
28
Außer wenn value ein Array ist. Die Interpretation von truthykönnte irreführend sein. In diesem Fall sollten wir value.length != 0nach einem nicht leeren Array suchen.
Benutzer
12
Ich möchte nur hinzufügen, dass Sie ifden ternären Operator verwenden können, wenn Sie der Meinung sind, dass das Konstrukt syntaktisch zu schwer ist : var result = undefined ? "truthy" : "falsy". Oder wenn Sie nur auf einen Booleschen Wert zu zwingen wollen, verwenden Sie den !!Operator, zum Beispiel !!1 // true, !!null // false.
KFL
7
Beachten Sie auch, dass dies nicht nach Zeichenfolgen sucht, die nur Leerzeichen enthalten.
Christophe Roussy
222

Die ausführliche Methode zum Überprüfen, ob der Wert undefiniert oder null ist, lautet:

return value === undefined || value === null;

Sie können auch den ==Operator verwenden, dies setzt jedoch voraus, dass alle Regeln bekannt sind :

return value == null; // also returns true if value is undefined
Salman A.
quelle
33
Nur prüfen nulloder undefinedkann so erfolgen : if (value == null). ==Achten Sie auf den Operator, der zwingt. Wenn Sie dies überprüfen if (value === null || value === undefined), haben Sie vergessen / wissen nicht, wie Javascript zwingt. webreflection.blogspot.nl/2010/10/…
Christiaan Westerbeek
32
@ChristiaanWesterbeek: Ihr Punkt, der arg == nulldie gleichen Ergebnisse liefert wie arg === undefined || arg === null. Ich halte das letztere Beispiel jedoch für lesbarer.
Salman A
10
arg == nullist meiner Erfahrung nach ziemlich häufig.
Bryan Downing
8
return value === (void 0)ist sicherer als das Testen, gegen undefineddas leider eine legitime Variable im Umfang sein kann.
x0n
4
@ Sharky Es gibt einen Unterschied zwischen einer Variablen, die nicht definiert ist, und einer nicht deklarierten Variablen: lucybain.com/blog/2014/null-undefined-undeclared
Christiaan Westerbeek
80
function isEmpty(value){
  return (value == null || value.length === 0);
}

Dies wird true für zurückgeben

undefined  // Because undefined == null

null

[]

""

und Nullargumentfunktionen, da eine Funktion lengthdie Anzahl der deklarierten Parameter ist, die sie benötigt.

Um die letztere Kategorie nicht zuzulassen, möchten Sie möglicherweise nur nach leeren Zeichenfolgen suchen

function isEmpty(value){
  return (value == null || value === '');
}
Mike Samuel
quelle
7
undefined == nullaberundefined !== null
Ian Boyd
2
@ IanBoyd, weil Sie == mit === vergleichen. Dies bedeutet, dass undefined == null (true) undefined! = null (false) undefined === null (false) undefined! == null (true) besser wäre, ein bisschen mehr Informationen zu geben, um hilfreich zu sein und Leute anzutreiben in die richtige Richtung. Moz Doc über den Unterschied Developer.mozilla.org/en-US/docs/Web/JavaScript/…
Corey Young
43

Dies ist der sicherste Scheck und ich habe ihn hier nicht genau so gesehen:

if (typeof value !== 'undefined' && value) {
    //deal with value'
};

Es werden Fälle behandelt, in denen der Wert nie definiert wurde, und auch eine der folgenden:

  • Null
  • undefined (der Wert von undefined ist nicht der gleiche wie ein Parameter, der nie definiert wurde)
  • 0
  • "" (leerer String)
  • falsch
  • NaN

Bearbeitet: Geändert zu strikter Gleichheit (! ==), weil es mittlerweile die Norm ist;)

Guya
quelle
10
Ich habe nicht abgelehnt, aber im Hinblick auf einen strengen Gleichheitsvergleich gilt die allgemeine Regel, dass ein strikter Vergleich verwendet werden sollte , es sei denn, Sie benötigen eine implizite Typkonvertierung.
J.Steve
2
Vielen Dank für Ihren Kommentar Steve. Diese allgemeine Regel ist in Ordnung. Ich erwarte nur, dass die Leute verstehen, warum sie das eine oder andere benutzen. Jede Art, wie du aussiehst, wird ppl gerne über "immer immer streng verwenden" predigen - als wäre es das Wichtigste in Javascript. Ich habe zu viele Fälle wie if (val! == null) gesehen, die offensichtlich zu einem unerwünschten Ergebnis führen. Es ist in Ordnung zu sagen, dass Sie im Zweifelsfall streng sind, aber es ist besser, nicht im Zweifel zu sein.
Guya
6
Ich denke, der Punkt hier ist, dass wir erwarten, dass der typeofOperator eine Zeichenfolge zurückgibt, sodass die Verwendung der strengen Gleichheitsprüfung technisch genauer, spezifischer und schneller ist. Es gibt also wirklich keinen Grund, den losen Vergleich zu verwenden, nicht umgekehrt. Auch val !== nullist in vielen Fällen vollkommen gültig - ich mache es die ganze Zeit. Ich stimme Ihrem Argument der Nichtkonformität zu, aber ich denke, dies ist ein schlechtes Beispiel dafür. Ich versuche nicht, dich zu trollen.
Bryan Downing
Vielen Dank für Ihren Kommentar Bryan, Sie verwenden val! == null, weil Sie wissen, was Sie tun. Ein Anfänger möchte einen Rückfall haben, wenn val falsch ist. Aber val wird niemals null sein, es wird undefiniert sein. Wenn er nur nicht auf diesen Rat gehört hätte, „immer streng zu verwenden“, hätte er weniger Fehler. Ich habe gesehen, dass dies im Produktionscode passiert. typeof gibt immer einen String zurück und der Geschwindigkeitsunterschied ist redundant. Das einzige Argument für die Verwendung von strict im obigen Fall ist die Konsistenz. Ich habe gesagt: "Keine Notwendigkeit für strikte Gleichheit". Dies bedeutet nicht, dass Sie dies nicht können, wenn Sie möchten oder wenn Ihr Code dadurch konsistenter wird.
Guya
28

Die folgende Funktion kann hilfreich sein:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

Oder in ES7 (Kommentar bei weiteren Verbesserungen)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

Ergebnisse:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

"Beachten Sie, dass der Bindungsoperator (: :) weder Teil von ES2016 (ES7) noch einer späteren Ausgabe des ECMAScript-Standards ist. Derzeit handelt es sich um einen Vorschlag der Stufe 0 (Strawman) für die Einführung in die Sprache." - Simon Kjellberg. Der Autor möchte seine Unterstützung für diesen schönen Vorschlag zum königlichen Aufstieg hinzufügen.

Vix
quelle
+1 Es ist hilfreich, das Objekt vom Typ 'Regexp' , 'Array' und 'Funktion' zu kennen
Yash
@Vix, warum ist die ES7-Version besser?
GollyJer
Es wurde nicht mit besser lesbaren Methoden experimentiert, um dieselbe Funktionalität auszudrücken, indem Folgendes verwendet wurde: Zuweisung zerstören, Operator binden.
Vix
2
Beachten Sie, dass der Bindungsoperator ( ::) weder Teil von ES2016 (ES7) noch eine spätere Ausgabe des ECMAScript-Standards ist. Derzeit handelt es sich um einen Vorschlag der Stufe 0 (Strawman) für die Einführung in die Sprache.
Simon Kjellberg
25

Die erste Antwort mit der besten Bewertung ist falsch. Wenn der Wert undefiniert ist, wird in modernen Browsern eine Ausnahme ausgelöst. Sie müssen verwenden:

if (typeof(value) !== "undefined" && value)

oder

if (typeof value  !== "undefined" && value)
krupar
quelle
3
eee ... Ich denke, das ist falsch, als ob (Wert) ausreichend ist (außer leere Objekte / Arrays). Wenn der Wert "undefiniert" ist, wird das "Wenn" -Konfession nicht bestanden.
Oskar Szura
3
Dadurch werden nicht definierte Variablen zusammengeführt (die bei der Auswertung einen ReferenceError auslösen), die sich von Variablen mit dem undefinedWert unterscheiden.
Qantas 94 Heavy
2
Ich habe hier den gleichen Fehler. if (x), if (! x), if (!! x) löst alle Fehler aus, wenn x undefiniert ist.
Shaosh
if(value === 0) gameOver(); ;)
Madbreaks
Diese Antwort ist auch falsch, weil sie false zurückgibt, wenn sie valueNull ist, was nicht das ist , wonach op sucht.
Madbreaks
17

Diese Zustandsprüfung

if (!!foo) {
    //foo is defined
}

ist alles, was du brauchst.

JerryP
quelle
Ich gehe davon aus, dass dies nur ein Ausschnitt ist. ifFührt aber schon eine Fälschungsprüfung durch, die diese nur in einen Booleschen Wert umwandelt. Fängt es Fälle, die ein Normaler if(foo)nicht fängt?
Daan van Hulst
1
Dies ist perfekt, wenn Sie etwas Inline benötigen, zum Beispiel ein Reaktionsattribut (als aktiv bezeichnet), das wahr ist, wenn eine Zeichenfolge nicht leer ist - eine if-Anweisung wäre übertrieben, damit ich sie einfach verwenden kannactive={!!foo}
Ben Kolya Mansley
16

! Überprüfen Sie, ob leere Zeichenfolgen (""), null, undefiniert, falsch und die Nummer 0 und NaN vorhanden sind. Angenommen, wenn eine Zeichenfolge leer var name = ""ist, wird console.log(!name)zurückgegeben true.

function isEmpty(val){
  return !val;
}

Diese Funktion gibt true zurück , wenn val ist leer, null, nicht definiert, falsch, die Zahl 0 oder NaN .

ODER

Je nach Problemdomäne können Sie einfach like !valoder verwenden !!val.

Arif
quelle
Dies sagt nicht wirklich aus, ob die Variable leer ist, da false und 0 gültige Werte sein können und keinen leeren Wert darstellen. Der Wert einer isEmpty-Funktion besteht darin, sicherzustellen, dass die erwarteten Werte leer sind. Meiner Meinung nach sind null, undefiniert, NaN und eine leere Zeichenfolge die Werte, die als leer sinnvoll sind.
Corey Young
9
Warum verwenden, isEmpty(val)wenn Sie nur tun könnten !val?
Allen Linatoc
Es liegt an dir. Sie können es verwenden, um die Lesbarkeit zu verbessern. Wenn Sie der Meinung sind, dass das Team, in dem Sie arbeiten, ein fortgeschrittener Programmierer ist, können Sie es nur !valoder !!valentsprechend Ihrer Problemdomäne verwenden.
Arif
15

Eine Lösung, die mir sehr gefällt:

Definieren wir, dass eine leere Variable nulloder undefined, oder wenn sie eine Länge hat, Null ist oder wenn es sich um ein Objekt handelt, keine Schlüssel hat:

function isEmpty (value) {
  return (
    // null or undefined
    (value == null) ||

    // has length and it's zero
    (value.hasOwnProperty('length') && value.length === 0) ||

    // is an Object and has no keys
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

Kehrt zurück:

  • true: undefined , null, "", [],{}
  • false: true , false, 1, 0, -1, "foo", [1, 2, 3],{ foo: 1 }
Alexandre Magro
quelle
14

Du übertreibst es ein bisschen. Um zu überprüfen, ob einer Variablen kein Wert zugewiesen wurde, müssen Sie nur gegen undefiniert und null prüfen.

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}

Dies setzt voraus 0, ""und Objekte (auch leere Objekte und Arrays) sind gültige "Werte".

tcooc
quelle
10

Wenn Sie einfaches Javascript bevorzugen, versuchen Sie Folgendes:

  /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */

function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

Andernfalls versuchen Sie Folgendes, wenn Sie bereits Unterstrich oder lodash verwenden:

_.isEmpty(value)
l3x
quelle
3
Habe deinen Code ausprobiert. In der Konsole wird eine Fehlermeldung angezeigt, die besagt: "Nicht erfasster Referenzfehler: isArray () ist nicht definiert". Ansonsten wäre es toll, wenn es klappen würde.
Crmprogdev
11
Zumindest im Fall von lodash _.isNilist die Funktion, die Sie suchen, nicht _.isEmpty. isNil Dokumentation , isEmpty Dokumentation
Snixtor
Dies würde fehlschlagen, wenn der Wert boolesch ist und den Wert true hat.
kalyanbk
3
Normales Javascript hat isArrayoder isStringfunktioniert nicht auf dem window.
GFoley83
@ GFoley83 - Du hast mich erwischt! Ich habe meine Gründe, Windows nicht zu verwenden. Ich beschreibe das Thema in dem Kapitel, das sich mit der Geschichte und dem Fortschritt von Softwaresprachen befasst. Weitere relevante Informationen werden wahrscheinlich die Diskussion / der Code sein, die die Behandlung monadischer Fehler in meinem Buch Learn Functional Programming in Go demonstrieren. Prost!
13.
9

Hier ist meins - gibt true zurück, wenn der Wert null, undefiniert usw. oder leer ist (dh nur Leerzeichen enthält):

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}
DavidWainwright
quelle
1
Ich habe hier verschiedene Methoden getestet. Mit einer Prüfung auf undefiniert funktioniert Ihre Funktion hervorragend. Also verwende ich if (Werttyp! == 'undefiniert' &&! IsEmpty (Wert)) ODER, wenn Sie tatsächlich nach Leer suchen möchten, können Sie if (Werttyp === 'undefiniert' || IsEmpty2 (Wert) verwenden. ). Dies funktioniert für null; Nicht definiert; 0; ""; ""; false
RationalRabbit
6
return val || 'Handle empty variable'

ist eine wirklich schöne und saubere Art, an vielen Stellen damit umzugehen, kann auch zum Zuweisen von Variablen verwendet werden

const res = val || 'default value'
Cubefox
quelle
Viele Orte, aber nicht, wenn der Standardwert ist trueund Sie versuchen, einen valvon zu liefern oder zurückzugeben false.
Molomby
@ Molomby, das ist ein sehr spezifischer Randfall, aber selbst das ist leicht zu handhabenconst res = falsyValue ? true : falsyValue
Cubefox
5

Wenn die Variable nicht deklariert wurde, können Sie mit einer Funktion nicht auf undefiniert testen, da eine Fehlermeldung angezeigt wird.

if (foo) {}
function (bar) {}(foo)

Beide erzeugen einen Fehler, wenn foo nicht deklariert wurde.

Wenn Sie testen möchten, ob eine Variable deklariert wurde, können Sie verwenden

typeof foo != "undefined"

Wenn Sie testen möchten, ob foo deklariert wurde und einen Wert hat, den Sie verwenden können

if (typeof foo != "undefined" && foo) {
    //code here
}
Herostwist
quelle
5

Standardwert überprüfen

function typeOfVar (obj) {
      return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
function isVariableHaveDefaltVal(variable) {
    if ( typeof(variable) === 'string' ) {  // number, boolean, string, object 
        console.log(' Any data Between single/double Quotes is treated as String ');        
        return (variable.trim().length === 0) ? true : false;
    }else if ( typeof(variable) === 'boolean' ) {
      console.log('boolean value with default value \'false\'');
        return (variable === false) ? true : false;
    }else if ( typeof(variable) === 'undefined' ) {
        console.log('EX: var a; variable is created, but has the default value of undefined.'); 
        return true;
    }else if ( typeof(variable) === 'number' ) { 
        console.log('number : '+variable);
        return (variable === 0 ) ? true : false;
    }else if ( typeof(variable) === 'object' ) {
   //   -----Object-----
        if (typeOfVar(variable) === 'array' && variable.length === 0) {
            console.log('\t Object Array with length = ' + [].length); // Object.keys(variable)
            return true;
        }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) {
            console.log('\t Object String with length = ' + variable.length);
            return true;
        }else if (typeOfVar(variable) === 'boolean' ) {
            console.log('\t Object Boolean = ' + variable);
            return (variable === false) ? true : false;
        }else if (typeOfVar(variable) === 'number' ) {
            console.log('\t Object Number = ' + variable);
            return (variable === 0 ) ? true : false;
        }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) {
       console.log('\t Object Regular Expression : ');
        return true;
        }else if (variable === null) {
       console.log('\t Object null value');
        return true;
        }
    }
    return false;
}
var str = "A Basket For Every Occasion";
str = str.replace(/\s/g, "-");
//The "g" flag in the regex will cause all spaces to get replaced.

Überprüfe das Ergebnis:

isVariableHaveDefaltVal(' '); // string          
isVariableHaveDefaltVal(false); // boolean       
var a;           
isVariableHaveDefaltVal(a);               
isVariableHaveDefaltVal(0); // number             
isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true         
isVariableHaveDefaltVal(null);              
isVariableHaveDefaltVal([]);               
isVariableHaveDefaltVal(/ /);              
isVariableHaveDefaltVal(new Object(''));               
isVariableHaveDefaltVal(new Object(false));            
isVariableHaveDefaltVal(new Object(0)); 
typeOfVar( function() {} );

Ich habe die @ Vix-Funktion () verwendet, um das Objekt von welchem ​​Typ zu überprüfen.

mit instansof «

var prototypes_or_Literals = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            else if (obj instanceof Date)
                return '[object Date]';
            else if (obj instanceof RegExp)
                return '[object regexp]';
            else if (obj instanceof String)
                return '[object String]';
            else if (obj instanceof Number)
                return '[object Number]';

            else
                return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};
output test «
prototypes_or_Literals( '' ) // "string"
prototypes_or_Literals( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"        
Yash
quelle
Vergleichsoperatoren prüfen == [Daten]. === [Daten, Objekttyp] JS-Nummern werden nach dem internationalen IEEE 754-Standard immer als Gleitkommazahlen mit doppelter Genauigkeit gespeichert. // Number Type [int, float literals ] var int = 77; var float = 77.7; console.log( int.toFixed(10) + '\t' + float.toFixed(10) ); // Object Type var number = new Number( 77 ); if( int != float ) console.log('Data Not Equal'); if( int == number && int !== number ) console.log('Data is Equal & Types vary');
Yash
5
function isEmpty(obj) {
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
    else return !obj;
}

In ES6 mit Trim für Whitespace-Strings:

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}
jales cardoso
quelle
1
tolle Funktion, danke! behandelt jede Art von Wert - Zahlen werden in allen anderen Lösungen weggelassen!
Fabian von Ellerts
1
@FabianvonEllerts Bitte versuchen Sie nicht, zusätzlichen Code in der Antwort eines anderen zu bearbeiten. Veröffentlichen Sie es als Ihre eigene Antwort, als Kommentar unter der Antwort oder fordern Sie in einem Kommentar an, die Antwort selbst zu aktualisieren.
TylerH
5

Es kann nützlich sein.

Alle Werte im Array stellen dar, was Sie sein möchten (null, undefiniert oder andere Dinge), und Sie suchen, was Sie darin möchten.

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1
ddagsan
quelle
2
Könntest du das bitte erklären? Was ist dort los
JoshKisb
Das Array enthält eine Variable, die Sie als leer angenommen haben.
Ddagsan
@JoshKisb Alle Werte im Array repräsentieren, was Sie sein möchten (null, undefiniert oder andere Dinge) und Sie suchen, was Sie darin wollen.
Ddagsan
1
@ddagsan Während JoshKisb Ihre Antwort vielleicht zu schätzen weiß, sollten Sie Ihre Erklärung in Ihre Antwort und nicht in die Kommentare einfügen
Nick
4

Wenn Sie "Werte verwenden TypeScriptund diese nicht berücksichtigen möchten "false ist dies die Lösung für Sie:

Zuerst: import { isNullOrUndefined } from 'util';

Dann: isNullOrUndefined(this.yourVariableName)

Bitte beachten Sie: Wie unten erwähnt, ist dies jetzt veraltet. Verwenden Sie value === undefined || value === nullstattdessen. ref .

BlackBeard
quelle
2
Ich fand das cool, also habe ich anfangs nicht gewählt, aber es ist eine Sache von Node.js, die veraltet ist. Typdefinitionsdatei sagt:/** @deprecated since v4.0.0 - use "value === null || value === undefined" instead. */
Atomiktom
@atomictom Ich dachte, es ist eine typescriptSache. Können Sie bitte den Link der Dokumentation angeben?
BlackBeard
Hier: nodejs.org/api/util.html#util_util_isnullorundefined_object . Außerdem: "Ich fand das cool, also habe ich anfangs positiv gestimmt ", das sollte lauten :)
Atomiktom
Warum sollte das eine nützliche einfache Sache wie diese ablehnen? Geeeeees.
Ticktock
3

Leere

Ich empfehle nicht, eine Funktion zu definieren oder zu verwenden, die berechnet, ob ein Wert auf der ganzen Welt leer ist. Was bedeutet es wirklich, "leer" zu sein? Wenn ja let human = { name: 'bob', stomach: 'empty' }, sollte ich isEmpty(human)zurückkehren true? Wenn ja let reg = new RegExp('');, sollte ich isEmpty(reg)zurückkehren true? Was ist mit isEmpty([ null, null, null, null ])- diese Liste enthält nur Leere, ist die Liste selbst also leer? Ich möchte hier einige Anmerkungen zur "Leere" (ein absichtlich undurchsichtiges Wort, um bereits bestehende Assoziationen zu vermeiden) in Javascript machen - und ich möchte argumentieren, dass "Leere" in Javascript-Werten niemals generisch behandelt werden sollte.


Wahrhaftigkeit / Falschheit

Um zu entscheiden, wie die "Leere" von Werten bestimmt werden soll, müssen wir dem in Javascript eingebauten, inhärenten Gefühl Rechnung tragen, ob Werte "wahr" oder "falsch" sind. Natürlich nullund undefinedsind beide "falsch". Weniger natürlich ist die Nummer 0(und keine andere Nummer außer NaN) auch "falsch". Am wenigsten natürlich: ''ist falsch, aber []und {}(und new Set(), und new Map()) sind wahr - obwohl sie alle gleich leer scheinen!


Null vs Undefiniert

Es gibt auch einige Diskussionen über nullvs undefined- brauchen wir wirklich beides, um Leere in unseren Programmen auszudrücken? Ich persönlich vermeide es, dass die Buchstaben u, n, d, e, f, i, n, e, d in dieser Reihenfolge in meinem Code erscheinen. Ich benutze immer null"Leere". Aber auch hier müssen wir dem inhärenten Sinn nullund undefinedUnterschied von Javascript Rechnung tragen :

  • Der Versuch, auf eine nicht vorhandene Eigenschaft zuzugreifen, gibt undefined
  • Das Weglassen eines Parameters beim Aufrufen einer Funktion führt dazu, dass dieser Parameter Folgendes erhält undefined:

let f = a => a;
console.log(f('hi'));
console.log(f());

  • Parameter mit Standardwerten erhalten den Standard nur, wenn sie angegeben sind undefined, nicht null:

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));


Nicht generische Leere

Ich glaube, dass Leere niemals generisch behandelt werden sollte. Wir sollten stattdessen immer die Sorgfalt haben, mehr Informationen über unsere Daten zu erhalten, bevor wir feststellen, ob sie leer sind. Dazu überprüfe ich hauptsächlich, mit welcher Art von Daten ich es zu tun habe:

let isType = (value, Cls) => {
  try {
    return Object.getPrototypeOf(value).constructor === Cls;
  } catch(err) {
    return false;
  }
};

Beachten Sie, dass diese Funktion den Polymorphismus ignoriert - sie erwartet value, dass es sich um eine direkte Instanz von Clsund nicht um eine Instanz einer Unterklasse von handelt Cls. Ich vermeide instanceofaus zwei Hauptgründen:

  • ([] instanceof Object) === true ("Ein Array ist ein Objekt")
  • ('' instanceof String) === false ("Ein String ist kein String")

Beachten Sie, dass dies Object.getPrototypeOfverwendet wird, um einen Fall wie zu vermeiden. let v = { constructor: String };Die isTypeFunktion gibt für isType(v, String)(false) und isType(v, Object)(true) immer noch korrekt zurück .

Insgesamt empfehle ich die Verwendung dieser isTypeFunktion zusammen mit den folgenden Tipps:

  • Minimieren Sie die Anzahl der Codeverarbeitungswerte unbekannten Typs. Zum Beispiel let v = JSON.parse(someRawValue);ist unsere vVariable jetzt von unbekanntem Typ. Wir sollten so früh wie möglich unsere Möglichkeiten einschränken. Der beste Weg, dies zu tun, kann darin bestehen, einen bestimmten Typ zu benötigen: zB if (!isType(v, Array)) throw new Error('Expected Array');- dies ist ein sehr schneller und ausdrucksstarker Weg, um die generische Natur von zu entfernen vund sicherzustellen, dass es immer ein ist Array. Manchmal müssen wir jedoch zulassen v, dass es mehrere Typen gibt. In diesen Fällen sollten wir vso früh wie möglich Codeblöcke erstellen, die nicht mehr generisch sind:

if (isType(v, String)) {
  /* v isn't generic in this block - It's a String! */
} else if (isType(v, Number)) {
  /* v isn't generic in this block - It's a Number! */
} else if (isType(v, Array)) {
  /* v isn't generic in this block - it's an Array! */
} else {
  throw new Error('Expected String, Number, or Array');
}

  • Verwenden Sie zur Validierung immer "Whitelists". Wenn Sie einen Wert benötigen, z. B. eine Zeichenfolge, eine Zahl oder ein Array, suchen Sie nach diesen 3 "weißen" Möglichkeiten und geben Sie einen Fehler aus, wenn keine der 3 erfüllt ist. Wir sollten in der Lage sein zu sehen, dass das Überprüfen auf "schwarze" Möglichkeiten nicht sehr nützlich ist: Sagen wir, wir schreiben if (v === null) throw new Error('Null value rejected');- dies ist großartig, um sicherzustellen, dass nullWerte es nicht schaffen, aber wenn ein Wert es schafft , wissen wir es immer noch kaum irgendetwas darüber. Ein Wert, vder diese Nullprüfung besteht, ist immer noch SEHR generisch - es ist alles andere alsnull ! Blacklists zerstreuen kaum die Generizität.
  • nullBetrachten Sie niemals "einen leeren Wert", es sei denn, es handelt sich um einen Wert . Betrachten Sie stattdessen "ein leeres X". Denken Sie im Wesentlichen niemals daran, etwas Ähnliches zu tun if (isEmpty(val)) { /* ... */ }- egal wie diese isEmptyFunktion implementiert ist (ich möchte es nicht wissen ...), sie ist nicht sinnvoll! Und es ist viel zu allgemein! Die Leere sollte nur mit Kenntnis des valTyps berechnet werden . Leerheitsprüfungen sollten folgendermaßen aussehen:

    • "Eine Zeichenfolge ohne Zeichen": if (isType(val, String) && val.length === 0) ...
    • "Ein Objekt mit 0 Requisiten": if (isType(val, Object) && Object.entries(val).length === 0) ...
    • "Eine Zahl gleich oder kleiner als Null": if (isType(val, Number) && val <= 0) ...
    • "Ein Array ohne Elemente": if (isType(val, Array) && val.length === 0) ...

    • Die einzige Ausnahme ist, wann nullbestimmte Funktionen angegeben werden. In diesem Fall ist es sinnvoll zu sagen: "Ein leerer Wert":if (val === null) ...

Gershom
quelle
Ich kann sehen, dass Sie darüber nachgedacht haben:>
Rui Marques
3

Versuchen Sie es mit einer anderen Logik . Sie können den folgenden Code verwenden, um alle vier (4) Bedingungen für die Validierung zu überprüfen, z. B. nicht null, nicht leer, nicht undefiniert und nicht null. Verwenden Sie nur diesen Code (! (! (Variable))) in Javascript und jquery.

function myFunction() {
    var data;  //The Values can be like as null, blank, undefined, zero you can test

    if(!(!(data)))
    {
        alert("data "+data);
    } 
    else 
    {
        alert("data is "+data);
    }
}
Ravikant
quelle
3

Schauen Sie sich den neuen ECMAScript Nullish-Koaleszenzoperator an

Sie können sich diese Funktion - den ??Operator - als eine Möglichkeit vorstellen, beim Umgang mit nulloder auf einen Standardwert zurückzugreifen undefined.

let x = foo ?? bar();

Wiederum entspricht der obige Code dem folgenden.

let x = (foo !== null && foo !== undefined) ? foo : bar();
Daniel Eduardo Delgado Diaz
quelle
2
function isEmpty(val){
    return !val;
}

Diese Lösung ist jedoch überentwickelt. Wenn Sie die Funktion später nicht für geschäftliche Modellanforderungen ändern möchten, ist es sauberer, sie direkt im Code zu verwenden:

if(!val)...
Luca C.
quelle
2
var myNewValue = myObject && myObject.child && myObject.child.myValue;

Dies wird niemals einen Fehler auslösen. Wenn myObject , child oder myValue null ist, ist myNewValue null. Es werden keine Fehler ausgegeben

Keith Blanchard
quelle
2

Für alle, die wegen ähnlicher Fragen hierher kommen, funktioniert Folgendes hervorragend und ich habe es in den letzten Jahren in meiner Bibliothek:

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object's constructor.
* @module {g3.utils}
* @function {g3.utils.type}
* @public
* @param {Type} 'obj' is any type native, host or custom.
* @return {String} Returns a lowercase string representing the object's 
* constructor which is different from word 'object' if they are not custom.
* @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
* http://stackoverflow.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript
* http://javascript.info/tutorial/type-detection
*******************************************************************************/
g3.utils.type = function (obj){
   if(obj === null)
      return 'null';
   else if(typeof obj === 'undefined')
      return 'undefined';
   return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));
Centurian
quelle
2

Wenn Sie vermeiden möchten, dass der Wert wahr wird, wenn der Wert laut jAndys Antwort einer der folgenden ist :

  • Null
  • nicht definiert
  • NaN
  • leerer String ("")
  • 0
  • falsch

Eine mögliche Lösung, die es vermeiden könnte, wahrheitsgemäße Werte zu erhalten, ist die folgende:

function isUsable(valueToCheck) {
    if (valueToCheck === 0     || // Avoid returning false if the value is 0.
        valueToCheck === ''    || // Avoid returning false if the value is an empty string.
        valueToCheck === false || // Avoid returning false if the value is false.
        valueToCheck)             // Returns true if it isn't null, undefined, or NaN.
    {
        return true;
    } else {
        return false;
    }
}

Es würde wie folgt verwendet werden:

if (isUsable(x)) {
    // It is usable!
}
// Make sure to avoid placing the logical NOT operator before the parameter (isUsable(!x)) and instead, use it before the function, to check the returned value.
if (!isUsable(x)) {
    // It is NOT usable!
}

Zusätzlich zu diesen Szenarien möchten Sie möglicherweise false zurückgeben, wenn das Objekt oder Array leer ist:

Sie würden es so machen:

function isEmptyObject(valueToCheck) {
    if(typeof valueToCheck === 'object' && !Object.keys(valueToCheck).length){
        // Object is empty!
        return true;
    } else {
        // Object is not empty!
        return false;
    }
}

function isEmptyArray(valueToCheck) {
    if(Array.isArray(valueToCheck) && !valueToCheck.length) {
        // Array is empty!
        return true;
    } else {
        // Array is not empty!
        return false;
    }
}

Wenn Sie nach allen Leerzeichenfolgen ("") suchen möchten, können Sie Folgendes tun:

function isAllWhitespace(){
    if (valueToCheck.match(/^ *$/) !== null) {
        // Is all whitespaces!
        return true;
    } else {
        // Is not all whitespaces!
        return false;
    }
}

Hinweis: hasOwnPropertyGibt true für leere Zeichenfolgen, 0, false, NaN, null und undefined zurück, wenn die Variable als eine von ihnen deklariert wurde, sodass sie möglicherweise nicht die beste ist. Die Funktion kann geändert werden, um anzuzeigen, dass sie deklariert wurde, ist jedoch nicht verwendbar.

yaharga
quelle
2

Code auf GitHub

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)

  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);

// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

Tests des armen Mannes 😁

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };

  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];

  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

Testergebnisse:

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]
Pascal Polleunus
quelle
Tolle Funktion, alle anderen Antworten hier hatten mehrere Probleme, die Ihre zu lösen scheinen. Ich wünschte nur, ich hätte sie gefunden, bevor ich meine eigene geschrieben hätte: p dachte, Sie möchten vielleicht einen Blick auf meine Arbeit stackoverflow.com/ werfen. Fragen / 5515310 /… unsere beiden Funktionen scheinen genau die gleiche Ausgabe zu haben, aber ich habe den Code ein wenig reduziert. Bitte lassen Sie mich wissen, wenn ich etwas verpasst habe.
Sean Bannister
👍 Hast du meine "Tests des armen Mannes" ausprobiert? Ich glaube, ich habe der Funktion weitere Tests für Sonderfälle wie Map, WeakMap und möglicherweise auch Date, RegExp hinzugefügt. Bist du dir sicher value.constructor === Object? Überprüfen Sie dies .
Pascal Polleunus
Ja, ich habe Ihre Tests durchgeführt. Vielen Dank dafür. Unsere beiden Funktionen liefern bei beiden Tests die gleichen Ergebnisse. Ich frage mich immer wieder, ob mir außerhalb dieser Testfälle etwas fehlt. Ich glaube, es value.constructor === Objectist in Ordnung, in Javascript haben IF-OR-Anweisungen eine Ausführungsreihenfolge, sodass die OR-Anweisung nur ausgeführt wird, wenn die vorherige nicht TRUE zurückgegeben hat und wir bereits nachgesehen haben Null. Tatsächlich besteht der einzige Zweck dieser letzten OR-Anweisung darin, zu erkennen {}und sicherzustellen, dass sie für Dinge, die sie nicht sollte, nicht TRUE zurückgibt.
Sean Bannister
1

Dadurch wird geprüft, ob die Variable der unbestimmten Verschachtelung undefiniert ist

function Undef(str) 
{
  var ary = str.split('.');
  var w = window;
  for (i in ary) {
    try      { if (typeof(w = w[ary[i]]) === "undefined") return true; }
    catch(e) { return true; }
  }
  return false;
}

if (!Undef("google.translate.TranslateElement")) {

Das obige prüft, ob die Google Übersetzungsfunktion TranslateElement vorhanden ist. Dies entspricht:

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {
Rickdog
quelle
1

Der optionale Verkettungsoperator bietet eine Möglichkeit, den Zugriff auf Werte über verbundene Objekte zu vereinfachen, wenn eine Referenz oder Funktion möglicherweise undefiniert oder null ist.

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

Der Null-Koaleszenz-Operator kann nach der optionalen Verkettung verwendet werden, um einen Standardwert zu erstellen, wenn keiner gefunden wurde:

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city
Sonniger Sultan
quelle
1
function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

Außerdem werden Leerzeichen ('') und Folgendes überprüft:

  • null, undefiniert, NaN, leer, Zeichenfolge (""), 0, falsch
Hassan Ali Shahzad
quelle
0

Ich denke mit dem? Bediener ist etwas sauberer.

var ? function_if_exists() : function_if_doesnt_exist();
Pedro Pereira
quelle