为什么 null 为对象,并且 null 和 undefined 有什么区别?

if ( object == null )
      Do something
if ( !object )
      Do something

答案

(name is undefined)

你: name什么? (*)
JavaScript: name ?叫什么name ?我不知道你在说什么您以前从未提到过任何name 。您是否在(客户端)看到其他脚本语言?

name = null;

你: name什么?
JavaScript:我不知道。

简而言之; undefined是不存在事物概念的地方;它没有类型,并且在该范围内从未被引用过; null是已知事物存在的位置,但不知道其值是什么。

要记住的一件事是,从概念上讲, nullfalse""等并不相同,即使它们在类型转换之后相等,即

name = false;

你: name什么?
JavaScript:布尔值 false。

name = '';

你: name什么?
JavaScript:空字符串


*:在此上下文中, name表示从未定义的变量。它可以是任何未定义的变量,但是 name 是几乎任何 HTML 表单元素的属性。它沿路前进,早在 id 之前就已建立。这很有用,因为 id 必须是唯一的,但名称不必是唯一的。

差异可以概括为以下代码段:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined) //true
alert(null == undefined)  //true

检查

object == null不同于检查if ( !object )

后者等于! Boolean(object) ,因为一元!运算符会自动将正确的操作数转换为布尔值。

由于Boolean(null)等于 false,所以!false === true

因此,如果您的对象不是 null而是 false0“” ,则检查将通过,因为:

alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false

null 不是对象 ,它是原始值 。例如,您不能向其添加属性。有时人们会错误地认为它是一个对象,因为typeof null返回"object" 。但这实际上是一个错误(甚至可以在 ECMAScript 6 中修复)。

nullundefined之间的区别如下:

  • undefined :由 JavaScript 使用,表示 “无价值”。未初始化的变量,缺失的参数和未知变量具有该值。

    > var noValueYet;
    > console.log(noValueYet);
    undefined
    
    > function foo(x) { console.log(x) }
    > foo()
    undefined
    
    > var obj = {};
    > console.log(obj.unknownProperty)
    undefined

    但是,访问未知变量会产生异常:

    > unknownVariable
    ReferenceError: unknownVariable is not defined
  • null :程序员使用它来表示 “无值”,例如,作为函数的参数。

检查变量:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

通常,应该在 JavaScript 中始终使用 === 且永远不要使用 ==(== 会执行各种可能产生意外结果的转换 )。校验x == null是一种边缘情况,因为它适用于nullundefined

> null == null
true
> undefined == null
true

检查变量是否具有值的一种常见方法是将其转换为布尔值,然后查看其是否为true 。该转换由if语句和布尔运算符执行! (“不”)。

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

这种方法的缺点:以下所有值的计算结果均为false ,因此必须小心(例如,上述检查无法区分undefined0 )。

  • undefinednull
  • 布尔值: false
  • 数字: +0-0NaN
  • 字符串: ""

您可以通过使用Boolean作为函数来测试到 boolean 的转换(通常是一个构造函数,与new一起使用):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

null 和 undefined 有什么区别?

没有定义的属性未定义。 null 是一个对象。它的类型是对象。 null 是一个特殊值,表示 “无值。undefined 不是对象,类型是 undefined。

您可以声明一个变量,将其设置为 null,其行为是相同的,除了看到的是 “null” 和 “undefined”。您甚至可以将未定义的变量与 null 进行比较,反之亦然,条件将为 true:

undefined == null
 null == undefined

有关更多详细信息,请参见JavaScript null 与 undefined 之间的区别

和您的新编辑

if (object == null)  does mean the same  if(!object)

在测试 object 是否为 false 时,它们都仅在测试false时满足条件,而在 true 时不满足条件

在这里检查: Javascript 陷阱

问题的第一部分:

为什么在 JavaScript 中将 null 视为对象?

这是一个 JavaScript 设计错误,目前无法修复。它应该是 null 类型,而不是 object 类型,或者根本没有。在检测真实对象时,它需要进行额外的检查(有时被遗忘),并且是错误的来源。

问题的第二部分:

正在检查


if (object == null)
Do something

与... 相同

if (!object)
Do something

除以下几点外,这两项检查都始终为假:

  • object 未定义或为 null:均为 true。

  • object 是基本类型,并且为 0, ""或 false:第一次检查 false,第二次检查 true。

如果对象不是原始对象,而是真实的对象(例如new Number(0)new String("")new Boolean(false) ,则两个检查都为 false。

因此,如果将 “对象” 解释为实际对象,则两个检查始终相同。如果允许使用原语,则对于 0, ""和 false 的检查是不同的。

object==null类的情况下,不明显的结果可能是错误的来源。绝不建议使用== ,而应使用===

问题的第三部分:

并且:

null 和 undefined 有什么区别?

在 JavaScript 中,一个区别是 null 为 object 类型,而 undefined 为 undefined 类型。

在 JavaScript 中, null==undefined为 true,如果类型被忽略,则视为相等。为什么他们决定,但 0, ""和 false 不相等,我不知道。这似乎是一个任意看法。

在 JavaScript 中, null===undefined不是 true,因为类型必须在===相同。

实际上,null 和 undefined 是相同的,因为它们都表示不存在。因此,0 和""也是如此,也许还有空容器[]{} 。如此多的相同的东西都是导致错误的良方。一种或根本没有更好。我会尝试使用尽可能少的。

'false','true' 和 '!' 是另一种可以简化的蠕虫,例如,仅if(!x)if(x)就足够了,您不需要 true 和 false。

如果没有给出值,则声明的var x的类型为 undefined,但它应该与从未声明过 x 的变量相同。另一个错误源是一个空的无容器。因此,最好像var x=1一样一起声明和定义它。

人们四处走动,试图找出所有这些类型的虚无,但都是一件复杂而又不同的衣服。现实是

undefined===undeclared===null===0===""===[]==={}===nothing

也许所有人都应该抛出异常。

var x = null;

x 定义为 null

y 未定义; // 因为我没有定义它

if (!x)

null 被评估为 false

理解 null 和 undefined 的一种方法是了解每种情况的发生位置。

在以下情况下,期望返回空值:

  • 查询 DOM 的方法

    console.log(window.document.getElementById("nonExistentElement"));
    //Prints: null
  • 从 Ajax 请求收到的 JSON 响应

{
      name: "Bob",
      address: null
    }
  • RegEx.exec

  • 不断变化的新功能。以下返回 null:

var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

所有其他不存在的情况都由 undefined 表示(如 @Axel 所示)。以下每个打印 “未定义”:

var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());

当然,如果您决定编写 var unitialized = null; 或自己从方法返回 null,则在其他情况下会出现 null。但这应该很明显。

第三种情况是您要访问变量,但您甚至不知道它是否已声明。对于这种情况,请使用 typeof 以避免引用错误:

if(typeof unknown !== "undefined"){
    //use unknown
}

总而言之,在处理 DOM,处理 Ajax 或使用某些 ECMAScript 5 功能时,请检查是否为 null。对于所有其他情况,可以使用严格的相等性检查 undefined 是安全的:

if(value === undefined){
  // stuff
}

JavaScript 中许多不同的空检查的比较:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

JavaScript空检查比较表

对于值相等,null 和 undefined 均为 false(null == undefined):它们都折叠为布尔值 false。它们不是同一对象(null!== undefined)。

undefined 是全局对象的属性(浏览器中为 “窗口”),但它是原始类型,而不是对象本身。这是未初始化的变量和函数的默认值,这些变量和函数以没有 return 语句的形式结束。

null 是 Object 的实例。对于用于返回集合对象以指示空结果的 DOM 方法,将使用 null,该方法提供错误值而未指示错误。

一些精度:

null 和 undefined 两个不同的值。一个代表缺少名称的值,另一个代表缺少名称。


ifif( o )进行以下操作, if( o )会发生什么:

计算括号 o 中的表达式,然后计算if强制将括号中表达式的值强制类型化(在我们的情况下为o

JavaScript 中的 Falsy(将被强制转换为 false)的值为: ”,null,undefined,0 和 false