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

if( value ) {}

如果value是没有，将计算为true：

• null
• 未定义
• NaN
• 空字符串（""）
• 虚假

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

此外，如果您不知道是否存在变量（这意味着，如果它是宣布），您应该使用typeof运算符进行检查。例如

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

如果你可以确定至少声明了变量，你应该直接检查它是否有truthy值，如上所示。

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

这将返回true for

undefined  // Because undefined == null
null
[]
""

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

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

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

空或空格

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

检查value是否未定义或null的详细方法是：

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

您也可以使用==运算符，但这需要1到知道所有的规则：

return value == null; // also returns true if value is 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'};

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

• null
• 未定义（未定义的值与从未定义的参数不同）
• ""（空字符串）
• 虚假
• NaN

_{编辑：改为严格平等 (! ==) 因为它现在是常态；）}

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

function stringIsEmpty(value) {
return value ? value.trim().length == 0 : true;
}

具有最佳评级的第一个答案是错误的。如果value未定义，它将在现代浏览器中抛出异常。您必须使用：

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

或

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

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

function isEmpty(val){return !val;}

如果val是空，空，未定义，假，数字0或NaN，则此函数将返回true。

或

根据您的问题域，您可以使用!val或!!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(); //undefinedtypeOf(null); //nulltypeOf(NaN); //numbertypeOf(5); //numbertypeOf({}); //objecttypeOf([]); //arraytypeOf(''); //stringtypeOf(function () {}); //functiontypeOf(/a/) //regexptypeOf(new Date()) //datetypeOf(new WeakMap()) //weakmaptypeOf(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;}

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

_.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, objectconsole.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(' '); // stringisVariableHaveDefaltVal(false); // booleanvar a;isVariableHaveDefaltVal(a);isVariableHaveDefaltVal(0); // numberisVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - trueisVariableHaveDefaltVal(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 prototypescase '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]';
elsereturn 'object';// object literalsdefault: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;}

但是这个解决方案是过度设计的，如果你不想稍后为busines-model neails修改函数，那么直接在代码中使用它会更干净：

if(!val)...

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

这永远不会抛出错误。如果myObject、儿童或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));

它可能是有用的。

数组中的所有值都代表你想要的（null、undefault或其他东西），你可以在其中搜索你想要的东西。

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

此函数检查empty object {}、empty array []、null、undefined和blank string ""

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={}；
val=[]；
is空（未定义）->true
is空（null）->true
是空的("") -> true
is空（false）->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）个验证条件，例如not null、not空白、not un封装和not零，仅在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 falseelse if (typeof value === 'string') return value.trim().length === 0else if (Array.isArray(value)) return value.length === 0else if (typeof value === 'object') return value == null || Object.keys(value).length === 0else if (typeof value === 'boolean') return falseelse return !value}

如果您正在使用#0并且不想考虑"这些值是#1"，那么这是您的解决方案：

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

然后：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'

我非常喜欢的解决方案：

让我们定义一个空白变量是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))}

退货：

• true：undefined，null，""，[]，{}
• false：true，false，1，0，-1，"foo"，[1, 2, 3]，{ foo: 1 }

空位

我不建议尝试定义或使用一个计算整个世界中是否有任何值为空的函数。“空”到底是什么意思？如果我有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()）是真值——尽管它们看起来都同样空洞！

空vs未定义

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

• 尝试访问不存在的属性会给出undefined
• 调用函数时省略参数会导致该参数接收undefined：

let f = a => a;console.log(f('hi'));console.log(f());

• 具有默认值的参数仅在给定undefined时接收默认值，而不是null：

let f = (v='hello') => v;console.log(f(null));console.log(f(undefined));

对我来说，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) => {// Intentional use of loose comparison operator detects `null`// and `undefined`, and nothing else!return value != null && Object.getPrototypeOf(value).constructor === Cls;};

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

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

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

总的来说，我建议使用这个isType函数以及这些提示：

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

if (isType(v, String)) {/* v isn't generic in this block - It's a String! */} else if (isType(v, Number)) {/* v isn't generic in this block - It's a Number! */} else if (isType(v, Array)) {/* v isn't generic in this block - it's an Array! */} else {throw new Error('Expected String, Number, or Array');}

• 始终使用“白名单”进行验证。如果你要求一个值是，例如，String、Number或Array，检查这3种“白色”可能性，如果这3种可能性都不满足，则抛出错误。我们应该能够看到检查“黑色”可能性不是很有用：假设我们写if (v === null) throw new Error('Null value rejected');-这对于确保null值无法通过非常好，但是如果值确实通过了，我们仍然对此一无所知。通过空检查的值v仍然是非常通用的-它是除了#1！黑名单很难消除泛型性。
• 除非一个值是#0，否则永远不要考虑“一个空值”。相反，考虑“一个空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用于表示某些功能时。在这种情况下，说：“空值”：if (val === null) ...是有意义的

如果您想避免在值为以下任何值时获得true，根据jandy的回答：

• null
• 未定义
• NaN
• 空字符串（""）
• 虚假

一种可能避免获取true值的可能解决方案如下：

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+）
• 数组：[]（使用ecma5+）

你会这样做：

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和unset返回true，如果变量被声明为其中任何一个，因此它可能不是最佳使用。该函数可能会被修改以使用它来显示它已声明，但不可用。

这也涵盖了空数组和空对象

null，未定义, ' ', 0, [ ], { }

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

看看新的ECMAScript零合并算子

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

let x = foo ?? bar();

同样，上面的代码相当于以下代码。

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

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-a3987ea08fd7const 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 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，大多数返回为空。Pascal的答案很好。

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

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 }，function () {}

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

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。证明

function isEmpty(val){return val==null || val==''}
// ------------// TEST// ------------
var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);
log('null', null);log('undefined', undefined);log('NaN', NaN);log('""', "");log('{}', {});log('[]', []);log('[1]', [1]);log('[0]', [0]);log('[[]]', [[]]);log('true', true);log('false', false);log('"true"', "true");log('"false"', "false");log('Infinity', Infinity);log('-Infinity', -Infinity);log('1', 1);log('0', 0);log('-1', -1);log('"1"', "1");log('"0"', "0");log('"-1"', "-1");
// "void 0" caseconsole.log('---\n"true" is:', true);console.log('"void 0" is:', void 0);log(void 0,void 0); // "void 0" is "undefined" - so we should get here TRUE

更多关于==的信息（来源这里）

奖金：为什么===比==更清楚

写得简单明了可理解的代码，使用可接受值的显式列表

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)}
// ------------// TEST// ------------
var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);
log('null', null);log('undefined', undefined);log('NaN', NaN);log('""', "");log('{}', {});log('[]', []);log('[1]', [1]);log('[0]', [0]);log('[[]]', [[]]);log('true', true);log('false', false);log('"true"', "true");log('"false"', "false");log('Infinity', Infinity);log('-Infinity', -Infinity);log('1', 1);log('0', 0);log('-1', -1);log('"1"', "1");log('"0"', "0");log('"-1"', "-1");
// "void 0" caseconsole.log('---\n"true" is:', true);console.log('"void 0" is:', void 0);log(void 0,void 0); // "void 0" is "undefined" - so we should get here TRUE

您可以始终使用loadash函数，例如_. isNil或_未定义。它们非常易于使用。

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

它还将检查空格 (' ') 以及以下内容：

• null，未定义， NaN，空，字符串 ("") ,0， false

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

function isEmpty(val) {return typeof val === 'number' ? isNaN(val) : !Boolean(val);}
var emptyVals = [undefined, null, false, NaN, ''];emptyVals.forEach(v => console.log(isEmpty(v)));

1. 你可以用这些论据
2. 成为数组的参数
3. 过滤器

function validateAttrs(arg1, arg2, arg3,arg4){var args = Object.values(arguments);return (args.filter(x=> x===null || !x)).length<=0}console.log(validateAttrs('1',2, 3, 4));console.log(validateAttrs('1',2, 3, null));console.log(validateAttrs('1',undefined, 3, 4));console.log(validateAttrs('1',2, '', 4));console.log(validateAttrs('1',2, 3, null));

将仅对undefined和null返回false：

return value ?? false

您可以使用空合并运算符??来检查null和undefined值。请参阅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 truedata == 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)
);};

我认为这让你的代码看起来更简单

检查变量是undefined还是null

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

检查变量是否不是undefined或null

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

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

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

从chrome控制台

{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