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

if (value) {
    // do something..
}

如果值不是：

无效的未定义NaN公司空字符串（“”）0假的

上面的列表表示ECMA-/Javascript中所有可能的错误值。在ToBoolean部分的规范中找到它。

此外，如果您不知道变量是否存在（也就是说，如果声明了变量），则应使用typeof运算符进行检查。例如

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

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

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

对于

undefined  // Because undefined == null

null

[]

""

和零参数函数，因为函数的长度是它所使用的声明参数的数量。

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

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

Null或空白

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

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

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

您也可以使用==运算符，但这需要您了解所有规则：

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

你做得有点过头了。要检查变量是否没有给定值，只需要检查undefined和null。

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

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

如果变量尚未声明，则无法使用函数测试未定义，因为会出现错误。

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

如果尚未声明foo，则两者都将生成错误。

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

typeof foo != "undefined"

如果您想测试foo是否已声明，并且它有一个值，您可以使用

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

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

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

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

无效的undefined（未定义的值与从未定义的参数不同）0“”（空字符串）假的NaN公司

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

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

function stringIsEmpty(value) {

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

}

第一个评分最好的答案是错误的。若值未定义，则会在现代浏览器中引发异常。您必须使用：

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

or

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

! 检查空字符串（“”）、null、undefined、false以及数字0和NaN。例如，如果字符串为空var name=“”，那么console.log（！name）返回true。

function isEmpty(val){
  return !val;
}

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

OR

根据您的问题域，您可以使用like！val或！！价值。

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

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阶段（strawman）建议。”–Simon Kjellberg。作者希望补充他对这个接受王室提升的美好提议的支持。

此条件检查

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

这就是你所需要的。

如果您喜欢纯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)

检查默认值

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函数（）来检查哪种类型的对象。

使用instansof«

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]"        

我认为使用？操作员稍微干净一点。

var ? function_if_exists() : function_if_doesnt_exist();

这将检查不确定嵌套的变量是否未定义

function Undef(str) 
{
  var ary = str.split('.');
  var w = window;
  for (i in ary) {
    try      { if (typeof(w = w[ary[i]]) === "undefined") return true; }
    catch(e) { return true; }
  }
  return false;
}

if (!Undef("google.translate.TranslateElement")) {

上面检查Google翻译函数TranslateElement是否存在。这相当于：

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {

对于我的案例，我尝试了if null，“”！变量，但它不起作用。

查看下面的代码以从html字段获取文本

var status=$(this).text(); //for example (for my case)

如果状态变量中没有值（没有文本），我试图将值“novalue”设置为状态变量。

以下代码有效。

if(status == false)
{
   status='novalue';
} 

当没有找到satus变量的文本时，上面的代码将“novalue”分配给状态变量

虽然是老掉牙，但忘记的是他们应该包装代码块，然后捕捉错误，然后测试。。。

function checkup( t ){
  try{
    for(p in t){
      if( p.hasOwnProperty( t ) ){
        return true;
      }
    }
    return false;
  }catch(e){
    console.log("ERROR : "+e);
    return e;
  }
}

因此，你真的不必事先检查潜在的问题，你只需抓住它，然后按照你想要的方式处理它。

function isEmpty(val){
    return !val;
}

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

if(!val)...

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

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

对于每一个有类似问题的人来说，以下内容非常有用，我在过去的几年里都把它放在了我的图书馆里：

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

这可能很有用。

数组中的所有值都表示您想要的值（空值、未定义值或其他值），您可以在其中搜索所需的值。

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

此函数检查空对象｛｝、空数组[]、空、未定义和空字符串“”

function isEmpty(val) {
  //check for empty object {}, array []
  if (val !== null && typeof val === 'object') {
    if (Object.keys(obj).length === 0) {
      return true;
    }
  }
  //check for undefined, null and "" 
  else if (val == null || val === "") {
    return true;
  }
  return false;
}

var val={}；isEmpty（val）->trueval=[]；isEmpty（val）->trueisEmpty（未定义）->trueisEmpty（null）->trueisEmpty（“”）->trueisEmpty（false）->falseisEmpty（0）->false

可以直接使用相等运算符

<script>
    var firstName;
    var lastName = null;
    /* Since null == undefined is true, the following statements will catch both null and undefined */
        if(firstName == null){
            alert('Variable "firstName" is undefined.');
        }    
        if(lastName == null){
           alert('Variable "lastName" is null.');
        }
</script>

demo@如何使用JavaScript确定变量是否未定义或为空

尝试使用不同的逻辑。您可以使用下面的代码检查所有四（4）个验证条件，如非空、非空、未定义和非零。仅在javascript和jquery中使用此代码（！（！（变量））。

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

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
}

如果您正在使用TypeScript，并且不想考虑“值为假”，那么这就是您的解决方案：

首先：从“util”导入｛isNullOrUndefined｝；

然后：isNullOrUndefined（this.yourVariableName）

请注意：如下文所述，现在已弃用此选项，请改用value==undefined||value==null。裁判。

try{

     let vari = obj.propTest; // obj may be don't have propTest property

        ...
} catch(NullException){
    // do something here
}

我认为使用try-catch可以避免任何空检查错误，在Angular或JavaScript中也是如此只是捕获空异常并在其中处理。

return val || 'Handle empty variable'

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

const res = val || 'default value'

我非常喜欢的解决方案：

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

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

退货：

true:undefined，null，“”，[]，｛｝false：true，false，1，0，-1，“foo”，[1，2，3]，｛foo:1｝

真空度

我不建议尝试定义或使用计算整个世界中任何值是否为空的函数。“空”到底意味着什么？如果我让human＝｛name:‘bob’，gast:‘empty’｝，isEmpty（human）是否应该返回true？如果我让reg=new RegExp（''）；，isEmpty（reg）是否应返回true？isEmpty（[null，null，null，null]）怎么样？这个列表只包含空，所以列表本身是空的吗？我想在这里提出一些关于javascript中的“真空性”（一个故意模糊的词，以避免预先存在的关联）的注释，并且我想指出，javascript值中的“空洞性”永远不应该被笼统地处理。

---

真实/虚假

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

---

空与未定义

还有一些关于空和未定义的讨论——我们真的需要这两者来表达程序中的空洞吗？我个人避免在代码中出现undefined。我总是用null表示“空虚”。然而，我们再次需要适应javascript对null和undefined的区别的固有感觉：

尝试访问不存在的属性时，未定义调用函数时省略参数会导致该参数接收到未定义的：

设f=a=>a；控制台日志（f（'hi'））；console.log（f（））；

具有默认值的参数仅在给定未定义而非空时接收默认值：

设f=（v='hello'）=>v；console.log（f（null））；console.log（f（未定义））；

对我来说，空是空虚的一个明确的能指；“本可以填写的内容故意留空”。

真正的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")

---

非通用真空度

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

让isType=（value，Cls）=>{//有意使用松散比较运算符检测到`null`//和“undefined”，没有别的！返回值！=null&&Object.getPrototypeOf（值）.cconstructor==Cls；};

注意，此函数忽略继承-它希望值是Cls的直接实例，而不是Cls子类的实例。我避免实例化的原因有两个：

（[]instanceof Object）===true（“数组是一个对象”）（“”instanceof String）===false（“字符串不是字符串”）

注意，Object.getPrototypeOf用于避免（模糊的）边缘情况，例如let v={constructor:String}；isType函数仍然正确返回isType（v，String）（false）和isType（v，Object）（true）。

总之，我建议使用isType函数以及以下提示：

最小化未知类型的代码处理值的数量。例如，对于v=JSON.parse（someRawValue）；，我们的v变量现在是未知类型。我们应该尽早限制我们的可能性。最好的方法是要求特定类型：例如，如果（！isType（v，Array））抛出新错误（“预期数组”）；-这是一种非常快速且富有表现力的方法，可以消除v的泛型性质，并确保它始终是一个数组。但有时，我们需要允许v具有多种类型。在这些情况下，我们应该尽早创建v不再通用的代码块：

if（isType（v，String））{/*v在这个块中不是通用的-它是一个字符串*/}否则如果（isType（v，Number））{/*v在这个块中不是通用的-它是一个数字*/}否则if（isType（v，Array））{/*v在这个块中不是通用的，它是一个数组*/}其他{抛出新错误（“预期的字符串、数字或数组”）；}

始终使用“白名单”进行验证。如果您需要一个值，例如字符串、数字或数组，请检查这3种“白色”可能性，如果这3种可能性都不满足，则抛出错误。我们应该能够看到，检查“黑色”可能性不是很有用：假设我们写if（v==null）throw new Error（'null value rejected'）；-这对于确保空值不通过非常有用，但是如果一个值通过了，我们仍然对它一无所知。通过这个空检查的值v仍然是非常通用的-它不是空！黑名单很难消除共性。除非值为空，否则不要考虑“空值”。相反，考虑“真空的X”。本质上，永远不要考虑做if（isEmpty（val））{/*…*/}-无论isEmpty函数是如何实现的（我不想知道…），它都没有意义！而且太普通了！真空度只能在了解val类型的情况下计算。真空度检查应如下所示：“字符串，无字符”：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表示某些功能。在这种情况下，说“真空值”很有意义：如果（val==null）。。。

根据jAndy的回答，如果该值为以下任一值，那么如果您想避免为真：

无效的未定义NaN公司空字符串（“”）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：

对象：｛｝（使用ECMA7+）阵列：[]（使用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，因此这可能不是最好的用法。可以修改该函数以使用它来显示它已声明，但不可用。

这还包括空数组和空对象

null，未定义，“”，0，[]，｛｝

isEmpty = (value) => (!value  || (typeof v === 'object' &&
   Object.keys(value).length < 1));

看看新的ECMAScript Nullish合并运算符

你可以想到这个功能-？？运算符-作为处理null或undefined时“回退”到默认值的一种方式。

let x = foo ?? bar();

同样，上述代码与以下代码等效。

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

下面是我的工作。请稍微改变一下，以加快速度

function isEmpty(obj) {
    if (!obj) return true;
    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;
}

对于我的用例，大多数现有答案都失败了，如果将函数分配给变量或返回NaN，则大多数答案返回为空。帕斯卡的回答很好。

这是我的实现，请测试并让我知道，如果你发现了什么。你可以在这里看到我是如何测试这个函数的。

function isEmpty(value) {
  return (
    // Null or undefined.
    (value == null) ||
    // Check if a Set() or Map() is empty
    (value.size === 0) ||
    // NaN - The only JavaScript value that is unequal to itself.
    (value !== value) ||
    // Length is zero && it's not a function.
    (value.length === 0 && typeof value !== "function") ||
    // Is an Object && has no keys.
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

退货：

true:undefined，null，“”，[]，{}，NaN，new Set（）//false：true，false，1，0，-1，“foo”，[1，2，3]，｛foo:1｝，函数（）｛｝

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

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

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

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

最简短的答案可能是

val==null || val==''

如果将右侧更改为val==“”，则空数组将为false。证据

函数isEmpty（val）{返回val==null | | val==“”}// ------------//测试// ------------var log=（name，val）=>console.log（`${name}->${isEmpty（val）}`）；log（'ull'，null）；log（'未定义'，未定义）；日志（'NaN'，NaN）；日志（'“”，“”）；日志（“｛｝”，｛｝）；日志（'[]'，[]）；日志（“[1]”，[1]）；日志（“[0]”，[0]）；日志（'[[]]'，[[]]）；log（'true'，true）；日志（'false'，false）；log（'“true”'，“true”）；日志（'“false”'，“false”）；log（“不确定性”，无限）；log（'-无限'，-无限）；日志（'1'，1）；日志（'0'，0）；日志（'-1'，-1）；日志（“1”，“1”）；日志（“0”，“0”）；日志（'“-1”'，“-1”）；//“void 0”案例console.log（'---\n“true”为：'，true）；console.log（'“void 0”为：'，void 0）；日志（void 0，void 0）；//“void 0”是“undefined”-因此我们应该在这里得到TRUE

有关==的更多详细信息（此处来源）

奖金：为什么==比==

写得清晰易懂可理解的代码，使用可接受值的显式列表

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

函数isEmpty（val）{return val==未定义| | val==null | | val===“”| |（Array.isArray（val）&&val.length==0）}// ------------//测试// ------------var log=（name，val）=>console.log（`${name}->${isEmpty（val）}`）；log（'ull'，null）；log（'未定义'，未定义）；日志（'NaN'，NaN）；日志（'“”，“”）；日志（“｛｝”，｛｝）；日志（'[]'，[]）；日志（“[1]”，[1]）；日志（“[0]”，[0]）；日志（'[[]]'，[[]]）；log（'true'，true）；日志（'false'，false）；log（'“true”'，“true”）；日志（'“false”'，“false”）；log（“不确定性”，无限）；log（'-无限'，-无限）；日志（'1'，1）；日志（'0'，0）；日志（'-1'，-1）；日志（“1”，“1”）；日志（“0”，“0”）；日志（'“-1”'，“-1”）；//“void 0”案例console.log（'---\n“true”为：'，true）；console.log（'“void 0”为：'，void 0）；日志（void 0，void 0）；//“void 0”是“undefined”-因此我们应该在这里得到TRUE

您可以始终使用loadash函数，例如_.isNil或_.isUndefined。它们非常容易使用。

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

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

null，未定义，NaN，空，字符串（“”），0，false

尝试Boolean（）和isNaN（）（对于数字类型）检查变量是否有值。

函数isEmpty（val）{返回类型的val==“number”？isNaN（val）：！布尔值（val）；}var emptyVals=[未定义，null，false，NaN，'']；emptyVals.forEach（v=>console.log（isEmpty（v）））；

可以使用参数成为数组的参数滤器

函数validateAttributes（arg1、arg2、arg3、arg4）{var args=对象.values（参数）；return（args.filter（x=>x===null||！x））。长度<=0}console.log（validateAttributes（'1'，2，3，4））；console.log（validateAttributes（'1'，2，3，null））；console.log（validateAttributes（'1'，未定义，3，4））；console.log（validateAttributes（'1'，2，''，4））；console.log（validateAttributes（'1'，2，3，null））；

仅对未定义和null返回false：

返回值？？假的

您可以使用零合并运算符？？检查空值和未定义值。参见MDN文档

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

0 ?? 42;  // returns 0

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

这是我检查数据是否为空的解决方案。

const _isEmpty = (data) => {
  return (
    // this way we can also check for undefined values. null==undefined is true
    data == null ||
    data == "" ||
    (Array.isArray(data) && data.length === 0) ||
    // we want {} to be false. we cannot use !! because !!{} turns to be true
    // !!{}=true and !!{name:"yilmaz"}=true. !! does not work ofr objects
    (data.constructor === Object && Object.keys(data).length === 0)

  );
};

我想这会让你的代码看起来更简单

检查变量是否未定义或为空

var a=undefined, b=null, c='hello world', d;
if(a !== (a ?? {})) { /**/ } // true
if(b !== (b ?? {})) { /**/ } // true
if(c !== (c ?? {})) { /**/ } // false
if(d !== (d ?? {})) { /**/ } // true

检查变量是否未定义或为空

var a=undefined, b=null, c='hello world', d;
if(a === (a ?? {})) { /**/ } // false
if(b === (b ?? {})) { /**/ } // false
if(c === (c ?? {})) { /**/ } // true
if(d === (d ?? {})) { /**/ } // false

仅使用“空值合并”检查未定义和空值

if ((myVariable ?? undefined) !== undefined) {
    // handle myVariable has a value, including 0 or ""
}
else {
    // handle undefined or null only
}

来自铬控制台

{const x=undefined; (x ?? undefined) !== undefined}
false

{const x=null; (x ?? undefined) !== undefined}
false

{const x=0; (x ?? undefined) !== undefined}
true

{const x=""; (x ?? undefined) !== undefined}
true

{const x={}; (x ?? undefined) !== undefined}
true

{const x=[]; (x ?? undefined) !== undefined}
true

{const x="a"; (x ?? undefined) !== undefined}
true