如何在 JavaScript 中检查空值？

JavaScript 在检查“null”值方面非常灵活。我猜您实际上是在寻找空字符串，在这种情况下，这个更简单的代码将起作用：

if(!pass || !cpass || !email || !cemail || !user){

这将检查空字符串 （）、、以及数字和 。""nullundefinedfalse0NaN

请注意，如果您专门检查数字，则错过此方法是一个常见的错误，并且对于返回 的函数，首选（或或（也检查的 hacky 代码）），例如 ）。0num !== 0num !== -1~num-1-1indexOf

首先，你有一个没有函数体的 return 语句。这很可能会引发错误。

更简洁的检查方法是简单地使用 ！算子：

if (!pass || !cpass || !email || !cemail || !user) {

    alert("fill all columns");

}

你可以使用 try catch finally

 try {
     document.getElementById("mydiv").innerHTML = 'Success' //assuming "mydiv" is undefined
 } catch (e) {

     if (e.name.toString() == "TypeError") //evals to true in this case
     //do something

 } finally {}   

您也可以自己的错误。看这个。throw

只需在所有地方替换 WITH。=====

==是一个松散的或抽象的相等比较

===是严格的平等比较

有关更多详细信息，请参阅有关相等性比较和相同性的 MDN 文章。

要专门检查 null，您可以使用以下命令：

if (variable === null)

此测试将仅通过 、 、 、 或 。null""undefinedfalse0NaN

此外，我还为每个“类似 false”的值提供了绝对检查（一个将返回 true 的值）。!variable

请注意，对于某些绝对检查，您需要实现 和 的使用 。absolutely equals: ===typeof

我在这里创建了一个 JSFiddle 来展示所有单独的测试

以下是每个检查的输出：

Null Test:

if (variable === null)

- variable = ""; (false) typeof variable = string

- variable = null; (true) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Empty String Test:

if (variable === '')

- variable = ''; (true) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number




Undefined Test:

if (typeof variable == "undefined")

-- or --

if (variable === undefined)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (true) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



False Test:

if (variable === false)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (true) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Zero Test:

if (variable === 0)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (true) typeof variable = number

- variable = NaN; (false) typeof variable = number



NaN Test:

if (typeof variable == 'number' && !parseFloat(variable) && variable !== 0)

-- or --

if (isNaN(variable))

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (true) typeof variable = number

正如你所看到的，测试起来有点困难NaN;

这是对 WebWanderer 关于检查 NaN 的解决方案的评论（我还没有足够的代表来发表正式评论）。解决方案显示为

if(!parseInt(variable) && variable != 0 && typeof variable === "number")

但是对于四舍五入为 的有理数，这将失败，例如 。更好的测试是：0variable = 0.1

if(isNaN(variable) && typeof variable === "number")

要检查 JavaScript 中的 undefined 和 null，您只需要编写以下内容：

if (!var) {
        console.log("var IS null or undefined");
} else {
        console.log("var is NOT null or undefined");
}

在 JavaScript 中，没有字符串等于 。null

也许您希望在空字符串时为 true，因为您知道松散相等运算符执行某些类型的类型强制。pass == nullpass==

例如，以下表达式为 true：

'' == 0

相反，严格相等运算符说这是错误的：===

'' === 0

鉴于 和 是松散相等的，您可以合理地推测 和 是松散相等的。然而，事实并非如此。''0''null

此表达式为 false：

'' == null

将任何字符串进行比较的结果是 false。因此，所有其他测试始终是错误的，用户永远不会收到警报。nullpass == null

若要修复代码，请将每个值与空字符串进行比较：

pass === ''

如果您确定这是一个字符串，那么它也会起作用，因为只有空字符串才松散地等于空字符串。另一方面，一些专家说，在 JavaScript 中始终使用严格相等是一种很好的做法，除非您特别想执行松散相等运算符执行的类型强制。passpass == ''

如果您想知道哪些值对是松散相等的，请参阅有关此主题的 Mozilla 文章中的“相同性比较”表。

AFAIK 在 JAVASCRIPT 中声明变量但未赋值时，其类型为 .因此，我们可以检查变量，即使它是保存某些实例来代替值。undefinedobject

创建一个用于检查返回的无效性的帮助程序方法，并在 API 中使用它。true

helper 函数来检查变量是否为空：

function isEmpty(item){
    if(item){
        return false;
    }else{
        return true;
    }
}

try-catch 异常 API 调用：

try {

    var pass, cpass, email, cemail, user; // only declared but contains nothing.

    // parametrs checking
    if(isEmpty(pass) || isEmpty(cpass) || isEmpty(email) || isEmpty(cemail) || isEmpty(user)){
        console.log("One or More of these parameter contains no vlaue. [pass] and-or [cpass] and-or [email] and-or [cemail] and-or [user]");
    }else{
        // do stuff
    }

} catch (e) {
    if (e instanceof ReferenceError) {
        console.log(e.message); // debugging purpose
        return true;
    } else {
        console.log(e.message); // debugging purpose
        return true;
    }
}

一些测试用例：

var item = ""; // isEmpty? true
var item = " "; // isEmpty? false
var item; // isEmpty? true
var item = 0; // isEmpty? true
var item = 1; // isEmpty? false
var item = "AAAAA"; // isEmpty? false
var item = NaN; // isEmpty? true
var item = null; // isEmpty? true
var item = undefined; // isEmpty? true

console.log("isEmpty? "+isEmpty(item));

试试这个：

if (!variable && typeof variable === "object") {
    // variable is null
}

如果布尔值来自 DB，这将不起作用 例如：

 value = false

 if(!value) {
   // it will change all false values to not available
   return "not available"
 }

严格相等运算符：-

我们可以通过以下方式检查 null===

if ( value === null ){

}

只需使用if

if( value ) {

}

如果 value 不是，则计算结果为 true：

• 零
• 定义
• 南
• 空字符串 （“”）
• 假
• 0

通过显式检查但使用简化的语法来改进已接受的答案：null

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
}

// Test
let pass=1, cpass=1, email=1, cemail=1, user=1; // just to test

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
    console.log ("Yayy! None of them are null");
} else {
    console.log ("Oops! At-lease one of them is null");
}

实际上，我认为您可能需要使用，因为如果您使用，您还可以过滤 0 或 false 值。if (value !== null && value !== undefined)if (value)

请考虑以下两个函数：

const firstTest = value => {
    if (value) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}
const secondTest = value => {
    if (value !== null && value !== undefined) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}

firstTest(0);            // result: failed
secondTest(0);           // result: passed

firstTest(false);        // result: failed
secondTest(false);       // result: passed

firstTest('');           // result: failed
secondTest('');          // result: passed

firstTest(null);         // result: failed
secondTest(null);        // result: failed

firstTest(undefined);    // result: failed
secondTest(undefined);   // result: failed

在我的情况下，我只需要检查值是否为 null 且未定义，并且我不想过滤 or 或值。所以我使用了第二个测试，但你可能也需要过滤它们，这可能会导致你使用第一个测试。0false''

我找到了另一种方法来测试值是否为null：

if(variable >= 0 && typeof variable === "object")

null同时充当 和。比较或结果为 。比较 or or 将导致 false。但是，由于也是一个对象，我们可以将其检测为空。numberobjectnull >= 0null <= 0truenull === 0null > 0null < 0null

我做了一个更复杂的函数 natureof witch 会比 typeof 做得更好，并且可以被告知要包含哪些类型或保持分组

/* function natureof(variable, [included types])
included types are 
    null - null will result in "undefined" or if included, will result in "null"
    NaN - NaN will result in "undefined" or if included, will result in "NaN"
    -infinity - will separate negative -Inifity from "Infinity"
    number - will split number into "int" or "double"
    array - will separate "array" from "object"
    empty - empty "string" will result in "empty" or
    empty=undefined - empty "string" will result in "undefined"
*/
function natureof(v, ...types){
/*null*/            if(v === null) return types.includes('null') ? "null" : "undefined";
/*NaN*/             if(typeof v == "number") return (isNaN(v)) ? types.includes('NaN') ? "NaN" : "undefined" : 
/*-infinity*/       (v+1 === v) ? (types.includes('-infinity') && v === Number.NEGATIVE_INFINITY) ? "-infinity" : "infinity" : 
/*number*/          (types.includes('number')) ? (Number.isInteger(v)) ? "int" : "double" : "number";
/*array*/           if(typeof v == "object") return (types.includes('array') && Array.isArray(v)) ? "array" : "object";
/*empty*/           if(typeof v == "string") return (v == "") ? types.includes('empty') ? "empty" : 
/*empty=undefined*/ types.includes('empty=undefined') ? "undefined" : "string" : "string";
                    else return typeof v
}

// DEMO
let types = [null, "", "string", undefined, NaN, Infinity, -Infinity, false, "false", true, "true", 0, 1, -1, 0.1, "test", {var:1}, [1,2], {0: 1, 1: 2, length: 2}]

for(i in types){
console.log("natureof ", types[i], " = ", natureof(types[i], "null", "NaN", "-infinity", "number", "array", "empty=undefined")) 
}

我做了这个非常简单的函数，可以创造奇迹：

function safeOrZero(route) {
  try {
    Function(`return (${route})`)();
  } catch (error) {
    return 0;
  }
  return Function(`return (${route})`)();
}

路线是任何可以爆炸的价值链。我将其用于jQuery / cheerio和对象等。

示例 1：一个简单的对象，例如这个。const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};

但它可能是一个非常大的物体，我们甚至没有制造出来。所以我把它传递过来：

let value1 = testobj.items[2].val;  // "hum!"
let value2 = testobj.items[3].val;  // Uncaught TypeError: Cannot read property 'val' of undefined

let svalue1 = safeOrZero(`testobj.items[2].val`)  // "hum!"
let svalue2 = safeOrZero(`testobj.items[3].val`)  // 0

当然，如果你愿意，你可以使用或...无论您的需求如何。null'No value'

通常，如果找不到 DOM 查询或 jQuery 选择器，则可能会抛出错误。但是使用类似的东西：

const bookLink = safeOrZero($('span.guidebook > a')[0].href);
if(bookLink){
  [...]
}

您可以使用 lodash 模块来检查值是否为 null 或未定义

_.isNil(value)
Example 

 country= "Abc"
    _.isNil(country)
    //false

   state= null
    _.isNil(state)
    //true

city= undefined
    _.isNil(state)
    //true

   pin= true
    _.isNil(pin)
    // false   

参考链接： https://lodash.com/docs/#isNil

检查错误条件：

// Typical API response data
let data = {
  status: true,
  user: [],
  total: 0,
  activity: {sports: 1}
}

// A flag that checks whether all conditions were met or not
var passed = true;

// Boolean check
if (data['status'] === undefined || data['status'] == false){
  console.log("Undefined / no `status` data");
  passed = false;
}

// Array/dict check
if (data['user'] === undefined || !data['user'].length){
  console.log("Undefined / no `user` data");
  passed = false;
}

// Checking a key in a dictionary
if (data['activity'] === undefined || data['activity']['time'] === undefined){
   console.log("Undefined / no `time` data");
   passed = false;
}

// Other values check
if (data['total'] === undefined || !data['total']){
  console.log("Undefined / no `total` data");
  passed = false;
}

// Passed all tests?
if (passed){
  console.log("Passed all tests");
}

您可以按如下方式检查某个值是否为 null

[pass,cpass,email,cemail,user].some(x=> x===null) 

let pass=1;
let cpass=2;
let email=3;
let cemail=null;
let user=5;

if ( [pass,cpass,email,cemail,user].some(x=> x===null) ) {     
    alert("fill all columns");
    //return false;  
}   

奖励：为什么比（来源=====)

a == b

a === b

乍一看，它看起来像是覆盖范围和严格性之间的简单权衡。

• ==涵盖多个值，可以在更少的代码中处理更多的场景。
• ===是最严格的，这使得它是可预测的。

可预测性总是获胜，这似乎是一个放之四海而皆准的解决方案。===

但这是错误的。尽管是可预测的，但它并不总是产生可预测的代码，因为它忽略了方案。===

const options = { };
if (options.callback !== null) {
  options.callback();      // error --> callback is undefined.
}

通常，对 null 检查执行更可预测的工作：==

• 总的来说，两者的意思是一样的：“缺少一些东西”。为了实现可预测性，您需要检查这两个值。然后做一个完美的工作，因为它恰好涵盖了这两个值。（即 == null 等同于 === null && === undefinednullundefined== null)

• 在特殊情况下，您确实希望明确区分 和 。在这些情况下，您最好使用严格的 or .（例如，丢失/忽略/跳过和空/清除/删除之间的区别。但这种情况很少见。nullundefined=== undefined=== null

这不仅罕见，而且是需要避免的。您不能存储在传统数据库中。而且，由于互操作性的原因，您也不应该依赖 API 设计中的值。但是，即使你根本不做区分，你也不能假设undefined不会发生。我们周围的人间接采取了概括/（这就是为什么这样的问题被关闭为“固执己见”的原因。undefinedundefinednullundefined

所以，回到你的问题。使用 .它完全做了它应该做的事情。== null

// FIX 1 --> yes === is very explicit
const options = { };
if (options.callback !== null && 
    options.callback !== undefined) {
  options.callback();
}


// FIX 2 --> but == covers both
const options = { };
if (options.callback != null) {
  options.callback();
}

// FIX 3 --> optional chaining also covers both.
const options = { };
options.callback?.();

可选与操作员检查怎么样？

例如：

// check mother for null or undefined and 
// then if mother exist check her children also
// this 100% sure it support and valid in JS today.
// Apart of that C# have almost the same operator using the same way
if (mother?.children) {

}
else {
 // it is null, undefined, etc...

}

空值的简单解决方案：

function isEmpty(value) {
        return (
            value === null || value === undefined || value === '' ||
            (Array.isArray(value) && value.length === 0) ||
            (!(value instanceof Date) && typeof value === 'object' && Object.keys(value).length === 0)
        );
    }

'' 方法可用于确定两个值是否为同一值。因此，您可以使用它来检查对象是否为 null。Object.is()

检查 null 值

let testA = null; //null
//console.log(Object.is(testA, null)); //true //null === null

if(Object.is(testA, null)) {
  console.log("This is a Null Value");
}

Output:
This is a Null Value

let x = null;
if (x === null) {
  console.log("x is null");
}

Output:
x is null

检查未定义的值（已声明变量，但尚未赋值。

let testB; //undefined
//console.log(Object.is(testB, undefined)); //true //undefined === undefined

if(Object.is(testB, undefined)) {
  console.log("This is an undefined Value");
}

Output:
This is an undefined Value

如果尚未声明对象，则不能使用此对象。作为替代方案，您可以尝试以下方法：

if (typeof x === "undefined") {
  console.log("x is undefined");
}

Output:
The value is either undefined or null

Mozilla Object.is（）：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is

这是一个非常非人类的代码。但有效：

if((pass, cpass, email, cemail, user !== null)){

试一试，帮助答案