JavaScript中的null和undefined有什么区别？

我想知道JavaScript null和之间的区别undefined。

在JavaScript中，undefined表示已声明但尚未分配值的变量，例如：

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

null是分配值。可以将其分配给变量，以表示没有值：

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

从前面的示例中可以明显看出，undefined和null是两个不同的类型：undefined是类型本身（未定义），null而是对象。

null === undefined // false
null == undefined // true
null === null // true

和

null = 'value' // ReferenceError
undefined = 'value' // 'value'

我从这里选的

未定义值是在未为变量分配值时使用的原始值。

空值是表示空，空或不存在引用的原始值。

当通过var声明变量并且不给它赋值时，它将具有未定义的值。就其本身而言，如果您尝试使用WScript.Echo（）或alert（）这个值，那么您将看不到任何东西。但是，如果将空白字符串附加到该字符串，则会突然出现：

var s;
WScript.Echo(s);
WScript.Echo("" + s);

您可以声明一个变量，将其设置为null，其行为是相同的，除了看到的是“ null”而不是“ undefined”。确实这是一个很小的差异。

您甚至可以将未定义的变量与null进行比较，反之亦然，条件将为true：

undefined == null
null == undefined

但是，它们被认为是两种不同的类型。尽管undefined本身就是一种类型，但null被认为是一个特殊的对象值。您可以使用typeof（）返回一个字符串，该字符串表示变量的常规类型：

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

运行上面的脚本将得到以下输出：

undefined
object

不管它们是什么类型，如果您尝试访问其中一个成员，则它们仍将发挥相同的作用，例如，它们将引发异常。使用WSH，您将看到可怕的“'varname'为null或不是对象”，这就是您很幸运的情况（但这是另一篇文章的主题）。

您可以明确地将变量设置为未定义，但我强烈建议不要使用它。我建议仅将变量设置为null，并为忘记设置的内容保留未定义的值。同时，我真的鼓励您始终设置每个变量。JavaScript的作用域链不同于C风格的语言，即使是经验丰富的程序员也容易感到困惑，并且将变量设置为null是防止基于它的bug的最佳方法。

使用delete运算符时，您会看到未定义的弹出窗口的另一个实例。我们这些来自C语言世界的人可能错误地认为这是在破坏一个对象，但事实并非如此。该操作的作用是从数组中删除下标或从对象中删除成员。对于数组，它不会影响长度，但是现在认为下标是未定义的。

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

上面脚本的结果是：

0.) a
1.) undefined
2.) c

读取不存在的下标或成员时，也会得到未定义的返回。

null和undefined之间的区别是：JavaScript永远不会将任何内容设置为null，这通常是我们要做的。虽然我们可以将变量设置为undefined，但我们更喜欢null，因为这不是为我们完成的工作。调试时，这意味着任何设置为null的操作都是您自己的事情，而不是JavaScript。除此之外，这两个特殊值几乎相等。

（由于缺少字符而添加了字符，因此允许发布此字符。）

空值是表示没有值的特殊关键字。

将其视为一个值，例如：

• “ foo”是字符串，
• true是布尔值，
• 1234是数字
• null未定义。

undefined属性表示尚未为变量分配包含null的值。喜欢

var foo;

定义的空变量为null数据类型undefined

他们两个都代表一个 没有值的变量的值

AND null不代表没有值的字串 -空字串 -

喜欢

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

现在如果

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

但

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

所以每个人都有自己的使用方式

undefined用它来比较变量数据类型

null使用它来清空变量的值

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

null：没有变量值；undefined：变量本身不存在；

..其中变量是与值关联的符号名称。

JS可能足够友好，可以使用null隐式地初始化新声明的变量，但事实并非如此。

请仔细阅读以下内容。它将消除您对JavaScript中null和undefined之间的区别的所有疑问。您也可以使用下面提供的实用程序功能来精确确定类型。

在JavaScript中，我们可以使用以下类型的变量。

1. 未声明的变量
2. 声明但未分配的变量
3. 用文字未定义分配的变量
4. 赋予文字为null的变量
5. 分配给变量的变量除了undefined或null

以下逐一解释每种情况

1. 未声明的变量：对于未声明的变量，以下内容成立

   • 只能由typeof（）检查，该函数返回字符串“ undefined”
   • 无法使用==或===或if或条件运算符检查？ （引发参考错误）

2. 声明但未分配的变量

   • typeof返回字符串“ undefined”
   • ==检查null是否返回true
   • ==用未定义检查返回true
   • ===用null检查是否返回false
   • ===用未定义检查返回true
   • 如果还是条件运算符？返回假

3. 用文字 undefined赋值的变量：这些变量与声明的但未赋值的变量相似。

4. 赋予文字为 null的变量

   • typeof返回字符串“对象”
   • ==检查null是否返回true
   • ==用未定义检查返回true
   • ===检查是否为null会返回true
   • ===用未定义检查返回false
   • 如果还是条件运算符？返回假

5. 分配给变量的变量除了 undefined或null

   • typeof返回以下字符串之一： 'string'，'number'，'boolean'，'function'，'object'，'symbol'

以下提供了用于正确检查变量的类型的算法：

1. 使用typeof检查未声明的 / 未分配的 / 未定义的分配 。如果返回字符串“ undefined”，则返回。
2. 使用===检查null。如果为true，则返回“ null”。
3. 使用typeof检查实际类型。如果不等于“对象”，则返回类型
4. 调用Object.prototype.toString.call（o）以确定实际的对象类型。它应为所有内置Javascript或DOM定义的对象返回类型为[[object ObjectType]”的字符串。对于用户定义的对象，它返回“ [object Object]”

您还可以使用以下实用程序功能来确定类型。当前支持所有ECMA 262 2017类型。

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

您可能会认为undefined表示系统级，意外或类似错误的值缺失，而null表示程序级，正常或预期的值缺失。

通过JavaScript：权威指南

我会解释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

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

• 两者都只能保存一个值，分别为null和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)。

tl; dr

使用null了一套你知道这一个变量是一个对象。

使用undefined了集中的变量，其类型为混合。

这是我对5个原语和Object类型的用法，解释了undefinedor的“用例”之间的区别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"

注意：null的智能用法将是Object 的虚假版本，因为Object始终是true，并且因为typeof nullreturn object。这意味着typeof myVarObject为Object和null类型返回一致的值。

所有

如果您知道变量具有混合类型（在整个生命周期中是任何类型），则可以按照惯例将其初始化为undefined。

null是一个特殊值，表示“无值”。null是一个特殊的对象，因为typeof null返回“对象”。

另一方面，undefined表示尚未声明变量或未给变量赋值。

理解差异的最好方法是，首先要清楚JavaScript的内部工作原理，然后才了解以下两者之间的含义差异：

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

这三种情况的含义有所不同，JavaScript将后两种情况区分为两个不同的值，null和undefined。您可以自由地明确使用这些值来传达这些含义。

那么，由于这种哲学基础而引起的JavaScript特定问题有哪些呢？

1. 没有初始化程序的已声明变量将获得该值，undefined因为您从未说过任何有关预期值的内容。

   let supervisor;
   assert(supervisor === undefined);

2. 从未设置的对象的属性的求值结果是，undefined因为没有人对该属性说过任何话。

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);

3. null并且undefined彼此“相似”，因为Brendan Eich如此说。但是，他们彼此之间并不平等。

   assert(null == undefined);
   assert(null !== undefined);

4. null而undefined值得庆幸的是有不同的类型。null属于类型Null和undefined类型Undefined。这是规范中的内容，但是由于typeof我在这里不再赘述，因此您永远不会知道这一点。

5. 在没有显式return语句的情况下到达函数末尾的函数将返回，undefined因为您对返回的内容一无所知。

顺便说一句，JavaScript中还有其他形式的“虚无”（学习哲学是一件好事……）

• NaN
• 使用从未声明过的变量并接收 ReferenceError
• 在其时间死区中使用let或const定义的局部变量并接收ReferenceError

• 稀疏数组中的空单元格。是的，即使undefined它们与===undefined 相比，它们也不是。

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]

在JavasSript中，有5种原始数据类型String，Number，Boolean，null和undefined。我将尝试用一些简单的例子来解释

可以说我们有一个简单的功能

 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(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

也

var a;
alert(typeof a); 

这将给未定义；我们已经声明了一个变量，但没有给该变量赋任何值；但是如果我们写

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

所以null是一个对象。以某种方式，我们为'a'分配了null值

对于undefined类型，只有一个值和一个值：undefined。

对于null类型，只有一个值和一个值：null。

因此，对于这两个标签，标签既是其类型，也是其值。

他们之间的区别。例如：

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

要么：

• undefined 还没有价值
• null 有价值并且不再

其实null是一个特殊的关键字，而不是标识符，因此您不能将其视为要分配给的变量。

但是，undefined是一个标识符。但是，在non-strictmode和strictmode下，您都可以创建未定义名称的局部变量。但这是一个可怕的想法！

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

foo();

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

foo();

当您在javascript中声明变量时，会为其分配值 undefined。这意味着该变量未更改，以后可以分配任何值。这也意味着您在声明时不知道此变量将要保存的值。

现在您可以显式分配一个变量 null。这意味着该变量没有任何值。例如-有些人没有中间名。因此，在这种情况下，最好将null值分配给人员对象的middlename变量。

现在假设某人正在访问您的person对象的middlename变量，并且该变量具有value undefined。他不知道开发人员是否忘记初始化此变量或它没有任何值。如果它具有value null，那么用户可以轻松推断出Middlename没有任何值，并且它不是一个不变的变量。

null和undefined都用于表示缺少某些值。

var a = null;

初始化并定义。

typeof(a)
//object

null是JavaScript中的对象

Object.prototype.toString.call(a) // [object Object]

var b;

b是未定义和未初始化的

未定义的对象属性也是未定义的。例如，未在对象c上定义“ x”，并且如果您尝试访问cx，它将返回未定义。

通常，我们将null分配给未定义的变量。

Per Ryan Morr在此主题上的详尽文章...

“通常，如果需要将非值分配给变量或属性，将其传递给函数或从函数返回，则null几乎总是最佳选择。简单来说，JavaScript使用未定义，程序员应使用null。”

请参阅探索Null和Undefined的永恒深渊

JavaScript中的Null和undefined均表示缺少值。

var a = null; //variable assigned null value
var b;  // undefined

尽管事实都是因为缺少值而存在，但是：Undefined实际上意味着变量未初始化。不返回任何值的函数和不提供任何值的函数参数，返回未定义的值。使用严格等于运算符===区分null和undefined。

参考：http : //www.thesstech.com/javascript/null-and-undefined

OK，当我们听到我们可能会感到困惑null和undefined，但让我们开始简单，他们都是falsy，在很多方面相似，但JavaScript代码怪异的一部分，让他们夫妇的显著差异，例如，typeof运算 null是'object'同时的typeof undefined是'undefined'。

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

但是，如果==按如下所示检查它们，则它们都是虚假的：

null==undefined; //true

同样，您可以分配null给对象属性或基本类型，同时undefined只需不分配任何内容即可实现。

我创建了一个快速的图像，一目了然地为您显示差异。

当typeof返回undefined时，undefined是一种类型，其中null表示一个初始化器，该变量指示没有对象（Javascript中的几乎所有对象都是对象）。

在javascript中，所有变量都存储为键值对。每个变量都存储为variable_name：variable_value / reference。

未定义表示已在内存中为变量指定了空间，但未为其分配任何值。最佳做法是，不应将此类型用作分配。

在那种情况下，如何表示何时希望变量在代码的后面没有值？您可以使用null类型 ，它也是一种用于定义同一事物的类型，没有值，但是与undefined不同，因为在这种情况下，您实际上将值存储在内存中。该值为空

两者相似，但用法和含义不同。

我想在null和之间添加一个非常细微的区别，undefined当您从头开始学习Vanilla JavaScript（JS）时，很高兴知道这一点：

• null是JS中的保留关键字，而它undefined是您所在的运行时环境的全局对象上的变量。

在编写代码时，这种区别无法同时识别，null并且undefined始终在JavaScript语句的RHS中使用。但是，当您在表达式的LHS中使用它们时，您可以轻松观察到这种差异。因此，JS解释器将以下代码解释为错误：

var null = 'foo'

它给出以下错误：

未捕获的SyntaxError：意外的令牌null

尽管我不建议您在实际生活中成功执行以下代码，但以下代码可以成功运行：

var undefined = 'bar'

之所以有效，undefined是因为它是全局对象（在客户端JS的情况下，浏览器窗口对象）上的变量

undefined和之间的差异null很小，但是存在差异。值undefined从未被初始化的变量。其值null被明确赋予值null的变量，这意味着该变量被明确设置为不具有值。如果比较undefined并null使用null==undefined表达式，它们将相等。

基本上，Undefined是一个全局变量，由javascript在运行时创建，无论是否为null表示没有值分配给该变量（实际上null本身就是一个对象）。

让我们举个例子：

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

未定义的就是您将得到的输出。

现在，

        x=5;
        y=null;
        z=x+y;

您将获得5作为输出。那是Undefined和null之间的主要区别

null-这是一个赋值，与变量一起使用以表示无值（它是一个对象）。

undefined-这是一个没有分配任何值的变量，因此JavaScript会为其分配一个undefined（这是一种数据类型）。

未声明 -如果根本未创建变量，则称为未声明。

看一下这个。输出价值一千个单词。

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

也可以看看：

• https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

干杯!

这两个特殊值都表示一个空状态。

主要区别在于，undefined表示尚未初始化的变量的值，而null表示有意缺少的对象。

变量号已定义，但是未分配初始值：

let number;
number; // => undefined

数字变量未定义，这清楚地表明未初始化的变量

当访问不存在的对象属性时，会发生相同的未初始化概念：

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

因为obj中不存在lastName属性，所以JavaScript正确地将obj.lastName评估为undefined。

在其他情况下，您知道变量期望包含一个对象或一个函数返回一个对象。但是由于某种原因，您无法实例化该对象。在这种情况下，null是丢失对象的有意义的指示。

例如，clone（）是一个克隆纯JavaScript对象的函数。该函数应返回一个对象：

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

但是，可以使用非对象参数调用clone（）：15或null（或者通常是原始值，null或undefined）。在这种情况下，该函数无法创建克隆，因此它将返回null-缺少对象的指示符。

typeof运算符区分两个值：

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

严格质量运算符===正确区分undefined和null：

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

除了具有不同的含义外，还存在其他差异：

1. 对于这两个值，对象解构的工作方式不同：

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

2. JSON.stringify（）保留null但省略undefined

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

3. 类型运算符

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

如果未初始化变量，则未定义。未定义不是对象。示例：var MyName; console.log（typeof MyName）;

检查控制台登录开发工具，它将被打印为未定义。

null是一个对象。如果您希望某个变量为null，则使用null.null变量存在但值未知。应按语法将其分配给变量。null不会自动初始化。

示例：var MyName = null; console.log（typeof MyName）; 检查csole登录开发工具，它将是一个对象。