在JavaScript中，null和undefined之间有什么区别？

null和undefined是两种不同的对象类型，它们有以下共同点：

• 都只能保存一个值，分别为null和undefined；
• 两者都没有属性或方法，尝试读取任何一个的属性将导致运行时错误（对于所有其他对象，如果您尝试读取不存在的属性，则会得到值 undefined ）；
• 值null和undefined被 == 和！= 操作符视为相等，并且与其他任何值都不相等。

然而，相似之处就在这里。首先，关键字null和undefined实现的方式存在根本性差异。这一点并不明显，但请考虑以下示例：

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

undefined, NaN 和 Infinity 只是预初始化的“超全局”变量的名称 - 它们在运行时初始化，并且可以被具有相同名称的普通全局或局部变量覆盖。

现在，让我们用null尝试同样的事情：

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

哎呀！null，true和false都是保留的关键字 - 编译器不允许你将它们用作变量或属性名称。

另一个区别在于undefined是一种基本类型，而null是一种对象类型（表示缺少对象引用）。考虑以下示例：

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

此外，在数字上下文中，null和undefined的处理方式存在重要区别：

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

null用于算术表达式或数值比较时会变成0 - 类似于false，它基本上只是一种特殊的“零”。另一方面，undefined是真正的“不存在”，当您尝试在数字上下文中使用它时，它将变为NaN（“不是数字”）。

请注意，null和undefined从==和!=运算符中接收特殊处理，但您可以使用表达式(a >= b && a <= b)测试a和b的真实数值相等性。

我将解释 undefined, null 和 Uncaught ReferenceError:

1 - Uncaught ReferenceError：在您的脚本中变量未被声明，没有引用此变量
2 - undefined：变量已声明但未初始化
3 - null：变量已声明且为空值

未定义意味着变量已被声明但没有值：

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Null是一种赋值：

var var2= null;
alert(var2); //null
alert(typeof var2); //object

除了不同的含义，还有其他差异：

1. Object destructuring works differently for these two values:
   

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null
   

2. JSON.stringify() keeps null but omits undefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}
   

3. typeof operator

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"
   

简洁版：

null 用于设置已知为对象的变量。

undefined 用于设置类型不确定的变量。

这是我使用五种基本类型和对象类型的方法，并解释了 undefined 或 null 的使用情况之间的区别。

字符串

如果你知道一个变量在其整个生命周期内只是字符串，可以按照惯例将其初始化为 "" ：

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

数字

如果您知道一个变量在其整个生命周期内只是一个数字，则按照惯例，您可以将其初始化为0（或NaN，如果0是您使用中的重要值）：

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

或者

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

布尔类型

如果你知道一个变量在整个生命周期中只会是布尔类型，按照惯例，你可以将其初始化为false：

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

对象

如果您知道一个变量在整个生命周期中只是一个对象，根据惯例，您可以将其初始化为 null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

 function test(a) {
     if(a == null) {
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

另外，在上面的代码中，if(a == null)和if(!a)是等同的。

现在，当我们调用该函数而没有传递参数a时：

test(); // will alert "a is null";
test(4); // will alert "The value of a is " + 4;

另外

var a;
alert(typeof a);

这将会得到undefined，我们声明了一个变量但是没有为这个变量赋任何值;

但如果我们写成

var a = null;
alert(typeof a); // will give alert as object

所以，null是一个对象。我们已经将值null赋给了'a'。

好的，当我们听到 null 和 undefined 时可能会感到困惑，但让我们从简单的开始，它们都是 falsy 并且在很多方面都很相似，但 JavaScript 中奇怪的部分使它们有一些显著的区别，例如，typeof null 是 'object' ，而 typeof undefined 是 'undefined'。

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

但如果你用如下的代码检查它们，使用==，你会发现它们都是falsy：

null==undefined; //true

• null 是一个空值
• undefined 是一个缺失的值

• undefined 还没有被赋值
• null 曾经有过值，但现在已经没有了

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

var null = 'foo'

出现以下错误：

未捕获的 SyntaxError: 意外的 null 标记

同时，下面的代码可以成功运行，但我不建议在实际生活中这样做：

var undefined = 'bar'