Bir şeyin Javascript'te Boş olup olmadığını kontrol etmek

Javascript'te bir değişkenin boş olup olmadığını nasıl kontrol edebilirim? Aptal soru için özür dilerim, ama ben Javascript'te acemiyim!

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

response.photoJSON'dandı ve bazen boş olabilir, veri hücreleri boş! Boş olup olmadığını kontrol etmek istiyorum.

Boş bir dizeyi test ediyorsanız:

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

Bildirilmiş ancak tanımlanmamış bir değişkeni kontrol ediyorsanız:

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

Tanımlanamayan bir değişkeni kontrol ediyorsanız:

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

Her ikisini de kontrol ediyorsanız, değişken null veya tanımsızdır:

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

Bu sandığınızdan daha büyük bir soru. Değişkenler birçok şekilde boş olabilir. Neye ihtiyacın olduğuna bağlı.

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

Bu, tüm durumları kapsamalıdır:

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

Yukarıda yayınlanan birçok çözümde potansiyel eksiklikler görüyorum, bu yüzden kendi çözümümü derlemeye karar verdim.
Not: Array.prototype.some kullanır , tarayıcı desteğinizi kontrol edin.

Aşağıdaki çözüm, aşağıdakilerden biri doğruysa değişkeni boş kabul eder:

1. JS o değişken eşit olduğunu düşündüğü falsezaten gibi birçok şeyi kapsayan, 0, "", [], ve hatta [""]ve[0]
2. Değer nullveya türü'undefined'
3. Bu boş bir Nesnedir

4. Yalnızca kendi içinde boş olan değerlerden oluşan bir Nesne / Dizidir (yani, her bir parçasının eşit olduğu ilkellere bölünmüştür false). Kontroller Nesne / Dizi yapısına yinelemeli olarak detaylandırma yapar. Örneğin

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

Fonksiyon kodu:

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

İşte benim en basit çözümüm.

PHP empty işlevinden esinlenilmiştir

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

Bkz. Http://underscorejs.org/#isEmpty

isEmpty_.isEmpty (object) Numaralandırılabilir bir nesne değer içermiyorsa (sıralanabilir kendi özellikleri yoksa) true döndürür. Dizeler ve dizi benzeri nesneler için _.isEmpty, length özelliğinin 0 olup olmadığını kontrol eder.

@İnkednm'den gelen yanıtları tek bir işlevde birleştirmek:

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

JSON anahtarının boş kontrolü, kullanım durumuna bağlıdır. Yaygın bir kullanım örneği için aşağıdakileri test edebiliriz:

1. Değil null
2. Değil undefined
3. Boş Dize değil ''
4. Boş bir Nesne değil {} [] (Dizi bir Nesnedir)

İşlev:

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

Şunun için true döndür:

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

değişkeni if ​​koşulunun içine koyun, eğer değişken herhangi bir değere sahipse, true, aksi takdirde false döndürür.

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

Böyle yapmaya ne dersin?

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

"Boş" ile ne demek istediğine bağlı. En yaygın model, değişkenin tanımsız olup olmadığını kontrol etmektir . Birçok kişi ayrıca boş bir kontrol yapar, örneğin:
if (myVariable === undefined || myVariable === null)...

veya daha kısa bir biçimde:
if (myVariable || myVariable === null)...

if (myVar == undefined)

varlığın beyan edilip edilmediğini ancak başlangıç ​​durumuna getirilmediğini görmek için çalışacaktır.

Tanımsız olup olmadığını kontrol edin:

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

Bu, vb'lerin eşdeğerini yapacaktır IsEmpty. Myvar herhangi bir değer içeriyorsa, hatta null, boş dize veya 0, "boş" değildir.

Bir değişkenin veya özelliğin var olup olmadığını kontrol etmek için, örneğin tanımlanmış olabilir, ancak tanımlanmamış olabilir, inoperatörü kullanabilirsiniz .

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

PHP'nin emptyişlevinin eşdeğerini arıyorsanız, şuna bakın :

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

boş dizi ise neyi kaçırıyorum ... anahtarsız nesne ... yanlışlık sabiti isEmpty = o => Array.isArray (o) &&! o.join (''). uzunluk || typeof o === 'nesne' &&! Nesne.keys (o) .length || ! (+ değer);

İşte boş değişkenleri kontrol etmek için daha basit (kısa) bir çözüm. Bu işlev, bir değişkenin boş olup olmadığını kontrol eder. Sağlanan değişken, karışık değerler (null, undefined, array, object, string, integer, function) içerebilir.

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;