it-swarm.com.de

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

Gibt es eine universelle JavaScript-Funktion, die überprüft, ob eine Variable einen Wert hat und sicherstellt, dass sie nicht undefined oder null ist? 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;
}
1983
Alex

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

if( value ) {
}

wird zu true ausgewertet, wenn value nicht ist:

  • null
  • undefined
  • NaN
  • leerer String ("")
  • false

Die obige Liste zeigt alle möglichen falsy Werte in ECMA-/Javascript. Finden Sie es in der Spezifikation im Abschnitt ToBoolean.

Wenn Sie nicht wissen , ob eine Variable existiert (dh, wenn sie deklariert wurde ) Sie sollten dies mit dem Operator typeof überprüfen. 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 truthy -Wert wie oben gezeigt hat.

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

3927
jAndy

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 einer alle Regeln kennt :

return value == null; // also returns true if value is undefined
194
Salman A
function isEmpty(value){
  return (value == null || value.length === 0);
}

Dies wird true für zurückgeben

undefined  // Because undefined == null

null

[]

""

und Null-Argument-Funktionen, da length einer Funktion die Anzahl der deklarierten Parameter ist, die sie benötigt.

Wenn Sie die letztere Kategorie nicht zulassen möchten, sollten Sie nur nach leeren Zeichenfolgen suchen

function isEmpty(value){
  return (value == null || value === '');
}
71
Mike Samuel

Dies ist der sicherste Scheck und ich habe nicht gesehen, dass er hier genau so gepostet wurde:

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

Es werden Fälle behandelt, in denen value noch nie definiert wurde, und auch folgende:

  • null
  • undefined (Wert von undefined ist nicht derselbe wie ein Parameter, der nie definiert wurde)
  • "" (leerer String)
  • false
  • NaN

P.S. keine Notwendigkeit für strikte Gleichheit in Werttyp! = 'undefiniert'

32
guya

Möglicherweise finden Sie die folgende Funktion nützlich:

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. Es handelt sich derzeit um einen Vorschlag der Stufe 0 (Strawman), um in die Sprache eingeführt zu werden." - Simon Kjellberg. der autor möchte seine unterstützung für diesen schönen vorschlag zum erhalt des königlichen aufstiegs hinzufügen.

27
Vix

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)
25
krupar

! prüfe auf leere Zeichenketten (""), null, undefiniert, falsch und die Zahl 0 und NaN. Sprich, wenn eine Zeichenkette leer ist var name = "" dann console.log(!name) gibt true zurück.

function isEmpty(val){
  return !val;
}

diese Funktion gibt true zurück, wenn valleer, null, undefiniert, false, die Zahl 0 oder NaN ist.

ODER

Je nach Problemdomain können Sie einfach !val oder !!val verwenden.

16
Arif

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

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

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

12
tcooc

Diese Zustandsprüfung

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

ist alles, was du brauchst.

11
JerryP

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;

}
9
DavidWainwright

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 einen Unterstrich oder ein lodash verwenden:

_.isEmpty(value)
9
l3x

Ich werde eine registrierte Lösung hinterlassen, die mir sehr gut gefallen hat:

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

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 }
7
Alexandre Magro
return val || 'Handle empty variable'

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

const res = val || 'default value'
5
cubefox

m den Standardwert zu ü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 @Vix function () verwendet, um den Typ des Objekts 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]"        
5
Yash

Wenn die Variable nicht deklariert wurde, können Sie mit einer Funktion nicht auf undefinierte Werte 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
}
5
herostwist
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 Beschnitt für Whitespace-Zeichenfolgen:

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
}
4
jales cardoso

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 wollen.

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1
4
ddagsan

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 diesen Code (! (! (Variabel)) nur in Javascript und in 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);
    }
}
3
Ravikant

Wenn Sie TypeScript verwenden und "Werte nicht berücksichtigen möchten, sind dies false" dann ist dies die Lösung für Sie:

Erstens: import { isNullOrUndefined } from 'util';

Dann: isNullOrUndefined(this.yourVariableName)

Bitte beachten Sie: Wie bereits erwähnt nten ist dies jetzt veraltet, verwenden Sie stattdessen value === undefined || value === null. ref .

3
BlackBeard

Für alle, die hierher kommen, weil sie ähnliche Fragen haben:

(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));
2
centurian
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 geworfen

2
Keith Blanchard
function isEmpty(val){
    return !val;
}

diese Lösung ist jedoch überarbeitet. Wenn Sie die Funktion später nicht für Geschäftsmodellanforderungen ändern möchten, ist es einfacher, sie direkt im Code zu verwenden:

if(!val)...
2
Luca C.

Dies prü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 ist äquivalent zu:

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

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 ich let human = { name: 'bob', stomach: 'empty' } habe, sollte isEmpty(human)true zurückgeben? Wenn ich let reg = new RegExp(''); habe, sollte isEmpty(reg)true zurückgeben? 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 bestehende Assoziationen zu vermeiden) in Javascript machen - und ich möchte argumentieren, dass "Leere" in Javascript-Werten niemals generisch behandelt werden sollte.


Wahrheit/Falschheit

Um zu entscheiden, wie die "Leere" von Werten zu bestimmen ist, müssen wir dem eingebauten, inhärenten Sinn von Javascript Rechnung tragen, ob Werte "wahr" oder "falsch" sind. Natürlich sind null und undefined beide "falsch". Weniger natürlich ist die Zahl 0 (und keine andere Zahl 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 null vs undefined - brauchen wir wirklich beides, um die 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, um "Leere" zu bezeichnen. Aber auch hier müssen wir uns auf den inhärenten Sinn von Javascript einstellen, wie sich null und undefined unterscheiden:

  • Der Versuch, auf eine nicht vorhandene Eigenschaft zuzugreifen, gibt undefined
  • Wenn ein Parameter beim Aufruf einer Funktion weggelassen wird, erhält dieser Parameter undefined:
let f = a => a;
console.log(f('hi'));
console.log(f());
  • Parameter mit Standardwerten erhalten den Standardwert nur bei Angabe von undefined, nicht von 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. Stattdessen sollten wir immer die Sorgfalt aufbringen, um weitere Informationen zu unseren Daten zu erhalten, bevor wir feststellen, ob diese frei sind. Ich überprüfe dazu hauptsächlich, um welche Art von Daten es sich handelt:

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

Beachten Sie, dass diese Funktion den Polymorphismus ignoriert - es wird erwartet, dass value eine direkte Instanz von Cls und keine Instanz einer Unterklasse von Cls ist. Ich vermeide instanceof aus zwei Hauptgründen:

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

Beachten Sie, dass Object.getPrototypeOf verwendet wird, um einen Fall wie let v = { constructor: String }; zu vermeiden. Die isType -Funktion wird weiterhin korrekt für isType(v, String) (false) und isType(v, Object) (true) zurückgegeben.

Insgesamt empfehle ich, diese isType -Funktion zusammen mit den folgenden Tipps zu verwenden:

  • Minimieren Sie die Anzahl der Codeverarbeitungswerte unbekannten Typs. Zum Beispiel hat unsere Variable v für let v = JSON.parse(someRawValue); jetzt einen unbekannten Typ. Wir sollten unsere Möglichkeiten so früh wie möglich einschränken. Der beste Weg, dies zu tun, kann darin bestehen, einen bestimmten Typ zu erfordern: z. if (!isType(v, Array)) throw new Error('Expected Array'); - Dies ist eine sehr schnelle und aussagekräftige Methode, um die generische Natur von v zu entfernen und sicherzustellen, dass es immer eine Array ist. Manchmal müssen wir jedoch zulassen, dass v von mehreren Typen ist. In diesen Fällen sollten wir so früh wie möglich Codeblöcke erstellen, in denen v nicht mehr generisch ist:
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, der z. B. ein String, eine Zahl oder ein Array sein soll, überprüfen Sie diese drei "weißen" Möglichkeiten und geben Sie einen Fehler aus, wenn keine der drei Möglichkeiten vorliegt 3 sind zufrieden. Wir sollten sehen können, dass das Prüfen auf "schwarze" Möglichkeiten nicht sehr nützlich ist: Angenommen, wir schreiben if (v === null) throw new Error('Null value rejected'); - dies ist großartig, um sicherzustellen, dass null Werte nicht durchkommen, aber wenn a value schafft es , wir wissen immer noch kaum etwas darüber. Ein Wert v, der diese Nullprüfung besteht, ist immer noch SEHR generisch - es ist alles andere als null! Schwarze Listen verdrängen kaum die Allgemeinheit.
  • Es sei denn, ein Wert ist null, betrachten Sie niemals "einen leeren Wert". Betrachten Sie stattdessen "ein leeres X". Grundsätzlich sollten Sie niemals etwas wie if (isEmpty(val)) { /* ... */ } - no Unabhängig davon, wie diese isEmpty -Funktion implementiert ist (ich möchte es nicht wissen ...), ist sie nicht aussagekräftig! Und es ist viel zu generisch! Die Leere sollte nur mit Kenntnis des Typs val berechnet werden. Vacuousness-Checks sollten so aussehen:

    • "Ein String 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, wenn null zur Kennzeichnung bestimmter Funktionen verwendet wird. In diesem Fall ist es sinnvoll zu sagen: "Ein leerer Wert": if (val === null) ...

1
Gershom Maes

Obwohl ein Oldie, was vergessen ist, dass sie ihren Codeblock umbrechen und dann den Fehler abfangen und dann testen sollten ...

function checkup( t ){
  try{
    for(p in t){
      if( p.hasOwnProperty( t ) ){
        return true;
      }
    }
    return false;
  }catch(e){
    console.log("ERROR : "+e);
    return e;
  }
}

Sie müssen also wirklich nicht vorab nach einem potenziellen Problem suchen, sondern fangen es einfach auf und behandeln es nach Ihren Wünschen.

0
Mark Giblin
try{

     let vari = obj.propTest; // obj may be don't have propTest property

        ...
} catch(NullException){
    // do something here
}

Ich denke, mit try catch wird jeder Fehler der Nullprüfung vermieden, auch in Angular oder JavaScript.

0
nobjta_9x_tq

Ich denke mit dem? Betreiber ist etwas sauberer.

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