Javascript 为什么null是一个对象，以及'；空和未定义的区别是什么？

为什么在JavaScript中

null

被视为

对象

正在检查

if ( object == null )
      Do something

同

if ( !object )
      Do something

?

而且：

null
和
undefined
之间有什么区别？
null
是一个对象。其类型为null<代码>未定义

不是对象；其类型未定义

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

空和未定义之间有什么区别

没有定义的属性是未定义的。null是一个对象。它的类型是object。null是一个特殊值，表示“无值。未定义”不是对象，它的类型是未定义的

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

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

 undefined == null
 null == undefined

有关更多详细信息，请参阅

使用新的编辑是

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

当测试对象是否为false时，它们仅在测试iffalse时满足条件，而在测试true时不满足条件

---

检查此处：

例如

窗口。someWeirdProperty

未定义，因此

“window.someWeirdProperty==null”

在

“window.someWeirdProperty===undefined”

计算结果为true

此外，checkif

if（！o）

与检查

if（o==null）

是否

o

为

false不同

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

值null表示故意不存在任何对象值。它是JavaScript的基本值之一，对于布尔运算被视为falsy

var x = null;
var y;

x被声明并定义为null

y已声明但未定义。声明时没有值，因此未定义

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

z未声明，因此如果尝试使用z，也将是未定义的。
null和未定义对于值相等都是false（null==未定义）：它们都折叠为布尔false。它们不是相同的对象（null！==未定义）

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

null是Object的实例。null用于返回集合对象以指示空结果的DOM方法，它提供一个假值而不指示错误。
差异可以总结为以下代码段：

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

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

检查

object==null
与检查
是否（！object）
不同

后者等于
！Boolean（object）
，因为一元
！
运算符会自动将正确的操作数转换为布尔值

因为
布尔值（null）
等于false，那么
！false==true

因此，如果对象为非空，但为假或0或“，则检查将通过
因为：

你：什么是
名字？（*）

JavaScript:
名称
？什么是
名称
？我不知道你在说什么。你以前从未提到过任何
名称
。你在（客户端）看到其他脚本语言了吗

你：什么是
名字
？

JavaScript:我不知道

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

需要记住的一点是，
null
在概念上与
false
或
“
等不同，即使它们在类型转换后相等，即

name = false;

你：什么是
名字
？

JavaScript:Boolean false

name = '';

你：什么是
名字
？

JavaScript:空字符串


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

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


对于
if（o）
，在
if中发生的情况如下所示：

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

JavaScript中的Falsy（将被强制为false）值为：“”、null、undefined、0和false。
问题的第一部分：

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

这是一个JavaScript设计错误，他们现在无法修复。它应该是null类型，而不是object类型，或者根本没有。在检测真实对象时需要额外检查（有时会忘记），这是错误的根源

问题的第二部分：

正在检查




if（object==null）


做点什么




与
相同


if（！object）


做点什么


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


对象未定义或为null：均为true

对象是基元，0、
“
或false：第一次检查false，第二次检查true


如果对象不是原语，而是真实对象，如
新数字（0）
、
新字符串（“”
）或
新布尔值（false）
，则两者都会检查
undefined===undeclared===null===0===""===[]==={}===nothing

> 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

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

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

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

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

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


    {
      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();

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.

   <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 weDontHaveAValue = null;

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