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

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

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

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 === '');
}

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

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.

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)

Diese Zustandsprüfung

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

ist alles, was du brauchst.

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

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 }

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

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)

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;

}

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'

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
}

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]"        

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
}

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

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 .

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

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

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();

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

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

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

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:

• Objekt: {} (mit ECMA 7+ )
• Array: [] (mit ECMA 5+ )

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.

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]

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

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

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

Ich denke mit dem? Bediener ist etwas sauberer.

var ? function_if_exists() : function_if_doesnt_exist();