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

(name is undefined)

您：什么是 name？ ^(*)
JavaScript： name？什么是 name？我不知道你在说什么。您之前从未提及任何 name。您是否在（客户端）端看到了其他一些脚本语言？

name = null;

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

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

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

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，而是 false 或 0 或“”，则检查将通过，因为：

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

---

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

null 和 undefined 的区别如下：

undefined：由 JavaScript 使用，意思是“没有价值”。未初始化的变量、缺失的参数和未知变量具有该值。 > var noValueYet; > 控制台.log(noValueYet);未定义 > 函数 foo(x) { console.log(x) } > foo() 未定义 > 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 中使用 === 并且永远不要使用 ==（== 执行可能会产生意外结果的 all kinds of conversions）。检查 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）。

未定义，空

布尔值：假

数字：+0、-0、NaN

字符串：“”

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

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

---

null 和 undefined 有什么区别？？

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

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

 undefined == null
 null == undefined

有关详细信息，请参阅 JavaScript Difference between null and undefined。

和你的新编辑是

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

测试 object 是否为 false 时，它们都只满足测试 if false 的条件，但不满足条件

在这里检查：Javascript gotcha

---

问题的第一部分：

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

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

问题的第二部分：

正在检查 if (object == null) Do something 与 if (!object) Do something

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

对象未定义或为空：两者都为真。

对象是原始的，并且 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 为真，如果忽略类型，则视为相等。为什么他们决定，但 0、"" 和 false 不相等，我不知道。这似乎是一个武断的意见。

在 JavaScript 中，null===undefined 不正确，因为 === 中的类型必须相同。

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

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

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

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

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

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

---

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

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

var x = null;
var y;

x 被声明并定义为 null

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

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

---

TLDR

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

null 也是 JavaScript 中的原始值。它表示 the intentional absence of an object value。 JavaScript 中的 null 旨在实现与 Java 的互操作性。

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

细节

undefined 是一个原始值，represents 隐含没有值。请注意，直到 1998 年的 JavaScript 1.3，才可以直接访问 undefined。这告诉我们，null 旨在成为程序员在明确指示缺少值时使用的值。未初始化的变量自动具有值 undefined。 undefined 是 ECMAScript 规范中的 one-of-a-kind type。

null 是一个原始值，represents 故意缺少对象值。 null 也是 ECMAScript 规范中的 one-of-a-kind type。

JavaScript 中的 null 旨在实现与 Java、both from a "look" perspective, and from a programmatic perspective (eg the LiveConnect Java/JS bridge planned for 1996) 的互操作性。此后，Brendan Eich 和其他人都对包含 两个“缺乏价值”值表示反感，但在 1995 年，Eich under orders“让 [JavaScript] 看起来像 Java”。

Brendan Eich：

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

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

typeof 运算符是在 in JavaScript 1.1 之后不久添加的，于 1996 年 8 月 19 日发布。

从 the V8 blog：

typeof null 返回对象，而不是 null，尽管 null 是它自己的类型。要理解为什么，请考虑将所有 JavaScript 类型的集合分为两组：对象（即 Object 类型）基元（即任何非对象值） 因此，null 表示“没有对象值”，而 undefined 表示“没有价值”。

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

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

JavaScript 开发人员在 typeof null === "object" 表示的惊讶是同时具有 null 和 undefined 的弱类型语言 (JavaScript) 与另一种强类型语言 ( Java）只有 null，其中 null 是 strictly defined 来引用引用类型（不是原始类型）。

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

出现了许多不完美的反向合理化和/或约定，包括 undefined 表示 implicit 没有值，而 null 表示 intental 没有值;或者 undefined 是没有值，而 null 是没有 object 值。

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

https://i.stack.imgur.com/EVwWS.png

---

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

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

查询 DOM 的方法 console.log(window.document.getElementById("nonExistentElement")); //打印：空

从 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
}

---

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

https://i.stack.imgur.com/ThA4b.png

---

要补充 undefined 和 null 之间的区别的答案，来自 JavaScript Definitive Guide 6th Edition, p.41 on this page：

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

---

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

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

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

---

一些精度：

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

对于 if( o )，if 中发生的情况如下：

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

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

---

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

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

如果你打电话

test();

你得到

未定义的空

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

为了能够查询这种差异，JavaScript 具有 null 和 undefined：虽然 null 是 - 就像其他语言中的对象一样，但 undefined 不能是对象，因为没有实例（甚至不是null 个实例）可用。

---

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

"window.someWeirdProperty === null" 评估为 false 而

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

此外，检查 if (!o) 与检查 if (o == null) 是否为 o 是 false 不同。

---

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

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

---

看这个：

   <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

---

摘自 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.

---

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

---

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

是的，物品的价值是已知的；它是“定义的”。它已被初始化。

该项目的价值是：“没有价值。”

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

---

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

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

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

---

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

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

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

---

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

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

var weDontHaveAValue = null;

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

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

---

什么是类型？

类型是一种对值进行分类的方法。这是一个表格，其中包含有问题的类型及其 typeof 结果。

Type Values type contains typeof result typeof 结果是假的吗？仅未定义：未定义“未定义”否仅空：空“对象”是对象无限数量的值：{}，{a：“b”}，...“对象”否

null 不是对象，它是 Null 类型的值。

typeof 运算符在撒谎！它为 null 返回 "object" 是 JavaScript 语言中的错误。

我在我的开源电子书中写了一个关于这个的章节。你可以在这里阅读它https://github.com/carltheperson/advanced-js-objects

---