在 Javascript 中检查某些内容是空的？

Check for undefined:

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

This would do the equivelant of vb's IsEmpty. If myvar contains any value, even null, empty string, or 0, it is not "empty".

To check if a variable or property exists, eg it's been declared, though it may be not have been defined, you can use the in operator.

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

It depends on what you mean by "empty". The most common pattern is to check to see if the variable is undefined. Many people also do a null check, for example:
if (myVariable === undefined || myVariable === null)...

or, in a shorter form:
if (myVariable || myVariable === null)...

If you're testing for an empty string:

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

If you're checking for a variable that has been declared, but not defined:

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

If you're checking for a variable that may not be defined:

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

If you're checking both i.e, either variable is null or undefined:

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

if (myVar == undefined)

will work to see if the var is declared but not initalized.

If you're looking for the equivalent of PHP's empty function, check this out:

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

This is a bigger question than you think. Variables can empty in a lot of ways. Kinda depends on what you need to know.

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

This should cover all cases:

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

See http://underscorejs.org/#isEmpty

isEmpty_.isEmpty(object) Returns true if an enumerable object contains no values (no enumerable own-properties). For strings and array-like objects _.isEmpty checks if the length property is 0.

I see potential shortcomings in many solutions posted above, so I decided to compile my own.
Note: it uses Array.prototype.some, check your browser support.

Solution below considers variable empty if one of the following is true:

1. JS thinks that variable is equal to false, which already covers many things like 0, "", [], and even [""] and [0]
2. Value is null or it's type is 'undefined'
3. It is an empty Object

4. It is an Object/Array consisting only of values that are empty themselves (i.e. broken down to primitives each part of it equals false). Checks drill recursively into Object/Array structure. E.g.

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

Function code:

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

what am I missing if empty array... keyless object... falseness const isEmpty = o => Array.isArray(o) && !o.join('').length || typeof o === 'object' && !Object.keys(o).length || !(+value);

just put the variable inside the if condition, if variable has any value it will return 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");
};

What about doing like this.

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

Here's a simpler(short) solution to check for empty variables. This function checks if a variable is empty. The variable provided may contain mixed values (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

Combining answers from @inkednm into one function:

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

const isEmpty = val => val == null || !(Object.keys(val) || val).length;

Here my simplest solution.

Inspired by PHP empty function

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

Empty check on a JSON's key depends on use-case. For a common use-case, we can test for following:

1. Not null
2. Not undefined
3. Not an empty String ''
4. Not an empty Object {} [] (Array is an Object)

Function:

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

Return true for:

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

A more readable version of @SJ00 answer:

/**
* Checks if a JavaScript value is empty
* @example
*    isEmpty(null); // true
*    isEmpty(undefined); // true
*    isEmpty(''); // true
*    isEmpty([]); // true
*    isEmpty({}); // true
* @param {any} value - item to test
* @returns {boolean} true if empty, otherwise false
*/
function isEmpty(value) {
return (
value === null || // check for null
value === undefined || // check for undefined
value === '' || // check for empty string
(Array.isArray(value) && value.length === 0) || // check for empty array
(typeof value === 'object' && Object.keys(value).length === 0) // check for empty object
);
}

My solution:

function isEmpty(object) {
return (
(!object)
|| (object === undefined)
|| (object === null)
|| (object === '')
|| ((object?.length !== undefined) && (object.length === 0))
|| (typeof object === 'object' && Object.keys(object).length === 0)
);
}

Tests with Jest:

describe('isEmpty should return `false` when the parameter have some truthy value.', () => {
test('Empty objects should return true', () => {
expect(utils.isEmpty([])).toBe(true);
expect(utils.isEmpty({})).toBe(true);
expect(utils.isEmpty('')).toBe(true);
expect(utils.isEmpty(undefined)).toBe(true);
expect(utils.isEmpty(null)).toBe(true);
});


test('Truthy objects should return false', () => {
expect(utils.isEmpty([1])).toBe(false);
expect(utils.isEmpty({a: undefined})).toBe(false);
expect(utils.isEmpty({a: 5})).toBe(false);
expect(utils.isEmpty({a: 5, b: 6, c: undefined})).toBe(false);
expect(utils.isEmpty('f00')).toBe(false);
expect(utils.isEmpty('0')).toBe(false);
});
})

var message_1 = message.trim();
if (message_1.length > 0) {
// to do
}

just be careful with all what i see here:

typeof object === 'object' && Object.keys(object).length === 0) is indeed checking if an object is Empty. But did you know that Date in javascript are considered object also?

so if you do:

const shouldNotbeEmpty = new Date(Date.now())
isEmpty(shouldNotbeEmpty) // this will return true when it should not

my only way to figure it out to fix that was to check if the object is a Date instance:

typeof value === "object" && Object.keys(value).length === 0 && !value instanceof Date

so something like this:

const isObject = value => typeof value === "object" && Object.keys(value).length === 0
const isString = value => typeof value === "string" && value.trim().length === 0
const isEmpty = value => {
const isDate = value instanceof Date
return value === undefined || value === null || (isObject(value) && !isDate) || isString(value)
}


exports.isEmpty = isEmpty

const isEmpty = value => {
if (!value && value !== 0) return true
if(Array.isArray(value)){
if(!value.length) return true
return value.every(isEmpty)
}
if (typeof value === 'object') {
return Object.values(value).every(isEmpty)
}
return false
}


isEmpty(); // true
isEmpty(undefined); // true
isEmpty(null); // true
isEmpty(0); // false
isEmpty(1); // false
isEmpty(''); // true
isEmpty('a'); // false
isEmpty([]); // true
isEmpty([0]); // false
isEmpty([1]); // false
isEmpty([[]]); // true
isEmpty([[], []]); // true
isEmpty([[], null, undefined]); // true
isEmpty([[], 1]); // false
isEmpty({}); // true
isEmpty({a: 1}); // false
isEmpty({a: 1, b: 2}); // false
isEmpty({a: 1, b: {}}); // false
isEmpty({a: null, b: [], c: undefined}); // true
isEmpty({a: {}, b: {}, c: {}}); // true
isEmpty(() => {}) // false