如何在 Javascript 中检查变量是否为空？
if(response.photo) is empty {
do something
else {
do something else
}
response.photo 来自 JSON，有时它可能是空的，空数据单元格！我想检查它是否为空。
【问题讨论】：
false？
PHPs empty() 函数的 JavaScript 实现，以更易读的方式。 stackoverflow.com/a/33319704/3779853
标签： javascript jquery
如果您正在测试空字符串：
if(myVar === ''){ // do stuff };
如果您正在检查已声明但未定义的变量：
if(myVar === null){ // do stuff };
如果您正在检查可能未定义的变量：
if(myVar === undefined){ // do stuff };
如果您同时检查两者，即任一变量为空或未定义：
if(myVar == null){ // do stuff };
【讨论】：
undefined“常量”，因为它根本不是常量。请改用typeof myVar === 'undefined'。
var undefined = 1; 将打破您的第三个示例。始终使用typeof 并检查"undefined"。
if(typeof variable === "undefined")
这是一个比你想象的更大的问题。变量可以通过多种方式清空。有点取决于你需要知道什么。
// 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;
}
【讨论】：
!x 不适用于空数组。
这应该涵盖所有情况：
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，请检查您的浏览器支持。
如果满足以下条件之一，则以下解决方案认为变量为空：
false，它已经涵盖了很多东西，例如0、""、[]，甚至[""] 和[0]
null 或者它的类型是'undefined'
它是一个对象/数组，仅由自身为空的值组成（即分解为基元，每个部分都等于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))
);
}
【讨论】：
[{},0,""]。这里的所有其他解决方案都只是两条不走远的线和一个适用于对象并需要库的下划线函数。
这是我最简单的解决方案。
灵感来自 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【讨论】：
@SJ00 更易读的版本@答案：
/**
* 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
);
}
【讨论】：
见http://underscorejs.org/#isEmpty
isEmpty_.isEmpty(对象) 如果可枚举对象不包含任何值（没有可枚举的自身属性），则返回 true。对于字符串和类似数组的对象，_.isEmpty 检查长度属性是否为 0。
【讨论】：
将来自@inkednm 的答案组合成一个函数：
function isEmpty(property) {
return (property === null || property === "" || typeof property === "undefined");
}
【讨论】：
property == null 对null 和undefined 进行联合检查
对 JSON 密钥的空检查取决于用例。对于一个常见的用例，我们可以测试以下内容：
null
undefined
''
{}[]（数组是一个对象）
功能：
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({}) === "{}"
【讨论】：
这取决于您所说的“空”是什么意思。最常见的模式是检查变量是否为undefined。很多人也做空检查，例如：if (myVariable === undefined || myVariable === null)...
或者，更短的形式：if (myVariable || myVariable === null)...
【讨论】：
undefined“常数”，因为它根本不是常数。请改用typeof myVar === 'undefined'。
if (myVar == undefined)
将检查变量是否已声明但未初始化。
【讨论】：
undefined 可以在代码中重新定义（即undefined = true 有效）。
undefined“常数”，因为它根本不是常数。请改用typeof myVar === 'undefined'。
检查未定义：
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;
}
【讨论】：
如果空数组...无键对象...虚假，我会错过什么 const isEmpty = o => Array.isArray(o) && !o.join('').length || typeof o === 'object' && !Object.keys(o).length || !(+值);
【讨论】：
这是一个检查空变量的更简单（简短）的解决方案。此函数检查变量是否为空。提供的变量可能包含混合值（空、未定义、数组、对象、字符串、整数、函数）。
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;
【讨论】：
function isEmpty(variable) {
const type = typeof variable
if (variable === null) return true
if (type === 'undefined') return true
if (type === 'boolean') return false
if (type === 'string') return !variable
if (type === 'number') return false
if (Array.isArray(variable)) return !variable.length
if (type === 'object') return !Object.keys(variable).length
return !variable
}【讨论】：
我的解决方案：
function isEmpty(object) {
return (
(!object)
|| (object === undefined)
|| (object === null)
|| (object === '')
|| ((object?.length !== undefined) && (object.length === 0))
|| (typeof object === 'object' && Object.keys(object).length === 0)
);
}
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);
});
})
【讨论】：