Перевірка чогось пустого в Javascript?

Як я можу перевірити, чи змінна порожня в Javascript? Вибачте за дурне запитання, але я новачок у Javascript!

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

response.photoбув з JSON, і іноді він може бути порожнім, порожні клітинки даних! Я хочу перевірити, чи не пусто.

Якщо ви тестуєте на наявність порожнього рядка:

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

Якщо ви перевіряєте наявність змінної, яка була оголошена, але не визначена:

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

Якщо ви перевіряєте наявність змінної, яка може не бути визначена:

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

Якщо ви перевіряєте обидва, тобто, будь-яка змінна має значення null або undefined:

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

Це питання більше, ніж ви думаєте. Змінні можуть спорожнятися різними способами. Своєрідно залежить від того, що вам потрібно знати.

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

Це повинно охоплювати всі випадки:

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

Я бачу потенційні недоліки у багатьох рішеннях, розміщених вище, тому я вирішив скласти власне.
Примітка: він використовує Array.prototype.some , перевірте підтримку браузера.

Рішення, наведене нижче, вважає змінну порожньою, якщо є одним із наведених нижче істинних:

1. JS вважає , що змінна дорівнює false, яка вже охоплює багато речей , як 0, "", [], і навіть [""]і[0]
2. Значення є nullабо його тип є'undefined'
3. Це порожній об'єкт

4. Це Об’єкт / Масив, що складається лише зі значень, які самі порожні (тобто розбиті до примітивів, кожна частина яких дорівнює false). Рекурсивно перевіряє деталізацію структури об’єкта / масиву. Напр

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

Код функції:

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

Ось моє найпростіше рішення.

Натхненний 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

Див. Http://underscorejs.org/#isEmpty

isEmpty_.isEmpty (object) Повертає true, якщо перелічуваний об'єкт не містить значень (немає перелічуваних власних властивостей). Для рядків та схожих на масив об'єктів _.isEmpty перевіряє, чи властивість length дорівнює 0.

Поєднання відповідей від @inkednm в одну функцію:

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

Порожня перевірка ключа JSON залежить від випадку використання. Для типового варіанту використання ми можемо перевірити наступне:

1. Ні null
2. Ні undefined
3. Не порожній рядок ''
4. Не порожній об’єкт {} [] (масив - це об’єкт)

Функція:

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

Повернути істину для:

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

просто помістіть змінну всередині умови if, якщо змінна має якесь значення, вона поверне true true false.

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

А як щодо цього.

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

Це залежить від того, що ви маєте на увазі під «порожнім». Найпоширеніший шаблон - перевірити, чи не є невизначеною змінною . Багато людей також виконують нульову перевірку, наприклад:
if (myVariable === undefined || myVariable === null)...

або, у коротшій формі:
if (myVariable || myVariable === null)...

if (myVar == undefined)

буде працювати, щоб перевірити, чи оголошено var, але не ініціалізовано.

Перевірка на невизначеність:

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

Це зробило б еквівалент vb IsEmpty. Якщо myvar містить будь-яке значення, навіть нульове, порожній рядок або 0, воно не є "порожнім".

Щоб перевірити, чи існує змінна або властивість, наприклад, вона була оголошена, хоча, можливо, вона не була визначена, ви можете використовувати inоператор.

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

Якщо ви шукаєте еквівалент функції PHP empty, перевірте це:

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

що мені бракує, якщо порожній масив ... безключовий об'єкт ... falseness const isEmpty = o => Array.isArray (o) &&! o.join (''). length || typeof o === 'object' &&! Object.keys (o) .length || ! (+ значення);

Ось більш просте (коротке) рішення для перевірки порожніх змінних. Ця функція перевіряє, чи змінна порожня. Надана змінна може містити змішані значення (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;