Проверить что-то пустое в 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) Возвращает истину, если перечисляемый объект не содержит значений (нет перечисляемых собственных свойств). Для строк и объектов, подобных массиву, _.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, иначе 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 содержит какое-либо значение, даже null, пустую строку или 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

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

Вот более простое (короткое) решение для проверки пустых переменных. Эта функция проверяет, пуста ли переменная. Предоставленная переменная может содержать смешанные значения (null, undefined, массив, объект, строка, целое число, функция).

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;