Kiểm tra một cái gì đó isEmpty trong Javascript?

Làm cách nào để kiểm tra xem một biến có trống trong Javascript không? Xin lỗi vì câu hỏi ngu ngốc, nhưng tôi là người mới trong Javascript!

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

response.photolà từ JSON và đôi khi nó có thể trống, các ô dữ liệu trống! Tôi muốn kiểm tra xem nó có trống không.

Nếu bạn đang kiểm tra một chuỗi trống:

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

Nếu bạn đang kiểm tra một biến đã được khai báo nhưng chưa được xác định:

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

Nếu bạn đang kiểm tra một biến có thể không được xác định:

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

Nếu bạn đang kiểm tra cả hai nghĩa là, một trong hai biến là null hoặc không xác định:

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

Đây là một câu hỏi lớn hơn bạn nghĩ. Các biến có thể làm trống theo nhiều cách. Kinda phụ thuộc vào những gì bạn cần biết.

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

Điều này sẽ bao gồm tất cả các trường hợp:

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

Tôi thấy những thiếu sót tiềm ẩn trong nhiều giải pháp được đăng ở trên, vì vậy tôi quyết định biên dịch cho riêng mình.
Lưu ý: nó sử dụng Array.prototype.some , hãy kiểm tra hỗ trợ trình duyệt của bạn.

Giải pháp dưới đây coi biến trống nếu một trong những điều sau là đúng:

1. JS nghĩ biến đó là tương đương với false, mà đã bao gồm nhiều thứ như 0, "", [], và thậm chí [""]và[0]
2. Giá trị là nullhoặc loại của nó là'undefined'
3. Nó là một đối tượng rỗng

4. Nó là một Đối tượng / Mảng chỉ bao gồm các giá trị tự trống (nghĩa là được chia nhỏ thành các phần nguyên thủy mà mỗi phần của nó bằng nhau false). Kiểm tra đệ quy mũi khoan vào cấu trúc Đối tượng / Mảng. Ví dụ

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

Mã chức năng:

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

Đây là giải pháp đơn giản nhất của tôi.

Lấy cảm hứng từ hàm 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

Xem http://underscorejs.org/#isEmpty

isEmpty_.isEmpty (đối tượng) Trả về true nếu một đối tượng có thể liệt kê không chứa giá trị (không có thuộc tính riêng có thể liệt kê). Đối với các chuỗi và các đối tượng dạng mảng, _.isEmpty kiểm tra xem thuộc tính length có bằng 0 hay không.

Kết hợp các câu trả lời từ @inkednm thành một hàm:

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

Kiểm tra trống trên khóa của JSON tùy thuộc vào trường hợp sử dụng. Đối với một trường hợp sử dụng phổ biến, chúng tôi có thể kiểm tra những điều sau:

1. không phải null
2. không phải undefined
3. Không phải là một chuỗi trống ''
4. Không phải là một đối tượng rỗng {} [] (Mảng là một đối tượng)

Chức năng:

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

Trả về true cho:

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

chỉ cần đặt biến bên trong điều kiện if, nếu biến có bất kỳ giá trị nào thì nó sẽ trả về true, else false.

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

Làm như thế này thì sao.

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

Nó phụ thuộc vào những gì bạn có nghĩa là "trống rỗng". Mẫu phổ biến nhất là kiểm tra xem biến có phải là không xác định hay không . Nhiều người cũng kiểm tra null, ví dụ:
if (myVariable === undefined || myVariable === null)...

hoặc ở dạng ngắn hơn:
if (myVariable || myVariable === null)...

if (myVar == undefined)

sẽ hoạt động để xem liệu var có được khai báo nhưng không được phát sinh hay không.

Kiểm tra không xác định:

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

Điều này sẽ làm tương đương với vb's IsEmpty. Nếu myvar chứa bất kỳ giá trị nào, kể cả null, chuỗi rỗng hoặc 0, thì nó không phải là "trống".

Để kiểm tra xem một biến hoặc thuộc tính có tồn tại hay không, ví dụ như nó đã được khai báo, mặc dù nó có thể chưa được định nghĩa, bạn có thể sử dụng intoán tử.

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

Nếu bạn đang tìm kiếm emptychức năng tương đương của PHP , hãy xem phần này:

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

Tôi thiếu gì nếu mảng trống ... đối tượng không khóa ... falseness const isEmpty = o => Array.isArray (o) &&! o.join (''). length || typeof o === 'object' &&! Object.keys (o) .length || ! (+ giá trị);

Đây là một giải pháp đơn giản hơn (ngắn gọn) để kiểm tra các biến trống. Hàm này kiểm tra xem một biến có trống không. Biến được cung cấp có thể chứa các giá trị hỗn hợp (null, không xác định, mảng, đối tượng, chuỗi, số nguyên, hàm).

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;