如何在JavaScript中检查空值？

如何在JavaScript中检查空值？我写了下面的代码，但它不起作用。

if (pass == null || cpass == null || email == null || cemail == null || user == null) {
alert("fill all columns");return false;
}

如何在我的JavaScript程序中找到错误？

1808977 次浏览
小开
最佳答案

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

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

它将检查空字符串（""）、null、undefined、false以及数字0和NaN。

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

小开

首先，你有一个没有函数体的返回语句。这很可能会抛出错误。

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

if (!pass || !cpass || !email || !cemail || !user) {
alert("fill all columns");
}
小开

您可以使用try cat最终

 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自己的错误。请参阅这个。

小开

只需在所有位置将==替换为===。

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

===是严格相等比较

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

小开

要检查null具体来说，您将使用以下命令：

if (variable === null)

此测试将只有通过null，而不会通过""，undefined，false，0或NaN。

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

请注意，对于某些绝对检查，您需要实现使用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有点困难；

小开

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

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

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

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

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

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

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

也许当pass为空字符串时，您期望pass == null为真，因为您知道松散的等号操作符==执行某些类型强制转换。

例如，这个表达式是true：

'' == 0

相反，严格等号操作符===表示这是false：

'' === 0

假设''和0是松散相等的，你可以合理地推测''和null是松散相等的。

这个表达式是假的：

'' == null

将任何字符串与null进行比较的结果都是假的。因此，pass == null和所有其他测试始终为假，用户永远不会收到警报。

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

pass === ''

如果你确定pass是一个字符串，pass == ''也可以，因为只有空字符串松散地等于空字符串。另一方面，一些专家说，在JavaScript中总是使用严格相等是一个很好的做法，除非你特别想做松散等号操作符执行的类型强制。

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

小开

AFAIK在JAVASCRIPT中，当一个变量是宣布但没有赋值时，它的类型是undefined。所以我们可以检查变量，即使它是一个object，用一些实例代替值。

创建一个帮助器方法来检查返回true的空性，并在您的API中使用它。

帮助函数检查变量是否为空：

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

try-cat异常API调用：

try {
var pass, cpass, email, cemail, user; // only declared but contains nothing.
// parametrs checkingif(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 purposereturn true;} else {console.log(e.message); // debugging purposereturn true;}}

一些测试用例：

var item = ""; // isEmpty? truevar item = " "; // isEmpty? falsevar item; // isEmpty? truevar item = 0; // isEmpty? truevar item = 1; // isEmpty? falsevar item = "AAAAA"; // isEmpty? falsevar item = NaN; // isEmpty? truevar item = null; // isEmpty? truevar 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 availablereturn "not available"}
小开

严格等号操作符：-

我们可以通过===检查null 

if ( value === null ){
}

只需使用if

if( value ) {
}

将评估为true if值不是：

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

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

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

// Testlet 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");}

小开

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

考虑这两个函数：

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: failedsecondTest(0);           // result: passed
firstTest(false);        // result: failedsecondTest(false);       // result: passed
firstTest('');           // result: failedsecondTest('');          // result: passed
firstTest(null);         // result: failedsecondTest(null);        // result: failed
firstTest(undefined);    // result: failedsecondTest(undefined);   // result: failed

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

小开

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

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

null同时充当number和object。比较null >= 0或null <= 0会导致true。比较null === 0或null > 0或null < 0会导致false。但由于null也是一个对象，我们可以将其检测为null。

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

/* function natureof(variable, [included types])included types arenull - 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" orempty=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}
// DEMOlet 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/啦啦队和对象等。

示例1：一个简单的对象，如thisconst 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){[...]}
小开

您可以使用洛达什模块来检查值是否为空或未定义

_.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 datalet data = {status: true,user: [],total: 0,activity: {sports: 1}}
// A flag that checks whether all conditions were met or notvar passed = true;
// Boolean checkif (data['status'] === undefined || data['status'] == false){console.log("Undefined / no `status` data");passed = false;}
// Array/dict checkif (data['user'] === undefined || !data['user'].length){console.log("Undefined / no `user` data");passed = false;}
// Checking a key in a dictionaryif (data['activity'] === undefined || data['activity']['time'] === undefined){console.log("Undefined / no `time` data");passed = false;}
// Other values checkif (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和undefined的意思是一样的："有东西不见了"。为了可预测性，你需要检查这两个值。然后== null做得很完美，因为它正好涵盖了这两个值。（即#2等于#4）

  • 在特殊情况下，你希望做在null和undefined之间有一个明确的区别。在这种情况下，你最好用严格的=== undefined或=== null。（例如，缺少/忽略/跳过和空/清除/删除之间的区别。）但它是罕见。

这不仅是罕见的，也是应该避免的。你不能将undefined存储在传统的数据库中。由于互操作性的原因，你也不应该在API设计中依赖undefined值。但是即使你根本不区分，你不能假设#0不会发生。我们周围的人都会间接采取泛化null/undefined的行为（这就是为什么像这样的问题被关闭为"固执己见"。）。

所以，回到你的问题。使用== null没有错。它做了它应该做的事情。

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

// FIX 2 --> but == covers bothconst 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 wayif (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));}
小开

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

检查空值

let testA = null; //nullconsole.log(Object.is(testA, null)); //true //null === null
if(Object.is(testA, null)) {console.log("This is a Null Value");}
Output:trueThis is a Null Value

检查未定义的值

let testB; //undefinedconsole.log(Object.is(testB, undefined)); //true //undefined === undefined
if(Object.is(testB, undefined)) {console.log("This is an undefined Value");}
Output:trueThis is an undefined Value

如果您想同时检查未定义和null，请使用此选项。

let testC; //undefinedconsole.log(Object.is(testC, undefined)); //true //undefined === undefinedconsole.log(Object.is(testC, null)); //false //undefined === null
if (Object.is(testC, undefined) || Object.is(testC, null)){console.log("The value is either undefined or null");}
if (!(Object.is(testC, undefined) || Object.is(testC, null))){console.log("The value is neither undefined nor null");}
Output:truefalseThe value is either undefined or null

点击查看：https://onecompiler.com/javascript/3ymdqd34v

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


提交答案