Überprüfen, ob etwas in Javascript leer ist?

Wie kann ich überprüfen, ob eine Variable in Javascript leer ist? Entschuldigung für die dumme Frage, aber ich bin ein Neuling in Javascript!

if(response.photo) is empty {
    do something
else {
    do something else
}

response.photowar von JSON, und es könnte manchmal leer sein, leere Datenzellen! Ich möchte überprüfen, ob es leer ist.

Wenn Sie auf eine leere Zeichenfolge testen:

if(myVar === ''){ // do stuff };

Wenn Sie nach einer Variablen suchen, die deklariert, aber nicht definiert wurde:

if(myVar === null){ // do stuff };

Wenn Sie nach einer Variablen suchen, die möglicherweise nicht definiert ist:

if(myVar === undefined){ // do stuff };

Wenn Sie beide überprüfen, dh entweder ist die Variable null oder undefiniert:

if(myVar == null){ // do stuff };

Dies ist eine größere Frage als Sie denken. Variablen können auf viele Arten leer sein. Ein bisschen hängt davon ab, was Sie wissen müssen.

// quick and dirty will be true for '', null, undefined, 0, NaN and false.
if (!x) 

// test for null OR undefined
if (x == null)  

// test for undefined OR null 
if (x == undefined) 

// test for undefined
if (x === undefined) 
// or safer test for undefined since the variable undefined can be set causing tests against it to fail.
if (typeof x == 'undefined') 

// test for empty string
if (x === '') 

// if you know its an array
if (x.length == 0)  
// or
if (!x.length)

// BONUS test for empty object
var empty = true, fld;
for (fld in x) {
  empty = false;
  break;
}

Dies sollte alle Fälle abdecken:

function empty( val ) {

    // test results
    //---------------
    // []        true, empty array
    // {}        true, empty object
    // null      true
    // undefined true
    // ""        true, empty string
    // ''        true, empty string
    // 0         false, number
    // true      false, boolean
    // false     false, boolean
    // Date      false
    // function  false

        if (val === undefined)
        return true;

    if (typeof (val) == 'function' || typeof (val) == 'number' || typeof (val) == 'boolean' || Object.prototype.toString.call(val) === '[object Date]')
        return false;

    if (val == null || val.length === 0)        // null or 0 length array
        return true;

    if (typeof (val) == "object") {
        // empty object

        var r = true;

        for (var f in val)
            r = false;

        return r;
    }

    return false;
}

Ich sehe potenzielle Mängel in vielen der oben genannten Lösungen, daher habe ich beschlossen, meine eigenen zu kompilieren.
Hinweis: Es wird Array.prototype.some verwendet . Überprüfen Sie die Unterstützung Ihres Browsers.

Die folgende Lösung betrachtet die Variable als leer, wenn eine der folgenden Bedingungen erfüllt ist:

1. JS denkt , dass Variable ist gleich false, die schon viele Dinge wie bedeckt 0, "", [], und auch [""]und[0]
2. Wert ist nulloder es ist Typ'undefined'
3. Es ist ein leeres Objekt

4. Es ist ein Objekt / Array, das nur aus Werten besteht, die selbst leer sind (dh in Grundelemente zerlegt, denen jeder Teil entspricht false). Überprüft den Drill rekursiv in der Objekt- / Array-Struktur. Z.B

   isEmpty({"": 0}) // true
   isEmpty({"": 1}) // false
   isEmpty([{}, {}])  // true
   isEmpty(["", 0, {0: false}]) //true
   

Funktionscode:

/**
 * Checks if value is empty. Deep-checks arrays and objects
 * Note: isEmpty([]) == true, isEmpty({}) == true, isEmpty([{0:false},"",0]) == true, isEmpty({0:1}) == false
 * @param value
 * @returns {boolean}
 */
function isEmpty(value){
  var isEmptyObject = function(a) {
    if (typeof a.length === 'undefined') { // it's an Object, not an Array
      var hasNonempty = Object.keys(a).some(function nonEmpty(element){
        return !isEmpty(a[element]);
      });
      return hasNonempty ? false : isEmptyObject(Object.keys(a));
    }

    return !a.some(function nonEmpty(element) { // check if array is really not empty as JS thinks
      return !isEmpty(element); // at least one element should be non-empty
    });
  };
  return (
    value == false
    || typeof value === 'undefined'
    || value == null
    || (typeof value === 'object' && isEmptyObject(value))
  );
}

Hier meine einfachste Lösung.

Inspiriert von der PHP- empty Funktion

function empty(n){
	return !(!!n ? typeof n === 'object' ? Array.isArray(n) ? !!n.length : !!Object.keys(n).length : true : false);
}

//with number
console.log(empty(0));        //true
console.log(empty(10));       //false

//with object
console.log(empty({}));       //true
console.log(empty({a:'a'}));  //false

//with array
console.log(empty([]));       //true
console.log(empty([1,2]));    //false

//with string
console.log(empty(''));       //true
console.log(empty('a'));      //false

Siehe http://underscorejs.org/#isEmpty

isEmpty_.isEmpty (Objekt) Gibt true zurück, wenn ein aufzählbares Objekt keine Werte enthält (keine aufzählbaren eigenen Eigenschaften). Für Zeichenfolgen und Array-ähnliche Objekte überprüft _.isEmpty, ob die Eigenschaft length 0 ist.

Kombinieren Sie die Antworten von @inkednm zu einer Funktion:

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

Die leere Prüfung des Schlüssels eines JSON hängt vom Anwendungsfall ab. Für einen allgemeinen Anwendungsfall können wir Folgendes testen:

1. Nicht null
2. Nicht undefined
3. Kein leerer String ''
4. Kein leeres Objekt {} [] (Array ist ein Objekt)

Funktion:

function isEmpty(arg){
  return (
    arg == null || // Check for null or undefined
    arg.length === 0 || // Check for empty String (Bonus check for empty Array)
    (typeof arg === 'object' && Object.keys(arg).length === 0) // Check for empty Object or Array
  );
}

Rückgabe true für:

isEmpty(''); // Empty String
isEmpty(null); // null
isEmpty(); // undefined
isEmpty({}); // Empty Object
isEmpty([]); // Empty Array

Setzen Sie die Variable einfach in die if-Bedingung. Wenn die Variable einen Wert hat, wird true zurückgegeben, andernfalls false.

if (response.photo){ // if you are checking for string use this if(response.photo == "") condition
 alert("Has Value");
}
else
{
 alert("No Value");
};

Was ist damit?

JSON.stringify({}) === "{}"

Es kommt darauf an, was Sie unter "leer" verstehen. Das häufigste Muster besteht darin, zu überprüfen, ob die Variable undefiniert ist . Viele Leute machen auch eine Nullprüfung, zum Beispiel:
if (myVariable === undefined || myVariable === null)...

oder in kürzerer Form:
if (myVariable || myVariable === null)...

if (myVar == undefined)

wird funktionieren, um zu sehen, ob die Variable deklariert, aber nicht initialisiert ist.

Auf undefiniert prüfen:

if (typeof response.photo == "undefined")
{
    // do something
}

Dies würde das Äquivalent von vb's tun IsEmpty. Wenn myvar einen Wert enthält, sogar null, eine leere Zeichenfolge oder 0, ist er nicht "leer".

Um zu überprüfen, ob eine Variable oder Eigenschaft vorhanden ist, z. B. deklariert wurde, obwohl sie möglicherweise nicht definiert wurde, können Sie den inOperator verwenden.

if ("photo" in response)
{
    // do something
}

Wenn Sie nach dem Äquivalent der PHP- emptyFunktion suchen , lesen Sie Folgendes:

function empty(mixed_var) {
  //   example 1: empty(null);
  //   returns 1: true
  //   example 2: empty(undefined);
  //   returns 2: true
  //   example 3: empty([]);
  //   returns 3: true
  //   example 4: empty({});
  //   returns 4: true
  //   example 5: empty({'aFunc' : function () { alert('humpty'); } });
  //   returns 5: false

  var undef, key, i, len;
  var emptyValues = [undef, null, false, 0, '', '0'];

  for (i = 0, len = emptyValues.length; i < len; i++) {
    if (mixed_var === emptyValues[i]) {
      return true;
    }
  }

  if (typeof mixed_var === 'object') {
    for (key in mixed_var) {
      // TODO: should we check for own properties only?
      //if (mixed_var.hasOwnProperty(key)) {
      return false;
      //}
    }
    return true;
  }

  return false;
}

http://phpjs.org/functions/empty:392

Was fehlt mir, wenn das Array leer ist ... schlüsselloses Objekt ... Falschheit const isEmpty = o => Array.isArray (o) &&! o.join (''). length || typeof o === 'object' &&! Object.keys (o) .length || ! (+ Wert);

Hier ist eine einfachere (kurze) Lösung, um nach leeren Variablen zu suchen. Diese Funktion prüft, ob eine Variable leer ist. Die angegebene Variable kann gemischte Werte enthalten (null, undefiniert, Array, Objekt, Zeichenfolge, Ganzzahl, Funktion).

function empty(mixed_var) {
 if (!mixed_var || mixed_var == '0') {
  return true;
 }
 if (typeof mixed_var == 'object') {
  for (var k in mixed_var) {
   return false;
  }
  return true;
 }
 return false;
}

//   example 1: empty(null);
//   returns 1: true

//   example 2: empty(undefined);
//   returns 2: true

//   example 3: empty([]);
//   returns 3: true

//   example 4: empty({});
//   returns 4: true

//   example 5: empty(0);
//   returns 5: true

//   example 6: empty('0');
//   returns 6: true

//   example 7: empty(function(){});
//   returns 7: false

const isEmpty = val => val == null || !(Object.keys(val) || val).length;