Sprawdzanie, czy coś jest puste w Javascript?

Jak mogę sprawdzić, czy zmienna jest pusta w JavaScript? Przepraszam za głupie pytanie, ale jestem nowicjuszem w Javascript!

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

response.photopochodzi z formatu JSON i czasami może być pusty, puste komórki danych! Chcę sprawdzić, czy jest pusty.

Jeśli testujesz pod kątem pustego ciągu:

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

Jeśli szukasz zmiennej, która została zadeklarowana, ale nie została zdefiniowana:

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

Jeśli szukasz zmiennej, która nie może być zdefiniowana:

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

Jeśli sprawdzasz obie wartości tj., Każda ze zmiennych ma wartość null lub undefined:

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

To ważniejsze pytanie niż myślisz. Zmienne mogą być opróżniane na wiele sposobów. Rodzaj zależy od tego, co musisz wiedzieć.

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

Powinno to obejmować wszystkie przypadki:

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

Widzę potencjalne braki w wielu zamieszczonych powyżej rozwiązaniach, dlatego zdecydowałem się skompilować własne.
Uwaga: używa Array.prototype.some , sprawdź obsługę przeglądarki.

Poniższe rozwiązanie uznaje zmienną za pustą, jeśli spełniony jest jeden z poniższych warunków:

1. JS uważa, że zmienna jest równa false, która obejmuje już wiele rzeczy, jak 0, "", [], a nawet [""]i[0]
2. Wartość to nulllub jej typ to'undefined'
3. To jest pusty obiekt

4. Jest to obiekt / tablica składająca się tylko z wartości, które same są puste (tj. Podzielone na prymitywy, każda jego część jest równa false). Sprawdza drążenie rekurencyjnie w strukturze Object / Array. Na przykład

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

Kod funkcji:

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

Tutaj moje najprostsze rozwiązanie.

Zainspirowany funkcją PHP empty

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

Zobacz http://underscorejs.org/#isEmpty

isEmpty_.isEmpty (object) Zwraca wartość true, jeśli wyliczalny obiekt nie zawiera żadnych wartości (brak wyliczalnych właściwości własnych). W przypadku ciągów znaków i obiektów podobnych do tablic _.isEmpty sprawdza, czy właściwość length ma wartość 0.

Łączenie odpowiedzi z @inkednm w jedną funkcję:

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

Puste sprawdzenie klucza JSON zależy od przypadku użycia. W przypadku typowego przypadku użycia możemy przetestować następujące elementy:

1. Nie null
2. Nie undefined
3. To nie jest pusty ciąg ''
4. To nie jest pusty obiekt {} [] (tablica jest obiektem)

Funkcjonować:

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

Zwrot true dla:

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

po prostu umieść zmienną w warunku if, jeśli zmienna ma jakąkolwiek wartość, zwróci wartość true lub false.

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

A co z takim robieniem?

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

To zależy od tego, co masz na myśli mówiąc „pusty”. Najpopularniejszym wzorcem jest sprawdzenie, czy zmienna jest niezdefiniowana . Wiele osób sprawdza również wartość zerową, na przykład:
if (myVariable === undefined || myVariable === null)...

lub w krótszej formie:
if (myVariable || myVariable === null)...

if (myVar == undefined)

będzie działać, aby sprawdzić, czy var jest zadeklarowany, ale nie zainicjowany.

Sprawdź niezdefiniowane:

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

To byłoby równoważne z czasownikiem IsEmpty. Jeśli myvar zawiera jakąkolwiek wartość, nawet null, pusty ciąg lub 0, nie jest „pusty”.

Aby sprawdzić, czy zmienna lub właściwość istnieje, np. Została zadeklarowana, chociaż nie została jeszcze zdefiniowana, możesz użyć inoperatora.

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

Jeśli szukasz odpowiednika funkcji PHP empty, sprawdź to:

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

Czego mi brakuje, jeśli pusta tablica ... obiekt bezkluczykowy ... fałszywość const isEmpty = o => Array.isArray (o) &&! o.join (''). length || typeof o === 'object' &&! Object.keys (o) .length || ! (+ wartość);

Oto prostsze (krótkie) rozwiązanie sprawdzania pustych zmiennych. Ta funkcja sprawdza, czy zmienna jest pusta. Podana zmienna może zawierać wartości mieszane (null, undefined, array, object, string, integer, function).

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;