javascript - 为什么 null 是一个对象，null 和 undefined 有什么区别？

Question

为什么在 JavaScript 中被null认为是一个？object

正在检查

if ( object == null )
      Do something

一样

if ( !object )
      Do something

?

并且：

null和和有什么不一样undefined？

score 1524 · Accepted Answer

(name is undefined)

你：是什么name？^(*)
JavaScript: name ? 什么是name？我不知道你在说什么。你以前从来没有提到name过。您是否在（客户端）端看到了其他一些脚本语言？

name = null;

你：是什么name？
JavaScript：我不知道。

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

要记住的一件事null是，从概念上讲，它与falseor""或此类不同，即使它们在类型转换之后等同，即

name = false;

你：是什么name？
JavaScript：布尔值错误。

name = '';

你：是什么name？
JavaScript：空字符串

^{*：name在这种情况下，是指从未定义过的变量。它可以是任何未定义的变量，但是，name 几乎是任何 HTML 表单元素的属性。它可以追溯到很久以前，并且是在 id 之前建立的。它很有用，因为 id 必须是唯一的，但名称不必是唯一的。}

score 146 · Accepted Answer

差异可以总结为以下代码段：

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 then !false === true。

因此，如果您的对象不是 null，而是 false或0或""，则检查将通过，因为：

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

score 132 · Accepted Answer

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

null和的区别undefined如下：

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是一种极端情况，因为它适用于null和undefined：

> 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，因此您必须小心（例如，上述检查无法区分undefined和0）。

undefined,null
布尔值：false
数字：+0, -0,NaN
字符串：""

您可以通过使用 as 函数来测试到布尔值的转换Boolean（通常它是一个构造函数，与一起使用new）：

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

score 26 · Accepted Answer

null 和 undefined 有什么区别？？

没有定义的属性是undefined。anull是一个对象。它的类型是object. null 是一个特殊的值，意思是“没有值。undefined 不是一个对象，它的类型是 undefined。

您可以声明一个变量，将其设置为 null，并且行为是相同的，只是您会看到打印出的“null”与“undefined”。您甚至可以将未定义的变量与 null 进行比较，反之亦然，条件为真：

 undefined == null
 null == undefined

有关更多详细信息，请参阅JavaScript null 和 undefined 之间的区别。

和你的新编辑是

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

在测试 if为 false 时，它们都只在测试 if falseobject时满足条件，但在测试时不满足条件 true

在这里检查：Javascript 陷阱

score 21 · Accepted Answer

问题的第一部分：

为什么 null 在 JavaScript 中被视为对象？

这是他们现在无法修复的 JavaScript 设计错误。它应该是 null 类型，而不是 object 类型，或者根本没有它。在检测真实物体时需要进行额外的检查（有时会被遗忘），并且是错误的来源。

问题的第二部分：

检查

if (object == null)
Do something

与

if (!object)
Do something

这两项检查总是都是假的，除了：

对象未定义或为空：两者都为真。
object 是原始的，并且 0、""或 false：首先检查 false，然后检查 true。

如果对象不是原始对象，而是真正的对象，例如new Number(0)、new String("")或new Boolean(false)，那么这两个检查都是错误的。

因此，如果“对象”被解释为一个真正的对象，那么两个检查总是相同的。如果允许原语，则检查对于 0 ""、和 false 是不同的。

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

问题的第三部分：

还有：

null 和 undefined 有什么区别？

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

在 JavaScript 中，null==undefined为 true，如果忽略类型，则认为相等。为什么他们决定这样做，但是 0""和 false 不相等，我不知道。这似乎是一个武断的意见。

在 JavaScript 中，null===undefined这是不正确的，因为类型必须在===.

实际上，null 和 undefined 是相同的，因为它们都表示不存在。0""也是如此，就此而言，可能还有空容器[]和{}. 这么多类型的相同无是错误的秘诀。一种或根本没有更好。我会尽量少用。

“假”、“真”和“！” 是另一袋可以简化的蠕虫，例如，if(!x)单独if(x)就足够了，您不需要真假。

如果没有给出值，则声明var x的类型是未定义的，但它应该与根本没有声明 x 相同。另一个错误来源是一个空的空容器。所以最好一起声明和定义，比如var x=1.

人们绕着圈子转来转去，试图弄清楚所有这些各种各样的虚无，但在复杂的不同衣服中都是一样的东西。现实是

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

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

score 12 · Accepted Answer

typeof null;      // object
typeof undefined; // undefined

值 null 表示有意缺少任何对象值。它是 JavaScript 的原始值之一，对于布尔运算被视为虚假值。

var x = null;
var y;

x 被声明并定义为 null

y 已声明但未定义。它被声明为没有值，因此它是未定义的。

z 未声明，因此如果您尝试使用 z 也将是未定义的。

score 9 · Accepted Answer

理解 null 和 undefined 的一种方法是了解它们出现的位置。

在以下情况下预期返回 null 值：

查询 DOM 的方法

console.log(window.document.getElementById("nonExistentElement"));
//Prints: null

从 Ajax 请求收到的 JSON 响应


    {
      name: "Bob",
      address: null
    }

正则表达式.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 unitialised = null; 或自己从方法返回 null 然后在其他情况下会出现 null 。但这应该很明显。

第三种情况是当您想要访问一个变量但您甚至不知道它是否已被声明时。对于这种情况，使用 typeof 来避免引用错误：

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

总之，在您操作 DOM、处理 Ajax 或使用某些 ECMAScript 5 功能时检查 null。对于所有其他情况，使用严格相等检查 undefined 是安全的：

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

score 9 · Accepted Answer

TLDR

undefined是 JavaScript 中的原始值，表示值的隐式缺失。未初始化的变量自动具有此值，并且没有显式return语句的函数 return undefined。

null也是 JavaScript 中的原始值。它表示有意缺少对象值。nullin JavaScript 旨在实现与Java的互操作性。

typeof null返回"object"是因为语言设计的特殊性，源于 JavaScript 与 Java 可互操作的需求。这并不意味着null是一个对象的实例。这意味着：给定 JavaScript 中的原始类型树，null是“对象类型原始”子树的一部分。这将在下面更全面地解释。

细节

undefined是一个原始值，表示值的隐含缺失。请注意，undefined直到1998 年的JavaScript 1.3才可以直接访问它。这告诉我们，null程序员在明确指示缺少值时使用的值。未初始化的变量自动具有值undefined。undefined是ECMAScript 规范中独一无二的类型。

null是表示有意不存在对象值的原始值。在 ECMAScript 规范中null也是一种独一无二的类型。

nullin JavaScript 的设计旨在实现与Java的互操作性，无论是从“外观”的角度还是从编程的角度（例如，计划于 1996 年推出的 LiveConnect Java/JS 桥）。此后，Brendan Eich 和其他人都对包含两个“缺乏价值”的值表示反感，但在 1995 年，Eich 被命令“让 [JavaScript] 看起来像 Java”。

布伦丹·艾希：

如果我没有“让它看起来像 Java”作为管理层的命令，并且我有更多的时间（很难混淆这两个因果因素），那么我会更喜欢类似自我的“一切都是对象”的方法：没有布尔、数字、字符串包装器。没有未定义和空值。叹。

为了适应 Java 的概念null，由于 Java 的强类型特性，只能将其分配给类型为引用类型（而不是原语）的变量，Eich 选择将特殊null值定位在对象原型链的顶部（即引用类型的顶部），并将该null类型作为“对象类型原语”集的一部分。

typeof此后不久，该运算符被添加到 1996 年 8 月 19 日发布的 JavaScript 1.1中。

来自V8 博客：

typeof null返回object，而不是null，尽管null是它自己的类型。要理解原因，请考虑将所有 JavaScript 类型的集合分为两组：

对象（即对象类型）

原语（即任何非对象值）

因此，null意味着“没有对象价值”，而undefined意味着“没有价值”。

遵循这一思路，Brendan Eich 设计了 JavaScript typeof，以本着 Java 的精神为右侧的所有值（即所有对象和空值）返回“对象”。这就是为什么 typeof null === 'object'尽管规范有一个单独的null类型。

因此，Eich 设计了原始类型的层次结构以实现与 Java 的互操作性。这导致他null与层次结构中的“对象类型基元”一起定位。为了体现这一点，在typeof不久之后被添加到语言中时，他选择typeof null了返回"object"。

JavaScript 开发人员表示惊讶的typeof null === "object"是，一种同时具有和的弱类型语言 (JavaScript)与另一种仅具有和的强类型语言 (Java)null之间阻抗不匹配（或抽象泄漏）的结果被严格定义为引用引用类型（不是原始类型）。undefinednullnull

请注意，这一切都是合乎逻辑的、合理的和可辩护的。typeof null === "object"不是错误，而是必须适应 Java 互操作性的二阶效应。

出现了许多不完美的向后合理化和/或惯例，包括undefined暗示价值的隐含缺失，以及null表明价值的故意缺失；或者那undefined是没有值，null特别是没有对象值。

与 Brendan Eich 的相关对话，为后代截图：

score 8 · Accepted Answer

JavaScript 中许多不同的 null 检查的比较：

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 检查比较表

score 6 · Accepted Answer

要添加到 JavaScript Definitive Guide 6th Edition, p.41 on this page 的What is the difference between undefinedandnull的答案：

您可能会考虑undefined表示系统级、意外或类似错误的值缺失，并null表示程序级、正常或预期的值缺失。如果您需要将这些值之一分配给变量或属性或将这些值之一传递给函数，null这几乎总是正确的选择。

score 5 · Accepted Answer

对于值相等（null==undefined），null 和 undefined 都是 false：它们都折叠为布尔 false。它们不是同一个对象（null！==undefined）。

undefined 是全局对象（浏览器中的“窗口”）的属性，但它是原始类型而不是对象本身。它是未初始化的变量和没有返回语句结束的函数的默认值。

null 是 Object 的一个实例。null 用于返回集合对象以指示空结果的 DOM 方法，它提供 false 值而不指示错误。

score 5 · Accepted Answer

一些精度：

null 和 undefined是两个不同的值。一个表示没有名称的值，另一个表示没有名称。

在 an 中发生的情况if如下if( o )：

括号 o 中的表达式被求值，然后对if括号中的表达式的值进行类型强制 - 在我们的例子中o。

JavaScript 中的 Falsy（将被强制为 false）值为：''、null、undefined、0 和 false。

score 2 · Accepted Answer

例如window.someWeirdProperty是未定义的，所以

"window.someWeirdProperty === null"评估为假，而

"window.someWeirdProperty === undefined"评估为真。

此外， checkifif (!o)与检查if (o == null)beingo不同false。

score 2 · Accepted Answer

以下函数显示了为什么并且能够解决差异：

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

如果你打电话

test();

你得到

不明确的

空值

第一个console.log(...)尝试在尚未定义时从中获取 - 所以它返回“未定义” myProperty。myObj在将 null 分配给它之后，第二个console.log(...)显然返回“null”，因为myProperty存在，但它具有null分配给它的值。

为了能够查询这种差异，JavaScript 具有nulland undefined: While nullis - 就像在其他语言中的对象一样，undefined不能是对象，因为没有null可用的实例（甚至不是实例）。

score 2 · Accepted Answer

在Javascript null中，它不是一种object类型，它是一种primitave类型。

有什么不同？ 未定义是指尚未设置的指针。 Null指的是空指针，例如某些东西已手动将变量设置为类型null

score 2 · Accepted Answer

看这个：

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

score 1 · Accepted Answer

null是一个对象。它的类型为空。undefined不是一个对象；它的类型是未定义的。

score 1 · Accepted Answer

摘自 Nicholas C. Zakas 的“面向对象 Javascript 的原理”

但是为什么当类型为空时是一个对象呢？（事实上，设计和维护 JavaScript 的委员会 TC39 已经承认这是一个错误。你可以推断 null 是一个空对象指针，使“对象”成为逻辑返回值，但这仍然令人困惑。）

Zakas, Nicholas C. (2014-02-07)。面向对象 JavaScript 的原理（Kindle Locations 226-227）。没有淀粉出版社。Kindle版。

那说：

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

未定义的情况：

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

score 1 · Accepted Answer

考虑“null”的最佳方式是回忆数据库中如何使用类似概念，它表示字段包含“根本没有值”。

是的，物品的价值是已知的；它是“定义的”。它已被初始化。
该项目的价值是：“没有价值。”

对于编写更容易调试的程序，这是一种非常有用的技术。“未定义”变量可能是错误的结果...... （你怎么知道？） ......但是如果变量包含值'null'，你知道“某人，在这个程序的某个地方，将它设置为'null。'”因此，我建议，当您需要摆脱变量的值时，不要“删除”......将其设置为'null。' 旧值将被孤立，很快将被垃圾回收；新的价值是，“没有价值（现在）。” 在这两种情况下，变量的状态都是确定的：“很明显，它是故意的。”

score 1 · Accepted Answer

与 undefined 相比，null 的另一个有趣之处在于它可以递增。

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

这对于设置计数器的默认数值很有用。您在声明中将变量设置为 -1 多少次？

score 1 · Accepted Answer

未定义表示已声明变量但尚未为其分配任何值，而可以将 Null 分配给表示“无值”的变量。（Null 是赋值运算符）

2.Undefined 本身是一个类型，而 Null 是一个对象。

3.Javascript本身可以将任何未分配的变量初始化为未定义，但它永远不能将变量的值设置为null。这必须以编程方式完成。

score 0 · Accepted Answer

使用 null 将某些东西定义为没有值，当您期望某些东西可能根本没有定义时使用 undefined。

例如，如果一个变量没有值，则将其赋值为 null。

var weDontHaveAValue = null;

如果您希望某些内容可能根本没有定义，例如可选的选项参数，请使用 undefined。

if (typeof args.optionalParam !== 'undefined') { }

javascript - 为什么 null 是一个对象，null 和 undefined 有什么区别？

22 回答 22

Related

Reference