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

null是一个对象。其类型为 null。 不是对象;其类型未定义。undefined

null 和 undefined 有什么区别？？

没有定义的属性是 。a 是一个对象。其类型为 。null 是一个特殊值，表示“没有值。undefined 不是对象，它的类型是 undefined。undefinednullobject

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

 undefined == null
 null == undefined

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

并且您的新编辑是

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

当测试 if 为 false 时，它们都只在测试 if false 时满足条件，而在 true 时不满足条件object

在这里查看： Javascript 陷阱

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

"window.someWeirdProperty === null"计算结果为 false，而

"window.someWeirdProperty === undefined"计算结果为 true。

此外，checkif 与检查 being 不同。if (!o)if (o == null)ofalse

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

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

var x = null;
var y;

x 被声明并定义为 null

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

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

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

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

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

差异可以归纳为以下代码段：

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

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

检查

object == null是不同的检查。if ( !object )

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

由于等于 false 则 .Boolean(null)!false === true

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

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

(name is undefined)

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

name = null;

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

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

要记住的一件事是，从概念上讲，这与 or 或 such 并不相同，即使它们等同于类型转换，即nullfalse""

name = false;

你：什么？
JavaScript：布尔值 false。name

name = '';

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

^{*：在此上下文中，名称是指从未定义过的变量。它可以是任何未定义的变量，但是，name 几乎是任何 HTML 表单元素的属性。它可以追溯到很久以前，并且早在 id 之前就已经建立起来了。这很有用，因为 ID 必须是唯一的，但名称不必是唯一的。}

一些精度：

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

发生的情况如下：ifif( o )

计算括号 o 中的表达式，然后对括号中的表达式的值进行类型强制执行 - 在我们的例子中。ifo

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

问题的第一部分：

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

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

问题的第二部分：

检查





与if (object == null)Do something

if (!object)
Do something

这两个检查始终都是假的，除了：

• object is undefined 或 null：均为 true。

• object 是原始的，并且 0、 或 false：首先检查 false，第二个检查 true。""

如果对象不是基元，而是实 Object，如 、 或 ，则这两个检查都是假的。new Number(0)new String("")new Boolean(false)

因此，如果“对象”被解释为表示真实的对象，那么这两个检查总是相同的。如果允许使用基元，则 0、 和 false 的检查不同。""

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

问题的第三部分：

还有：

null 和 undefined 有什么区别？

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

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

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

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

例如，“false”、“true”和“！”是另一组可以简化的蠕虫，仅凭这些蠕虫就足够了，你不需要真假。if(!x)if(x)

如果未给出任何值，则声明的类型为 undefined，但它应该与从未声明过 x 相同。另一个 bug 源是一个空的 nothing 容器。所以最好一起声明和定义它，比如.var xvar x=1

人们兜兜转转，试图弄清楚所有这些不同类型的虚无，但这一切都只是穿着复杂不同衣服的同一件事。现实情况是

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

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

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

和的区别如下：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 == nullnullundefined

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

检查变量是否具有值的常用方法是将其转换为布尔值，然后查看它是否为 。该转换由语句和布尔运算符执行！（“不是”）。trueif

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";
}

这种方法的缺点：以下所有值的计算结果都为 ，因此您必须小心（例如，上述检查无法区分 和 ）。falseundefined0

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

您可以通过用作函数来测试到布尔值的转换（通常它是一个构造函数，用于）：Booleannew

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

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

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

• 查询 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 unitialised = null;或者自己从方法返回 null，然后在其他情况下发生 null。但这应该是很明显的。

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

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

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

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

要添加到以下页面的 JavaScript 权威指南第 6 版第 41 页的 undefined 和 null 之间的区别是什么的答案中：

您可以考虑表示系统级的、意外的、 或类似错误的价值缺失，并表示程序级别， 正常或预期没有价值。如果需要分配以下项之一 这些值到变量或属性，或将其中一个值传递给 一个函数，几乎总是正确的选择。undefinednullnull

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

以下函数显示了原因，并且能够计算出差异：

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

如果您调用

test();

你正在得到

定义

零

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

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

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

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

扎卡斯，尼古拉斯C.（2014-02-07）。面向对象的 JavaScript 原理（Kindle 位置 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”的最好方法是回想一下在数据库中如何使用类似的概念，它表示字段包含“根本没有值”。

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

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

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

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

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

1. Undefined 表示已声明变量，但尚未为其赋值，而 Null 可以赋值给表示“无值”的变量。（Null 是赋值运算符）

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

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

在 Javascript 中，它不是一种类型，而是一种类型。nullobjectprimitave

有什么区别？ “未定义”是指尚未设置的指针。Null 是指 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

顶级域名

undefined是 JavaScript 中的一个原始值，表示隐式缺少值。未初始化的变量会自动具有此值，并且没有显式语句的函数返回 .returnundefined

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

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

详

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

null是一个基元值，表示有意缺少对象值。 也是 ECMAScript 规范中独一无二的类型。null

null在 JavaScript 中，旨在从“外观”角度和编程角度（例如，1996 年计划的 LiveConnect Java/JS 桥接）实现与 Java 的互操作性。此后，Brendan Eich 和其他人都对包含两个“缺乏价值”的值表示厌恶，但在 1995 年，Eich 奉命“让 [JavaScript] 看起来像 Java”。

布兰登·艾希（Brendan Eich）：

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

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

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

来自 V8 博客：

typeof null返回 ，而不是 ，尽管是 自己的类型。要理解为什么，请考虑所有 JavaScript 类型分为两组：objectnullnull

1. 对象（即对象类型）
2. 基元（即任何非对象值）

因此，表示“无对象值”，而表示“无 值”。nullundefined

按照这个思路，Brendan Eich 设计了 JavaScript make 返回右侧所有值的 'object'， 即所有对象和 null 值，本着 Java 的精神。这就是为什么尽管规范具有单独的类型。typeoftypeof null === 'object'null

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

JavaScript 开发人员所表达的惊讶是由于同时具有 和 的弱类型语言 （JavaScript） 与另一种只有 的强类型语言 （Java） 之间的阻抗不匹配（或抽象泄漏）的结果，并且严格定义为引用类型（而不是原始类型）。typeof null === "object"nullundefinednullnull

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

出现了一些不完美的逆向合理化和/或惯例，包括表示隐含的缺乏价值，以及表明故意缺乏价值;或者，这是缺少值，特别是缺少对象值。undefinednullundefinednull

与Brendan Eich的相关对话，截图供后人参考：

使用 null 将某些内容定义为没有值，当您预计某些内容可能根本没有定义时，请使用 undefined。

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

var weDontHaveAValue = null;

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

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

什么是类型？

类型是对值进行分类的一种方式。下面是一个包含相关类型及其结果的表格。typeof

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

运营商在撒谎！它返回是 JavaScript 语言中的一个错误。typeof"object"null

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

null 和 undefined 之间的主要区别在于 null 表示 缺少的对象，而 undefined 表示变量的未初始化状态。

您可以将 null 视为未定义的对象，但 undefined 将仅是未定义的对象 因为它的类型是未定义的。

let a; 
console.log(a); //undefined, since it is declared but not initialized

console.log(null == undefined) //true
console.log(null === undefined) // false

console.log(typeof null) //object
console.log(typeof undefined) //undefined

未定义和未定义不是一回事。

age;

你：价值是什么？age

计算机：好的，让我检查一下我的记忆/参考表.....在这一点上（你问的时候），我没有看到任何名为 的标识符，不在此范围/上下文或任何父范围/上下文中; 我不知道。也许稍后我会遇到将该标识符添加到内存中的指令，但它现在不存在。ageage

var age;

你：价值是什么age;

电脑：好的，检查一下我的记忆...我在我的参考表中看到一个带有该名称的标识符，但在我添加它时没有为其分配任何值或指针或任何内容，所以我不知道;你可以认为它（）是空的/没有的/无用的。ageage

var age = null;

你：价值是什么age;

电脑：好的，检查一下我的记忆...我在参考表中看到：它是空的。基本上，它什么都没有/空，你不能用这个值做任何事情;这是故意的。age

现在，我可能不应该这样解释它，但希望它是有道理的。

我明白为什么 null 被设计为 JS 中的一个对象，我个人喜欢这种方式。

null实际上意味着同样的事情：空/无。区别在于它在概念上的使用方式。undefined

我看作是开发人员想要的虚无;有些东西是空的，是故意不代表任何东西的。我把未定义看作是计算机想要的虚无;开发人员/用户偶然没有价值的东西。null

例如，如果你从库/sdk 调用一个函数并得到 null，你几乎可以肯定这是开发人员/作者故意设计的;他们特别想表示虚无。

另请参阅 - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/null