是否有标准函数来检查 JavaScript 中的 null、未定义或空白变量？

您可以检查 变量 是否具有 truthy 值。这意味着

if( value ) {
}

如果 value 不是，将评估为 true：

无效的

不明确的

钠

空字符串 ("")

0

错误的

上面的列表代表了 ECMA-/Javascript 中所有可能的 falsy 值。在 ToBoolean 部分的 specification 中找到它。

此外，如果您不知道变量是否存在（也就是说，如果它被声明），您应该检查 typeof 运算符。例如

if( typeof foo !== 'undefined' ) {
    // foo could get resolved and it's defined
}

如果您可以确定至少声明了一个 变量，则应直接检查它是否具有如上所示的 truthy 值。

---

检查值是否未定义或为空的详细方法是：

return value === undefined || value === null;

您也可以使用 == 运算符，但这需要一个 know all the rules：

return value == null; // also returns true if value is undefined

---

function isEmpty(value){
  return (value == null || value.length === 0);
}

这将返回 true

undefined  // Because undefined == null

null

[]

""

和零参数函数，因为函数的 length 是它采用的声明参数的数量。

要禁止后一类，您可能只想检查空白字符串

function isEmpty(value){
  return (value == null || value === '');
}

---

这是最安全的检查，我还没有看到它像这样张贴在这里：

if (typeof value !== 'undefined' && value) {
    //deal with value'
};

它将涵盖从未定义价值的情况，以及以下任何一种情况：

无效的

未定义（未定义的值与从未定义的参数不同）

0

""（空字符串）

错误的

钠

已编辑：更改为严格相等（！==），因为这是现在的规范；）

---

您可能会发现以下功能很有用：

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

或者在 ES7 中（如果有进一步改进，请评论）

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

结果：

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

“请注意，绑定运算符 (::) 不是 ES2016 (ES7) 的一部分，也不是任何更高版本的 ECMAScript 标准。目前它是引入该语言的阶段 0（草编）提案。” ——西蒙·凯尔伯格。作者希望加入他对这一美丽提议的支持，以接受皇室提升。

---

评分最高的第一个答案是错误的。如果 value 未定义，它将在现代浏览器中引发异常。你必须使用：

if (typeof(value) !== "undefined" && value)

或者

if (typeof value  !== "undefined" && value)

---

我非常喜欢的一个解决方案：

让我们定义一个空白变量是 null 或 undefined，或者如果它有长度，它是零，或者如果它是一个对象，它没有键：

function isEmpty (value) {
  return (
    // null or undefined
    (value == null) ||

    // has length and it's zero
    (value.hasOwnProperty('length') && value.length === 0) ||

    // is an Object and has no keys
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

回报：

真：未定义，空，“”，[]，{}

假：真，假，1、0、-1、“富”、[1、2、3]、{富：1}

---

此条件检查

if (!!foo) {
    //foo is defined
}

是你所需要的全部。

---

看看新的 ECMAScript Nullish 合并运算符

您可以将此功能 - ?? 运算符 - 视为在处理 null 或 undefined 时“回退”到默认值的一种方式。

let x = foo ?? bar();

同样，上面的代码等价于下面的代码。

let x = (foo !== null && foo !== undefined) ? foo : bar();

---

! 检查 空字符串 ("")、null、undefined、false 以及数字 0 和 NaN。 说，如果字符串为空 var name = "" 则 console.log(!name)返回 true。

function isEmpty(val){
  return !val;
}

如果 val 为空、null、未定义、false、数字 0 或 NaN，此函数将返回 true。

或者

根据您的问题域，您可以使用 !val 或 !!val。

---

你有点过头了。要检查一个变量是否没有赋值，你只需要检查 undefined 和 null。

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

这是假设 0、"" 和对象（甚至是空对象和数组）都是有效的“值”。

---

空虚

我不建议尝试定义或使用计算整个世界中的任何值是否为空的函数。 “空”的真正含义是什么？如果我有 let human = { name: 'bob', stomach: 'empty' }，是否应该 isEmpty(human) 返回 true？如果我有 let reg = new RegExp('');，isEmpty(reg) 是否应该返回 true？ isEmpty([ null, null, null, null ]) 怎么样 - 这个列表只包含空，所以列表本身是空的吗？我想在这里提出一些关于 javascript 中“空洞”（一个故意模糊不清的词，以避免预先存在的关联）的注释 - 我想争辩说 javascript 值中的“空洞”永远不应该被笼统地处理。

真/假

为了决定如何确定值的“空性”，我们需要适应 javascript 内置的、固有的值是“真”还是“假”的感觉。自然地，null 和 undefined 都是“假的”。不太自然的是，数字 0（除了 NaN 没有其他数字）也是“假的”。最不自然：'' 是虚假的，但 [] 和 {}（以及 new Set() 和 new Map()）是真实的 - 尽管它们看起来都同样空洞！

空与未定义

还有一些关于 null 与 undefined 的讨论——我们真的需要两者来表达我们程序的空洞性吗？我个人避免在我的代码中出现 undefined。我总是用 null 来表示“空虚”。不过，我们需要再次适应 javascript 对 null 和 undefined 不同之处的固有认识：

尝试访问不存在的属性会给出未定义的

调用函数时省略参数会导致该参数接收未定义：

让 f = a => a;控制台.log(f('hi'));控制台.log(f());

具有默认值的参数仅在给定未定义而不是 null 时才接收默认值：

让 f = (v='你好') => v;控制台.log(f(null));控制台日志（f（未定义））；

对我来说，null 是空虚的明确表示； “本来可以填写的东西故意留空”。

确实 undefined 是允许某些 js 功能存在的必要复杂性，但在我看来 它应该始终留在幕后；没有直接互动。例如，我们可以将 undefined 视为 javascript 实现默认函数参数的机制。如果您不向函数提供参数，它将收到 undefined 的值。如果该参数最初设置为 undefined，则默认值将应用于函数参数。在这种情况下，undefined 是默认函数参数的关键，但它保留在后台：我们可以在不参考 undefined 的情况下实现默认参数功能：

这是默认参数的错误实现，因为它直接与 undefined 交互：

let fnWithDefaults = arg => {
  if (arg === undefined) arg = 'default';
  ...
};

这是一个很好的实现：

let fnWithDefaults = (arg='default') => { ... };

这是接受默认参数的不好方法：

fnWithDefaults(undefined);

只需这样做：

fnWithDefaults();

顺便说一句：您是否有一个具有多个参数的函数，并且您想提供一些参数同时接受其他参数的默认值？

例如：

let fnWithDefaults = (a=1, b=2, c=3, d=4) => console.log(a, b, c, d);

如果您想为 a 和 d 提供值并接受其他的默认值，该怎么办？这似乎是错误的：

fnWithDefaults(10, undefined, undefined, 40);

答案是：重构 fnWithDefaults 以接受单个对象：

let fnWithDefaults = ({ a=1, b=2, c=3, d=4 }={}) => console.log(a, b, c, d);
fnWithDefaults({ a: 10, d: 40 }); // Now this looks really nice! (And never talks about "undefined")

非泛型空洞

我相信空虚永远不应该以一种通用的方式来处理。相反，在确定数据是否为空之前，我们应该始终严格获取有关数据的更多信息——我主要通过检查我正在处理的数据类型来做到这一点：

let isType = (value, Cls) => { // 有意使用松散比较运算符检测 `null` // 和 `undefined`，仅此而已！返回值 != null && Object.getPrototypeOf(value).constructor === Cls; };

请注意，此函数忽略继承 - 它期望 value 是 Cls 的直接实例，而不是 Cls 子类的实例。我避免使用 instanceof 有两个主要原因：

([] instanceof Object) === true ("数组就是对象")

('' instanceof String) === false ("字符串不是字符串")

请注意，Object.getPrototypeOf 用于避免（模糊）边缘情况，例如 let v = { constructor: String };。对于 isType(v, String)（假）和 isType(v, Object)（真），isType 函数仍然正确返回。

总的来说，我建议将此 isType 函数与以下提示一起使用：

尽量减少未知类型的代码处理量。例如，对于 let v = JSON.parse(someRawValue);，我们的 v 变量现在是未知类型。我们应该尽早限制我们的可能性。最好的方法是要求特定类型：例如 if (!isType(v, Array)) throw new Error('Expected Array'); - 这是一种非常快速且富有表现力的方式来消除 v 的通用性，并确保它始终是一个数组。但是，有时我们需要允许 v 具有多种类型。在这些情况下，我们应该尽早创建 v 不再是泛型的代码块：

if (isType(v, String)) { /* v 在这个块中不是通用的 - 它是一个字符串！ */ } else if (isType(v, Number)) { /* v 在这个块中不是通用的 - 它是一个数字！ */ } else if (isType(v, Array)) { /* v 在这个块中不是通用的——它是一个数组！ */ } else { throw new Error('Expected String, Number, or Array'); }

始终使用“白名单”进行验证。如果您需要一个值，例如字符串、数字或数组，请检查这 3 种“白色”可能性，如果这 3 种都不满足，则抛出错误。我们应该能够看到检查“黑色”可能性并不是很有用：假设我们写 if (v === null) throw new Error('Null value denied'); - 这对于确保空值不会通过非常有用，但是如果一个值确实通过了，我们仍然对它几乎一无所知。通过这个空检查的值 v 仍然是非常通用的——它不是空的！黑名单很难消除通用性。

除非值为 null，否则永远不要考虑“空值”。相反，请考虑“一个空的 X”。从本质上讲，永远不要考虑做类似 if (isEmpty(val)) { /* ... */ } 之类的事情——不管这个 isEmpty 函数是如何实现的（我不想知道......），它都没有意义！而且太笼统了！真空度只能在知道 val 类型的情况下计算。 Vacuousness-checks 应该是这样的： "A string, with no chars": if (isType(val, String) && val.length === 0) ... "An Object, with 0 props": if (isType( val, Object) && Object.entries(val).length === 0) ... "一个数字，等于或小于零": if (isType(val, Number) && val <= 0) ... "一个没有项目的数组”： if (isType(val, Array) && val.length === 0) ... 唯一的例外是当 null 用于表示某些功能时。在这种情况下，说“空值”是有意义的： if (val === null) ...

"一个没有字符的字符串": if (isType(val, String) && val.length === 0) ...

“一个对象，有 0 个道具”： if (isType(val, Object) && Object.entries(val).length === 0) ...

“一个数字，等于或小于零”： if (isType(val, Number) && val <= 0) ...

“一个没有项目的数组”： if (isType(val, Array) && val.length === 0) ...

唯一的例外是当 null 用于表示某些功能时。在这种情况下，说“空值”是有意义的： if (val === null) ...

---

这是我的 - 如果值为 null、未定义等或空白（即仅包含空格），则返回 true：

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}

---

如果您更喜欢纯 javascript，请尝试以下操作：

  /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */

function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

否则，如果您已经在使用下划线或 lodash，请尝试：

_.isEmpty(value)

---

可能最短的答案是

val==null || val==''

如果您将右侧更改为 val===''，则空数组将给出错误。证明

函数 isEmpty(val){ 返回 val==null || val=='' } // ------------ // 测试 // ------------ var log = (name,val) => console.log (`${name} -> ${isEmpty(val)}`);日志（'空'，空）；日志（'未定义'，未定义）；日志（'NaN'，NaN）；日志（'””'， ””）;日志（'{}'， {}）;日志（'[]'， []）;日志('[1]', [1]);日志('[0]', [0]);日志（'[[]]'， [[]]）;日志（'真'，真）；日志（'假'，假）；日志（'“真”'，“真”）；日志('"假"', "假");日志（'无穷大'，无穷大）； log('-无穷大', -无穷大);日志（'1'，1）；日志（'0'，0）；日志（'-1'，-1）；日志('"1"', "1");日志('"0"', "0");日志('"-1"', "-1"); // "void 0" case console.log('---\n"true" is:', true); console.log('"void 0" is:', void 0);日志（无效 0，无效 0）； // "void 0" 是 "undefined" - 所以我们应该到这里 TRUE

关于 == 的更多详情（来源 here）

https://i.stack.imgur.com/nkpj6.png

奖励：=== 比 == 更清楚的原因

https://i.stack.imgur.com/7MeG6.png

要编写清晰易懂的代码，请使用明确的接受值列表

val===undefined || val===null || val===''|| (Array.isArray(val) && val.length===0)

function isEmpty(val){ return val===undefined || val===null || val==='' || (Array.isArray(val) && val.length===0) } // ------------ // 测试 // ------------ var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);日志（'空'，空）；日志（'未定义'，未定义）；日志（'NaN'，NaN）；日志（'””'， ””）;日志（'{}'， {}）;日志（'[]'， []）;日志('[1]', [1]);日志('[0]', [0]);日志（'[[]]'， [[]]）;日志（'真'，真）；日志（'假'，假）；日志（'“真”'，“真”）；日志('"假"', "假");日志（'无穷大'，无穷大）； log('-无穷大', -无穷大);日志（'1'，1）；日志（'0'，0）；日志（'-1'，-1）；日志('"1"', "1");日志('"0"', "0");日志('"-1"', "-1"); // "void 0" case console.log('---\n"true" is:', true); console.log('"void 0" is:', void 0);日志（无效 0，无效 0）； // "void 0" 是 "undefined" - 所以我们应该到这里 TRUE

---

return val || 'Handle empty variable'

是在很多地方处理它的一种非常好的和干净的方式，也可以用于分配变量

const res = val || 'default value'

---

如果尚未声明变量，您将无法使用函数测试未定义，因为您会收到错误消息。

if (foo) {}
function (bar) {}(foo)

如果 foo 没有被声明，两者都会产生错误。

如果要测试是否已声明变量，可以使用

typeof foo != "undefined"

如果你想测试 foo 是否已经被声明并且它有一个你可以使用的值

if (typeof foo != "undefined" && foo) {
    //code here
}

---

检查默认值

function typeOfVar (obj) {
      return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
function isVariableHaveDefaltVal(variable) {
    if ( typeof(variable) === 'string' ) {  // number, boolean, string, object 
        console.log(' Any data Between single/double Quotes is treated as String ');        
        return (variable.trim().length === 0) ? true : false;
    }else if ( typeof(variable) === 'boolean' ) {
      console.log('boolean value with default value \'false\'');
        return (variable === false) ? true : false;
    }else if ( typeof(variable) === 'undefined' ) {
        console.log('EX: var a; variable is created, but has the default value of undefined.'); 
        return true;
    }else if ( typeof(variable) === 'number' ) { 
        console.log('number : '+variable);
        return (variable === 0 ) ? true : false;
    }else if ( typeof(variable) === 'object' ) {
   //   -----Object-----
        if (typeOfVar(variable) === 'array' && variable.length === 0) {
            console.log('\t Object Array with length = ' + [].length); // Object.keys(variable)
            return true;
        }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) {
            console.log('\t Object String with length = ' + variable.length);
            return true;
        }else if (typeOfVar(variable) === 'boolean' ) {
            console.log('\t Object Boolean = ' + variable);
            return (variable === false) ? true : false;
        }else if (typeOfVar(variable) === 'number' ) {
            console.log('\t Object Number = ' + variable);
            return (variable === 0 ) ? true : false;
        }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) {
       console.log('\t Object Regular Expression : ');
        return true;
        }else if (variable === null) {
       console.log('\t Object null value');
        return true;
        }
    }
    return false;
}
var str = "A Basket For Every Occasion";
str = str.replace(/\s/g, "-");
//The "g" flag in the regex will cause all spaces to get replaced.

检查结果：

isVariableHaveDefaltVal(' '); // string          
isVariableHaveDefaltVal(false); // boolean       
var a;           
isVariableHaveDefaltVal(a);               
isVariableHaveDefaltVal(0); // number             
isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true         
isVariableHaveDefaltVal(null);              
isVariableHaveDefaltVal([]);               
isVariableHaveDefaltVal(/ /);              
isVariableHaveDefaltVal(new Object(''));               
isVariableHaveDefaltVal(new Object(false));            
isVariableHaveDefaltVal(new Object(0)); 
typeOfVar( function() {} );

我使用@Vix function() 来检查对象的类型。

使用实例 «

var prototypes_or_Literals = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            else if (obj instanceof Date)
                return '[object Date]';
            else if (obj instanceof RegExp)
                return '[object regexp]';
            else if (obj instanceof String)
                return '[object String]';
            else if (obj instanceof Number)
                return '[object Number]';

            else
                return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};
output test «
prototypes_or_Literals( '' ) // "string"
prototypes_or_Literals( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"        

---

function isEmpty(obj) {
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
    else return !obj;
}

在 ES6 中使用 trim 处理空白字符串：

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}

---

它可能有用。

数组中的所有值都代表您想要成为的内容（null、未定义或其他内容），您可以在其中搜索您想要的内容。

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1

---

您可以使用空值合并运算符 ?? 检查 null 和 undefined 值。请参阅MDN Docs

null ?? 'default string'; // returns "default string"

0 ?? 42;  // returns 0

(null || undefined) ?? "foo"; // returns "foo"

---

如果您正在使用 TypeScript 并且不想考虑 "那些是 false" 的值，那么这是适合您的解决方案：

第一个：import { isNullOrUndefined } from 'util';

然后：isNullOrUndefined(this.yourVariableName)

请注意：如前所述，below 现在已弃用，请改用 value === undefined || value === null。 ref。

---

尝试不同的逻辑。您可以使用波纹管代码检查所有四 (4) 个条件以进行验证，例如非空、非空白、非未定义和非零仅在 javascript 和 jquery 中使用此代码 (!(!(variable)))。

function myFunction() {
    var data;  //The Values can be like as null, blank, undefined, zero you can test

    if(!(!(data)))
    {
        alert("data "+data);
    } 
    else 
    {
        alert("data is "+data);
    }
}

---

当引用或函数可能未定义或为空时，可选链接运算符提供了一种简化通过连接对象访问值的方法。

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

可以在可选链接之后使用 nullish 合并运算符，以便在未找到时构建默认值：

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city

---

function isEmpty(val){
    return !val;
}

但是这个解决方案是过度设计的，如果您不想稍后修改该功能以满足业务模型的需要，那么直接在代码中使用它会更干净：

if(!val)...

---

var myNewValue = myObject && myObject.child && myObject.child.myValue;

这永远不会抛出错误。如果 myObject、child 或 myValue 为 null，则 myNewValue 将为 null。不会抛出任何错误

---

对于每个来这里有类似问题的人来说，以下工作很好，我在过去几年的图书馆里有它：

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object's constructor.
* @module {g3.utils}
* @function {g3.utils.type}
* @public
* @param {Type} 'obj' is any type native, host or custom.
* @return {String} Returns a lowercase string representing the object's 
* constructor which is different from word 'object' if they are not custom.
* @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
* http://stackoverflow.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript
* http://javascript.info/tutorial/type-detection
*******************************************************************************/
g3.utils.type = function (obj){
   if(obj === null)
      return 'null';
   else if(typeof obj === 'undefined')
      return 'undefined';
   return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));

---

如果您想避免在值是以下任何一种情况下为真，请根据 jAndy's answer：

无效的

不明确的

钠

空字符串 ("")

0

错误的

一种可能避免获得真实值的可能解决方案如下：

function isUsable(valueToCheck) {
    if (valueToCheck === 0     || // Avoid returning false if the value is 0.
        valueToCheck === ''    || // Avoid returning false if the value is an empty string.
        valueToCheck === false || // Avoid returning false if the value is false.
        valueToCheck)             // Returns true if it isn't null, undefined, or NaN.
    {
        return true;
    } else {
        return false;
    }
}

它将按如下方式使用：

if (isUsable(x)) {
    // It is usable!
}
// Make sure to avoid placing the logical NOT operator before the parameter (isUsable(!x)) and instead, use it before the function, to check the returned value.
if (!isUsable(x)) {
    // It is NOT usable!
}

除了这些场景之外，如果对象或数组为空，您可能希望返回 false：

对象：{}（使用 ECMA 7+）

数组：[]（使用 ECMA 5+）

你会这样做：

function isEmptyObject(valueToCheck) {
    if(typeof valueToCheck === 'object' && !Object.keys(valueToCheck).length){
        // Object is empty!
        return true;
    } else {
        // Object is not empty!
        return false;
    }
}

function isEmptyArray(valueToCheck) {
    if(Array.isArray(valueToCheck) && !valueToCheck.length) {
        // Array is empty!
        return true;
    } else {
        // Array is not empty!
        return false;
    }
}

如果您希望检查所有空白字符串 (" ")，您可以执行以下操作：

function isAllWhitespace(){
    if (valueToCheck.match(/^ *$/) !== null) {
        // Is all whitespaces!
        return true;
    } else {
        // Is not all whitespaces!
        return false;
    }
}

注意：hasOwnProperty 对于空字符串、0、false、NaN、null 和 undefined，如果变量被声明为它们中的任何一个，则返回 true，因此它可能不是最好的使用。可以修改该函数以使用它来显示它已声明但不可用。

---

Code on GitHub

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)

  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);

// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

穷人的测试😁

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };

  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];

  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

试验结果：

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]

---

function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

它还将检查空格（''）以及以下内容：

null ,undefined ,NaN ,empty ,string ("") ,0 ,false

---