这可能很有用。

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

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

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

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

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

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

以下代码有效。

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

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

真空度

我不建议尝试定义或使用计算整个世界中任何值是否为空的函数。“空”到底意味着什么？如果我让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）。。。

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

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

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

检查默认值

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

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

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