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

Question

是否有一个通用JavaScript函数可以检查变量是否有值并确保它没有值未定义或无效的? 我有这个代码，但我不确定它是否涵盖所有情况：

函数为空（val）{返回（val===未定义||val==null||val.length<=0）？真：假；}

Answer 1

你可以检查一下变量有一个真实的值或否。这意味着

if（值）{//做点什么。。}

将评估为真的如果价值是不:

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

以上列表代表了所有可能的虚伪的ECMA-/Javascript中的值。在中查找规范在ToBoolean（目标布尔值）部分。

此外，如果您不这样做知道变量是否存在（也就是说，如果它是宣布)你应该向类型操作员。例如

if（类型foo！==“未定义”）{//foo可以被解析，它被定义}

如果你能确定变量至少声明了，您应该直接检查它是否有真实的值，如上图所示。

Answer 2

这个问题有两种解释：

检查变量是否有值
检查变量是否具有真实值

以下是两者的答案。

在JavaScript中，值可以是使无效或者不是nursh，值可以是虚伪的或真实的.
Nullish值是错误值的适当子集：

╭─ 使无效──────╮ ╭─ 非无效─────────────────────────────────╮┌───────────┬──────┬───────┬───┬────┬─────┬──────┬───┬─────────┬─────┐│ 未定义│空│假│0│“”│…│真│1│“你好”│└───────────┴──────┴───────┴───┴────┴─────┴──────┴───┴─────────┴─────┘╰─ 虚伪的───────────────────────────────╯ ╰─ 真实的───────────────╯

检查值是否为nursh（未定义或null）

根据您的编码风格，使用以下选项之一：

如果（value==null）{/*value为nulsh*/}if（value===未定义||value===null）{/*value为nulsh*/}如果（value==未定义）{/*value为nulsh*/}if（（value？？null）===null）{/*value为nulsh*/}

笔记：

• 这个==操作员工作是因为它对空与未定义比较有一种特殊情况
• 这个===运算符更具可读性（基于观点），对eqeqq友好，允许分别检查未定义和null
• 第一个和第三个示例的工作原理相同，但第三个在生产代码中很少出现
• 第四个示例使用零值合并操作符将零值更改为无效的用于直接比较

检查值是否为零

if（value！=null）{/*value不是nursh，尽管它可能是falsy*/}if（value！==未定义&&value！==null）{/*value不是nursh，尽管它可能是falsy*/}if（value！=undefined）{/*value不是nursh，尽管它可能是falsy*/}if（（值？？null）！==null）{/*值不是nursh，尽管它可能是falsy*/}

检查值是否错误

使用!操作员：

如果（！value）{/*value为falsy*/}

检查值是否真实

如果（value）{/*value为true*/}

数据验证

无效、虚假和真实检查不能单独用于数据验证。例如，0（falsy）是一个人的有效年龄，并且-1（truthy）不是。需要根据具体情况添加其他逻辑。一些示例：

/**检查值是否大于/等于0*注意，我们不能在这里使用真实检查，因为必须允许0*/[null，-1，0，1].forEach（num=>{if（num！=null&&num>=0）{console.log（“%o不为nulsh且大于等于0”，num）；}其他{console.log（“%o不正确”，num）；}});/**检查值是否不是空字符串或空白字符串*/[null、“”、“”和“hello”].forEach（str=>{if（str&&//\S/.test（str））{console.log（“%o为truethy且具有非空白字符”，str）；}其他{console.log（“%o不正确”，str）；}});/**检查值是否不是空数组*在检查长度属性之前检查真实性*/[null，[]，[1]].forEach（arr=>{if（arr&&arr.长度）{console.log（“%o是真的，并且有一个或多个项目”，arr）；}其他{console.log（“%o错误”，arr）；}});/**检查值是否不是空数组*使用可选的链接运算符确保值不为零*/[null，[]，[1]].forEach（arr=>{if（arr？.长度）{console.log（“%o不是nursh，并且有一个或多个项”，arr）；}其他{console.log（“%o错误”，arr）；}});

Answer 3

函数为空（值）{返回（值==null||value.length===0）；}

这将返回true

undefined//因为undefined==null无效的[]""

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

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

函数为空（值）{return（value==null||value==''）；}

Null或空白

函数为空（值）{return（value==null||value.trim（）.length===0）；}

Answer 4

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

if（值类型！==“未定义”&&value）{//处理价值};

它将涵盖以下情况价值从未定义，也未定义以下任何内容：

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

_{编辑：更改为严格等式（！==），因为它现在已经成为规范；）}

Answer 5

我非常喜欢的解决方案：

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

函数为空（值）{返回(//null或未定义（值==空）||//长度为零（value.hasOwnProperty（“长度”）&&value.length===0）||//是一个对象，没有键（value.constructor===对象和对象.keys（value）.length===0）)}

退货：

• 正确： 未定义,无效的,"",[],{}
• 错误： 真的,假,1,0,-1,“foo”,[1, 2, 3],{foo:1}

Answer 6

看看新的ECMAScriptNullish凝聚算子

你可以想到这个功能-??运算符-作为处理时“回退”到默认值的方法无效的或未定义.

设x=foo？？bar（）；

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

让x=（foo！==空&&foo！==未定义）？foo:bar（）；

Answer 7

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

函数类型Of（obj）{return{}.toString.call（obj）.split（''）[1]切片（0，-1）.toLowerCase（）；}

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

函数类型Of（obj）{const{toString}=对象原型；const stringified=对象：：toString（）；常量类型=stringified.split（''）[1].slice（0，-1）；return type.toLowerCase（）；}

结果：

typeOf（）//未定义typeOf（空）//无效的类型Of（NaN）//数typeOf（5）//数typeOf（｛｝）类型//对象typeOf（[]）//阵列typeOf（“”）//一串typeOf（函数（）{}）//功能typeOf（/a/）//正则表达式typeOf（new Date（））//日期typeOf（new WeakMap（））//WeakMaptypeOf（new Map（））//映射

“请注意，绑定操作符（：：）根本不是ES2016（ES7）或ECMAScript标准的任何后续版本的一部分。它目前是引入该语言的第0阶段（稻草人）建议。”–西蒙·凯尔伯格。作者希望对这一美丽的建议加上支持，以获得王室提升。

Answer 8

此条件检查

if（！！foo）{//定义了foo}

就是你所需要的。

Answer 9

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

if（typeof（value）！==“未定义”&&值）

或

if（值类型！==“未定义”&&value）

Answer 10

真空度

我不建议尝试定义或使用计算整个世界中是否有任何值为空的函数。“空”到底意味着什么？如果我有让人类={name:'bob'，胃：'empty'}，应该是空的（人类）返回真的? 如果我有let reg=新RegExp（“”）；，应该是空的（reg）返回真的? 关于isEmpty（[null，null，null，null]）-这个列表只包含空，所以列表本身是空的吗？我想在这里对javascript中的“真空”（一个故意晦涩的词，以避免预先存在的关联）提出一些注释，我想说的是，javascript值中的“空虚”永远不应该被泛化处理。

---

真实性/虚假性

为了决定如何确定值的“空洞性”，我们需要考虑javascript内置的内在感觉，即值是“真实的”还是“虚假的”。当然，无效的和未定义都是“假的”。不那么自然，数字0（除NaN公司)也是“虚假的”。自然最少：''是假的，但是[]和{}（和新集合（）、和新建地图（）)都是真实的，尽管它们看起来都同样空虚！

---

空与未定义

还有一些关于无效的与未定义-我们真的需要两者来表达我们程序中的空虚吗？我个人避免未定义出现在我的代码中。我总是使用无效的表示“空虚”。不过，我们需要再次适应javascript固有的无效的和未定义不同之处：

• 试图访问不存在的属性会导致未定义
• 调用函数时省略参数会导致接收该参数未定义:

设f=a=>a；console.log（f（'hi'））；console.log（f（））；

• 具有默认值的参数仅在给定时接收默认值未定义，不是无效的:

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

对我来说，无效的是空虚的明确象征；“本可以填写的内容故意留白”。

真的？未定义是允许一些js特性存在的必要复杂性，但在我看来它应该永远被留在幕后；未与直接交互.我们可以考虑未定义例如，javascript实现默认函数参数的机制。如果您不向函数提供参数，它将收到一个值未定义而不是。如果函数参数最初设置为未定义在这种情况下未定义是默认函数参数的关键，但它停留在后台：我们可以实现默认参数功能，而无需引用未定义:

这是一个错误的默认参数实现，因为它直接与未定义:

let fnWithDefaults=参数=>{如果（arg===未定义）arg='default'；...};

这是一个很好的实施：

让fnWithDefaults=（arg='default'）=>{…}；

接受默认参数的方式不太好：

fnWithDefaults（未定义）；

只需这样做：

fnWithDefaults（）；

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

例如。：

设fnWithDefaults=（a=1，b=2，c=3，d=4）=>console.log（a，b，c，d）；

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

fn默认值（10，未定义，未定义40）；

答案是：重构fnWith默认值要接受单个对象：

设fnWithDefaults=（{a=1，b=2，c=3，d=4}={}）=>console.log（a，b，c，d）；fnWithDefaults（｛a:10，d:40｝）；//现在这个看起来真不错！（从不谈论“未定义”）

---

非通用真空

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

设isType=（值，Cls）=>{//有意使用松散比较运算符检测`null`//还有“未定义”，什么都没有！返回值！=null&&Object.getPrototypeOf（value）.constructor===Cls；};

请注意，此函数忽略继承-它需要价值成为…的直接实例Cls公司，而不是的子类的实例Cls公司.我回避运算符主要有两个原因：

• （[]对象实例）===true（“数组是对象”）
• （字符串的“”实例）===false（“字符串不是字符串”）

请注意对象.get原型用于避免（模糊的）边缘外壳，例如让v={constructor:String}；这个is类型函数仍然正确返回isType（v，字符串）（错误），以及isType（v，对象）（正确）。

总的来说，我建议使用这个is类型功能以及以下提示：

• 最小化未知类型值的代码处理量。例如，用于让v=JSON.parse（someRawValue）；，我们的v（v）变量现在的类型未知。我们应该尽早限制我们的可能性。最好的方法是要求特定类型：例如。if（！isType（v，Array））引发新错误（“预期数组”）；-这是消除v（v），并确保它始终是阵列然而，有时我们需要允许v（v）具有多种类型。在这种情况下，我们应该创建代码块，其中v（v）不再通用，请尽早：

if（isType（v，String））{/*v在这个块中不是通用的-它是一个字符串*/}else if（isType（v，Number））{/*v在这个块中不是通用的-它是一个数字*/}else if（isType（v，Array））{/*v在这个块中不是通用的，它是一个数组*/}其他{throw new Error（“预期字符串、数字或数组”）；}

• 始终使用“白名单”进行验证。如果您需要一个值，例如String、Number或Array，请检查这三种“白色”可能性，如果三种可能性都不满足，则抛出Error。我们应该能够看到，检查“黑色”可能性并不是很有用：比如我们写如果（v===null）抛出新错误（“null value rejected”）；-这对确保无效的价值观无法通过，但如果做成功了，我们仍然对它一无所知。一个值v（v）通过这个空检查的仍然是非常通用的-它是除了什么无效的! 黑名单很难消除普遍性。
• 除非值为无效的，永远不要考虑“一个空洞的值”。相反，考虑“一个空洞的X”。从本质上讲，永远不要考虑像if（isEmpty（val））{/*…*/}-不管怎样栈空函数已实现（我不想知道…），它没有意义！而且它太普通了！只有在了解以下内容的情况下才能计算真空度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）。。。

  • 唯一的例外是无效的用于表示某些功能。在这种情况下，可以这样说：“空值”：如果（val===空）。。。

Answer 11

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

函数为空（值）{return（typeofvalue===“undefined”||value===null）；}

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

Answer 12

!检查空字符串（“”）、null、undefined、false以及数字0和NaN。比如，如果字符串为空var name=“”然后console.log（！name）收益真的.

函数为空（val）{返回！val；}

如果val值是空、null、未定义、false、数字0或NaN.

或

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

Answer 13

最简短的答案可能是

val==null||val==''

如果你把右侧换成val===“”那么空数组将给出false。证明

函数为空（val）{返回val==null||val==''}// ------------//测试// ------------var log=（name，val）=>控制台.log（`${name}->${isEmpty（val）}`）；log（'null'，null）；log（“未定义”，未定义）；log（'NaN'，NaN）；日志（“”，“”）；日志（“｛｝”，｛｝）；日志（'[]'，[]）；日志（“[1]”，[1]）；日志（“[0]”，[0]）；日志（'[[]]'，[[]]）；log（'true'，true）；日志（“false”，false）；log（“true”，“true“）；日志（“false”，“false”）；log（“不确定性”，无限性）；log（'-Infinity'，-Infinity）；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”是“未定义的”-所以我们应该得到这里的TRUE

有关的更多详细信息==（来源在这里)

奖金：原因===比==

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

val===未定义||val===null||val==''||（Array.isArray（val）&&val.length===0）

函数为空（val）{return val===未定义||val===null||val==''||（Array.isArray（val）&&val.length===0）}// ------------//测试// ------------var log=（name，val）=>控制台.log（`${name}->${isEmpty（val）}`）；log（'null'，null）；log（“未定义”，未定义）；log（'NaN'，NaN）；日志（“”，“”）；日志（“｛｝”，｛｝）；日志（'[]'，[]）；日志（“[1]”，[1]）；日志（“[0]”，[0]）；日志（'[[]]'，[[]]）；log（'true'，true）；日志（“false”，false）；log（“true”，“true“）；日志（“false”，“false”）；log（“不确定性”，无限性）；log（'-Infinity'，-Infinity）；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”是“未定义的”-所以我们应该得到这里的TRUE

Answer 14

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

函数字符串IsEmpty（值）{返回值？value.trim（）.length==0:true；}

Answer 15

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

/***检查“value”是否为空。数组、字符串或“参数”对象*长度为“0”且对象没有自己的可枚举属性*“空”。**@静态*@memberOf_*@category对象*@param{Array | Object | string}value要检查的值。*@returns{boolean}如果“value”为空，则返回“true”，否则返回“false”。*@示例**_.为空（[1,2,3]）；*//=>假**_.为空（[]）；*//=>真**_.isEmpty（{}）；*//=>真**_.is空（''）；*//=>真*/函数为空（值）{if（！value）{返回true；}if（isArray（value）||isString（value，值））{返回！值.长度；}for（var键值）{if（hasOwnProperty.call（value，key））{返回false；}}返回true；}

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

_.isEmpty（值）

Answer 16

return val ||'处理空变量'

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

const res=val | |'默认值'

Answer 17

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

if（foo）{}函数（bar）{}（foo）

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

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

foo类型！=“未定义”

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

if（foo的类型！=“未定义”&&foo）{//此处输入代码}

Answer 18

您可以使用零合并操作符??检查无效的和未定义值。请参阅MDN文档

空？？'默认字符串'；//返回“默认字符串”0 ?? 42;  // 返回0（null||未定义）？？“foo”；//返回“foo”

Answer 19

检查默认值

函数类型OfVar（obj）{return{}.toString.call（obj）.split（''）[1]切片（0，-1）.toLowerCase（）；}函数isVariableHaveDefaltVal（变量）{if（typeof（variable）===“字符串”）{//number，boolean，string，objectconsole.log（'单引号/双引号之间的任何数据都被视为字符串'）；return（variable.trim（）.length===0）？真：假；}else if（typeof（variable）===“boolean”）{console.log（'布尔值，默认值为“false”）；返回（变量===false）？真：假；}else if（typeof（variable）===“未定义”）{log（'EX:var a；变量已创建，但默认值为undefined.'）；返回true；}else if（typeof（variable）===“数字”）{console.log（'number:'+变量）；返回（变量===0）？真：假；}else if（typeof（variable）===“对象”）{//-----对象-----if（typeOfVar（variable）==“array”&&variable.length==0）{console.log（'\t长度为'+[].length的对象数组）；//Object.keys（变量）返回true；}else if（typeOfVar（variable）===“字符串”&&variable.length===0）{console.log（'\t长度为'+variable.length的对象字符串）；返回true；}else if（typeOfVar（variable）===“boolean”）{console.log（'\t对象布尔值='+变量）；返回（变量===false）？真：假；}else if（typeOfVar（variable）===“数字”）{console.log（'\t对象编号='+变量）；返回（变量===0）？真：假；}else if（typeOfVar（variable）===“regexp”&&variable.source.trim（）.length===0）{console.log（'\t对象正则表达式：'）；返回true；}else if（变量===null）{console.log（'\t对象空值'）；返回true；}}返回false；}var str=“适合任何场合的篮子”；str=str.replace（/\s/g，“-”）；//正则表达式中的“g”标志将替换所有空格。

检查结果：

isVariableHaveDefaltVal（“”）；//字符串isVariableHaveDefaltVal（假）；//布尔值变量a；isVariableHaveDefaltVal（a）；isVariableHaveDefaltVal（0）；//数字isVariableHaveDefaltVal（parseInt（“”））；//NAN是NAN（“”）；-真的isVariableHaveDefaltVal（空）；isVariableHaveDefaltVal（[]）；isVariableHaveDefaltVal（//）；isVariableHaveDefaltVal（新对象（“”））；isVariableHaveDefaltVal（新对象（false））；isVariableHaveDefaltVal（新对象（0））；typeOfVar（函数（）｛｝）；

我使用@Vix函数（）检查对象的类型。

使用instansof«

var prototypes_or_Literals=函数（obj）{开关（对象类型）{//对象原型case“对象”：if（obj实例数组）return“[object Array]”；else if（obj实例日期）return“[对象日期]”；else if（RegExp的obj实例）返回“[object regexp]”；else if（obj instanceof String）return'[object String]'；else if（obj instanceof Number）return“[对象编号]”；其他的return“object”；//对象文字违约：返回类型（obj）；}   };输出测试«prototypes_or_Literals（“”）//“string”prototypes_or_Literals（新字符串（“”））//“[object String]”Object.prototype.toString.call（“foo bar”）//“[Object String]”

Answer 20

函数isEmpty（obj）{if（typeofobj=='number'）返回false；else if（typeof obj=='string'）返回obj.length==0；else if（Array.isArray（obj））返回obj.length==0；else if（typeof obj=='object'）返回obj==null || object.keys（obj）.length==0；else if（typeof obj==‘boolean’）返回false；否则返回！对象；}

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

常量为空=值=>{if（typeof value===“数字”）返回falseelse if（typeof value===“string”）返回value.trim（）.length===0else if（Array.isArray（value））返回值.length===0else if（typeof value===“object”）返回值==null | | object.keys（value）.length==0else if（typeof value===“boolean”）返回false否则返回！价值}

Answer 21

它可能有用。

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

var variablesWhatILookFor=[null，undefined，'']；variablesWhatILookFor.indexOf（document.DocumentNumberLabel）>-1

Answer 22

如果您正在使用类型脚本不想解释“价值观假"那么这就是您的解决方案：

第一：从“util”导入｛isNullOrUndefined｝；

然后：为空或未定义（this.yourVariableName）

请注意：如前所述在下面现在已弃用，请使用value===未定义|| value====空而不是。裁判.

Answer 23

如果您想避免在值为以下任一值时变为true，请根据jAndy的回答:

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

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

功能可用（值ToCheck）{if（valueToCheck===0|//如果值为0，请避免返回false。valueToCheck===“”||//如果值为空字符串，请避免返回false。valueToCheck===false | |//如果值为false，请避免返回false。valueToCheck）//如果它不是null、undefined或NaN，则返回true。{返回true；}其他{返回false；}}

它的用法如下：

if（可用（x））{//它是可用的！}//确保避免将逻辑NOT运算符放在参数（isUsable（！x））之前，而是在函数之前使用它来检查返回值。if（！可用（x））{//它不可用！}

---

除了这些场景外，如果对象或阵列为空：

• 对象：{}（使用ECMA第7版+)
• 数组：[]（使用ECMA第5版+)

你可以这样做：

函数isEmptyObject（值ToCheck）{if（valueToCheck的类型==='object'&&！object.keys（valueToCheck）.length）{//对象为空！返回true；}其他{//对象不为空！返回false；}}函数为EmptyArray（valueToCheck）{if（Array.isArray（valueToCheck）&&！检查长度的值）{//数组为空！返回true；}其他{//数组不为空！返回false；}}

如果要检查所有空白字符串（“”），可以执行以下操作：

函数isAllWhitespace（）{if（valueToCheck.match（/^*$/）！==null）{//都是空白！返回true；}其他{//不是所有的空格！返回false；}}

---

注：拥有自己的财产如果变量声明为空字符串、0、false、NaN、null和未定义字符串中的任何一个，则返回true，因此可能不是最好的使用方法。可以修改函数以使用它来表明它已声明，但不可用。

Answer 24

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

函数myFunction（）{var数据//值可以是null、blank、undefined、zero，您可以测试if（！（！（数据））{警报（“数据”+数据）；} 其他{警报（“数据是”+数据）；}}

Answer 25

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

让客户={name:“卡尔”，详细信息：{年龄：82岁，地点：“天堂瀑布”//详细地址未知}};let customerCity=customer.details？。地址？。城市；

可以在可选链接之后使用零合并运算符，以便在找不到默认值时生成默认值：

让客户={name:“卡尔”，详细信息：{年龄：82}};const customerCity=客户？。城市？？“未知城市”；console.log（customerCity）；//未知城市

Answer 26

函数为空（val）{返回！val；}

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

if（！val）。。。

Answer 27

var myNewValue=myObject和myObject.child；

这永远不会抛出错误。如果我的对象,小孩，或myValue（我的值）则为null我的新值将为空。不会抛出错误

Answer 28

对于所有来这里提出类似问题的人来说，以下内容非常有用，我在过去几年的图书馆里都有：

（函数（g3，$，窗口，文档，未定义）{g3.utils=g3.utils|{}；/********************************函数类型（）*********************************返回对象构造函数的小写字符串表示。*@模块{g3.utils}*@函数｛g3.utils.type｝*@公共*@param{Type}“obj”是任何类型的本机、主机或自定义。*@return{String}返回表示对象*构造函数，如果它们不是自定义的，则与单词“对象”不同。*@参考http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/* http://stackoverflow.com/questions/3215046/disferenting-between-arrays-and-hashes-in-javascript* http://javascript.info/tutorial/type-detection*******************************************************************************/g3.utils.type=函数（obj）{if（obj===空）return“null”；else if（对象类型===“未定义”）return'undefined'；return Object.protype.toString.call（obj）.match（/^\[Object\s（.*）\]$/）[1].toLowerCase（）；};}（window.g3=window.g3||{}，jQuery，窗口，文档）；

Answer 29

GitHub上的代码

常量为空=值=>(（！value&&value！==0&&values！==false）||（Array.isArray（value）&&value.length===0）||（isObject（值）&&Object.keys（值）.length===0）||（值的类型。大小===“数字”&&value.size===0）//`WeekMap.length`应该存在！？||（值的类型。长度==='数字'&&值的类型！=='函数'&&value.length===0）);//资料来源：https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7const isObject=值=>Object.prototype.toString.call（value）===“[对象对象]”；

穷人的测试😁

常数测试=（）=>{const run=（标签，值，预期值）=>{常量长度=values.length；console.group（`${label}（${length}测试）`）；值.map（（v，i）=>{console.assert（预期为isEmpty（v）===，`${i}:${v}`）；});控制台.groupEnd（）；};常量空=[null，未定义，NaN，“”，{}，[]，new Set（）、new Set，];常量notEmpty=[“”，“a”，0，1，-1，false，true，｛a:1｝，[0]，新集合（[0]），新映射（[['a'，1]]），new WeakMap（）.set（{}，1），new Date（），/a/，new RegExp（），（）=>{}，];常量shouldBeEmpty=[{undefined:undefined}，新映射（[[]]），];run（'EMPTY'，空，真）；run（'NOT EMPTY'，notEmpty，false）；run（“应该为空”，shouldBeEmpty，true）；};

测试结果：

空（10次测试）非空（16次测试）应为空（2次测试）断言失败：0:[object object]断言失败：1:[object Map]

Answer 30

函数notEmpty（值）{return（typeof value！==“undefined”&&value.trim（）.length）；}

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

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