关于javascript：为什么null是一个对象，null和undefined之间有什么区别？


Why is null an object and what's the difference between null and undefined?

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

正在检查

1
2
if ( object == null )
      Do something

一样

1
2
if ( !object )
      Do something

？

还有：

null和undefined有什么区别？

相关讨论

1
(name is undefined)

你：什么是name？(*)javascript:name？什么是name？我不知道你在说什么。你以前没有提到过任何name。您是否在(客户端)方面看到其他脚本语言？

1
name = null;

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

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

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

1
name = false;

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

1
name = '';

你：什么是name？javascript:空字符串

*：name在此上下文中是指从未定义的变量。它可以是任何未定义的变量。但是，name是几乎所有HTML表单元素的属性。它在ID之前就已经建立了。它很有用，因为ID必须是唯一的，但名称不一定是唯一的。

相关讨论

差异可以概括为以下几点：

1
2
3
4
5
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等于假。

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

1
2
3
alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false
相关讨论

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

null与undefined的区别如下：

  • undefined：由javascript使用，表示"无值"。未初始化的变量、缺少的参数和未知变量都具有该值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    > var noValueYet;
    > console.log(noValueYet);
    undefined

    > function foo(x) { console.log(x) }
    > foo()
    undefined

    > var obj = {};
    > console.log(obj.unknownProperty)
    undefined

    但是，访问未知变量会产生一个异常：

    1
    2
    > unknownVariable
    ReferenceError: unknownVariable is not defined

  • null：程序员用来表示"无值"，例如作为函数的参数。

检查变量：

1
2
3
4
5
6
7
8
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(==中，应该始终使用==和never==来执行可能产生意外结果的各种转换。支票x == null是一种边缘情况，因为它适用于null和undefined两种情况：

1
2
3
4
> null == null
true
> undefined == null
true

检查变量是否有值的一种常见方法是将其转换为布尔值，并查看它是否为true。转换由if语句和布尔运算符执行！("不")。

1
2
3
4
5
6
7
8
9
10
11
12
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)。

  • 江户十一〔23〕、江户十一〔19〕。
  • 布尔值：false。
  • 编号：+0、-0、NaN。
  • 字符串：""。

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

1
2
3
4
5
6
7
8
9
10
> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true
相关讨论

What is the difference between null and undefined??

没有定义的属性是未定义的。空是一个对象。它的类型是对象。空是一个特殊值，意思是"没有值"。未定义不是对象，它的类型未定义。

您可以声明一个变量，将其设置为空，并且行为是相同的，除了您将看到打印出的"空"和"未定义"之外。甚至可以将未定义的变量与空变量进行比较，反之亦然，条件将为真：

1
2
 undefined == null
 null == undefined

有关详细信息，请参阅空值和未定义值之间的javascript差异。

你的新编辑是的

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

当测试对象是否为假时，它们都只满足测试对象是否为假时的条件，而不满足测试对象是否为真时的条件。

检查这里：javascript gotcha

相关讨论

问题的第一部分：

Why is null considered an object in JavaScript?

这是一个他们现在无法修复的javascript设计错误。它应该是空类型，而不是对象类型，或者根本没有对象类型。当检测到真正的对象时，它需要额外的检查(有时会被忘记)，并且是错误的来源。

问题的第二部分：

Is checking

if (object == null)
Do something

the same as

if (!object)
Do something

这两项检查都是错误的，除了：

  • 对象未定义或为空：均为真。

  • 对象是原始对象，0，""或false：第一个检查为false，第二个检查为true。

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

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

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

问题的第三部分：

And also:

What is the difference between null and undefined?

在JavaScript中，一个区别是空值属于对象类型，而未定义值属于未定义类型。

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

在javascript中，null===undefined不是真的，因为===中的类型必须相同。

实际上，空和未定义是相同的，因为它们都表示不存在。因此，0和""也一样，可能是空容器[]和{}。很多相同的类型，没有什么是bug的配方。一种或一种都不好。我尽量少用。

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

如果没有给定值，则声明的var x是未定义的类型，但它应该与从未声明X的类型相同。另一个bug源是一个空的无内容容器。所以最好一起声明和定义它，就像var x=1一样。

人们一圈又一圈地转来转去，试图弄清楚所有这些不同类型的东西，但是在复杂的不同的衣服里，它们都是一样的。现实是

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

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

相关讨论

1
var x = null;

x定义为空

y没有定义；//因为我没有定义它

1
if (!x)

空值的计算结果为假

在javascript中比较许多不同的空检查：

http://jsfidle.net/aaronhoffman/ddrhb/5/

1
2
3
4
5
6
7
8
9
10
11
12
13
// 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://aron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

JavaScript Null Check Comparison Chart

相关讨论

理解空值和未定义值的一种方法是理解每个值出现在哪里。

在以下情况下应为空返回值：

  • 查询DOM的方法

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

  • 从Ajax请求接收的JSON响应

1
2
3
4
    {
      name:"Bob",
      address: null
    }

  • ReExx.Exc.

  • 处于流动状态的新功能。以下返回空值：

1
2
3
4
5
        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

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

所有其他不存在的情况都用未定义表示(如@axel所述)。以下每种打印都是"未定义"的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    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避免引用错误：

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

总之，在操作DOM、处理Ajax或使用某些EcmaScript 5功能时，请检查是否为空。对于所有其他情况，可以安全地检查未定义，并严格相等：

1
2
3
if(value === undefined){
  // stuff
}

对于值相等(空=未定义)，空和未定义都是假的：它们都折叠为布尔值假。它们不是同一对象(空！=未定义的。

Undefined是全局对象的属性("window"在浏览器中)，但它是原始类型，而不是对象本身。它是未初始化变量和函数的默认值，结尾没有返回语句。

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

在回答undefined和null与本页的javascript最终指南之间的差异时，还需要补充以下内容：

You might consider undefined to represent system-level, unexpected,
or error-like absense of value and null to represent program-level,
normal, or expected absence of value. If you need to assign one of
these values to a variable or property or pass one of these values to
a function, null is almost always the right choice.

一些精度：

空值和未定义值是两个不同的值。一个表示名称没有值，另一个表示名称没有值。

if中发生的情况对if( o )来说如下：

计算圆括号o中的表达式，然后if启动类型强制圆括号中表达式的值-在我们的情况下是o。

javascript中的falsy(将强制为false)值为：""、null、undefined、0和false。

以下功能说明了原因，并能够计算出差异：

1
2
3
4
5
6
function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

如果你打电话

1
test();

你得到

undefined

null

第一个console.log(...)试图从myObj中得到myProperty，但它还没有定义，所以它返回"未定义"。给它赋空后，第二个console.log(...)返回明显的"空"，因为myProperty存在，但它的值为null赋给它。

为了能够查询这种差异，javascript有null和undefined：虽然null和其他语言中的对象一样，但undefined不能是对象，因为没有可用的实例(甚至没有null实例)。

看看这个：

1
2
3
4
5
6
7
8
9
10
11
12
13
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}

                                          //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

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

相关讨论

与未定义相比，空的另一个有趣之处是它可以递增。

1
2
3
4
5
6
x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

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

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

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

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

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

相关讨论

在javascript中，null不是object类型，而是primitave类型。

有什么区别？未定义是指尚未设置的指针。空是指空指针，例如，某个变量手动设置为null类型。

从Nicholas C.Zakas的"面向对象的javascript原则"中

But why an object when the type is null? (In fact, this has been acknowledged as an error by TC39, the committee that designs and maintains JavaScript. You could reason that null is an empty object pointer, making"object" a logical return value, but that’s still confusing.)

Zakas，Nicholas C.(2014-02-07)。面向对象的JavaScript的原理(Kindle位置226-227)。没有淀粉压榨机。Kindle版本。

上面说：

1
2
3
4
5
6
7
8
9
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;

未定义病例：

1
2
3
4
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"。因此，我建议，当你需要去掉变量的值时，不要"删除"…将其设置为"空"。旧值将被孤立，很快将被垃圾收集；新值为"没有值(现在)。"在这两种情况下，变量的状态都是确定的："显然，故意这样做了。"

  • 未定义表示变量已声明，但尚未分配任何值，而可以将空值分配给表示"无值"的变量。(空值是赋值运算符)

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

    3.javascript本身可以将任何未分配的变量初始化为未定义，但不能将变量的值设置为空。这必须通过编程来完成。