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

问题的第一部分：

为什么在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有什么区别？

In JavaScript, one difference is that null is of type object and undefined is of type undefined.

In JavaScript, null==undefined is true, and considered equal if type is ignored. Why they decided that, but 0, "" and false aren't equal, I don't know. It seems to be an arbitrary opinion.

In JavaScript, null===undefined is not true since the type must be the same in ===.

In reality, null and undefined are identical, since they both represent non-existence. So do 0, and "" for that matter too, and maybe the empty containers [] and {}. So many types of the same nothing are a recipe for bugs. One type or none at all is better. I would try to use as few as possible.

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

var x如果没有给出值，则声明的类型为undefined，但它应该与x从未声明过一样。另一个错误源是一个空的无容器。因此，最好像一样一起声明和定义它var x=1。

人们四处走动，试图找出所有这些类型的虚无，但都是一件复杂而又不同的衣服。现实是

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

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

var x = null;

if (!x)

    {
      name: "Bob",
      address: null
    }

        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

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

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

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

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

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

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

test();

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

   <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

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.