广告1。Null不是全局对象属性的标识符，不像undefined可以

让x;/ /定义 让y =零;/ /空 让z = 3;//有值 // 'w' //未声明 If (!x) console.log('x为空或未定义'); 如果(!y) console.log('y是空的或未定义的'); If (!z) console.log('z为空或未定义'); Try {if(w) 0} catch(e) {console.log('w is undefined ')} // typeof不抛出未声明变量的异常 If (typeof w === 'undefined') console.log('w is undefined');

广告2。===检查值和类型。==不需要相同的类型，并在比较之前进行隐式转换(使用. valueof()和. tostring())。这里你有所有(src):

if

==(否定!=)

===(它的否定!==)

我如何检查一个变量，如果它是空的或未定义…

变量是null吗?

if (a === null)
// or
if (a == null) // but see note below

.．.但注意，如果a未定义，后者也成立。

是否未定义:

if (typeof a === "undefined")
// or
if (a === undefined)
// or
if (a == undefined) // but see note below

.．.但是，请再次注意，最后一个是模糊的;如果a为空，它也为真。

现在，尽管有上述情况，检查它们的通常方法是利用它们是假的这一事实:

if (!a) {
    // `a` is falsey, which includes `undefined` and `null`
    // (and `""`, and `0`, and `NaN`, and [of course] `false`)
}

这是由规范中的ToBoolean定义的。

.．.null和undefined的区别是什么?

They're both values usually used to indicate the absence of something. undefined is the more generic one, used as the default value of variables until they're assigned some other value, as the value of function arguments that weren't provided when the function was called, and as the value you get when you ask an object for a property it doesn't have. But it can also be explicitly used in all of those situations. (There's a difference between an object not having a property, and having the property with the value undefined; there's a difference between calling a function with the value undefined for an argument, and leaving that argument off entirely.)

null比undefined更具体:它是一个空白对象引用。JavaScript当然是松散类型的，但并不是所有与JavaScript交互的东西都是松散类型的。如果像浏览器中的DOM这样的API需要一个空白的对象引用，我们使用null，而不是undefined。类似地，DOM的getElementById操作返回一个对象引用——一个有效的引用(如果它找到了DOM元素)，或者null(如果没有)。

有趣的是(或者不有趣)，他们有自己的类型。也就是说，null是null类型中的唯一值，而undefined是undefined类型中的唯一值。

“==”和“===”有什么区别?

它们之间的唯一区别是==将执行类型强制以尝试使值匹配，而===不会。例如"1" == 1为真，因为"1"强制为1。但是"1" === 1是假的，因为类型不匹配。("1" !== 1为真。)===的第一步(实际)是“操作数的类型相同吗?”，如果答案是“否”，则结果为假。如果类型相同，则执行==所执行的操作。

类型强制使用相当复杂的规则，并可能产生令人惊讶的结果(例如，"" == 0为真)。

详细说明如下:

等号比较(==，也叫“松散”等号) 严格相等比较(===)

差别很细微。

在JavaScript中，未定义的变量是一个从未声明或从未赋值的变量。假设你声明var a;例如，a将是未定义的，因为它从未被赋值。

但如果你赋值a = null;那么a现在是空的。在JavaScript中，null是一个对象(如果你不相信我，可以在JavaScript控制台中试试typeof null)，这意味着null是一个值(事实上，甚至undefined也是一个值)。

例子:

var a;
typeof a;     # => "undefined"

a = null;
typeof null;  # => "object"

这在函数参数中很有用。您可能希望有一个默认值，但可以考虑null。在这种情况下，你可以:

function doSomething(first, second, optional) {
    if (typeof optional === "undefined") {
        optional = "three";
    }
    // do something
}

如果你省略了可选参数doSomething(1,2)，那么optional将是“three”字符串，但如果你传递doSomething(1,2, null)，那么optional将是null。

至于equal ==和strict equal ===比较器，第一个是弱类型，而strict equal也检查值的类型。这意味着0 == "0"将返回true;而0 === "0"将返回false，因为数字不是字符串。

您可以使用这些操作符来检查undefined和null之间的值。例如:

null === null            # => true
undefined === undefined  # => true
undefined === null       # => false
undefined == null        # => true

最后一种情况很有趣，因为它允许你检查一个变量是否为undefined或null。

function test(val) {
    return val == null;
}
test(null);       # => true
test(undefined);  # => true

未定义的

这意味着变量还没有初始化。

例子:

var x;
if(x){ //you can check like this
   //code.
}

等于(= =)

它只检查值是否等于非数据类型。

例子:

var x = true;
var y = new Boolean(true);
x == y ; //returns true

因为它只检查值。

严格等于(= = =)

检查值和数据类型是否相同。

例子:

var x = true;
var y = new Boolean(true);
x===y; //returns false.

因为它检查数据类型x是一个基本类型，y是一个布尔对象。

如果你的(逻辑)检查是否定的(!)，你想捕获JS的null和undefined(因为不同的浏览器会给你不同的结果)，你会使用限制性较低的比较: 例如:

var ItemID = Item.get_id();
if (ItemID != null)
{
 //do stuff
}

这将捕获null和undefined

规范是这些问题的完整答案。以下是摘要:

For a variable x, you can: check whether it's null by direct comparison using ===. Example: x === null check whether it's undefined by either of two basic methods: direct comparison with undefined or typeof. For various reasons, I prefer typeof x === "undefined". check whether it's one of null and undefined by using == and relying on the slightly arcane type coercion rules that mean x == null does exactly what you want. The basic difference between == and === is that if the operands are of different types, === will always return false while == will convert one or both operands into the same type using rules that lead to some slightly unintuitive behaviour. If the operands are of the same type (e.g. both are strings, such as in the typeof comparison above), == and === will behave exactly the same.

更多阅读:

安格斯·克罗尔的《真理、平等和JavaScript》 Andrea Giammarchi的JavaScript强制解密 JavaScript常见问题:JavaScript类型转换