为什么null为对象，并且null和undefined有什么区别？

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

正在检查

if ( object == null )
      Do something

与...相同

if ( !object )
      Do something

？

并且：

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 === true。

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

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

null是不是一个对象，它是一个原始值。例如，您不能向其添加属性。有时人们会错误地认为它是一个对象，因为typeof nullreturn "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
• 字串： ""

您可以通过将其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)，那么这两个检查都是假的。

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

在类似object==null的情况下，不明显的结果可能是错误的来源。使用==不推荐过，用===代替。

问题的第三部分：

还有：

null和undefined有什么区别？

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

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

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

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

'false'，'true'和'！' 是可以简化，例如蠕虫的另一个袋子，if(!x)而if(x)单是足够了，你不需要真假。

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

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

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

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

一些精度：

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

发生if以下情况if( o )：

对括号o中的表达式进行求值，然后if对括号中的表达式的值进行类型强制-在本例中为踢o。

JavaScript中的Falsy（将被强制转换为false）的值为：”，null，undefined，0和false。

要添加到的答案之间有什么differrence undefined和null，从JavaScript的权威指南第6版，在此页第41页：

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

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

以下功能说明了原因并能够解决差异：

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具有null和undefined：尽管null是-与其他语言一样，对象undefined也不能是对象，因为没有可用的实例（甚至不是null实例）。

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

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

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

此外checkif if (!o)是不一样的检查if (o == null)的o是false。

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

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

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

用Java语言 null不是一种object类型，而是一种primitave类型。

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

看这个：

   <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的原理”

但是为什么类型为null的对象呢？（实际上，这是设计和维护JavaScript的委员会TC39确认为错误。您可能会认为null为空对象指针，使“对象”成为逻辑返回值，但这仍然令人困惑。）

扎卡斯（Nicholas 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”，则您会知道“有人在该程序的某个位置，将其设置为因此，我建议当您需要删除变量的值时，请不要“删除”，而是将其设置为“空”。旧值将被孤立，不久将被垃圾回收；新值是“没有值（现在）”。在这两种情况下，变量的状态都是确定的：“显然，它是故意这样做的。”

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

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

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