JavaScript 中 null 和 undefined 有什么区别？

Question

JavaScript 中 null 和 undefined 有什么区别？

Answer 1

undefined 表示变量已被声明但尚未赋值：

var testVar;
console.log(testVar); //shows undefined
console.log(typeof testVar); //shows undefined

null 是一个赋值值。它可以被分配给一个变量作为无值的表示：

var testVar = null;
console.log(testVar); //shows null
console.log(typeof testVar); //shows object

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

证明 ：

console.log(null === undefined) // false (not the same type)
console.log(null == undefined) // true (but the "same value")
console.log(null === null) // true (both type and value are the same)

和

null = 'value' // Uncaught SyntaxError: invalid assignment left-hand side
undefined = 'value' // 'value'

Answer 2

这种差异可以用卫生纸支架来解释：

• 非零值就像一个带有卫生纸卷的支架，并且管子上仍然有纸巾。

• 零值就像一个带有空卫生纸管的支架。

• 空值就像一个甚至没有纸巾管的支架。

• 未定义的值类似于持有人本身丢失。

< /a>

Answer 3

我从这里选择了这个

未定义值是当变量没有定义时使用的原始值。
已被赋值。

null 值是一个原始值，表示 null、empty、
或不存在的参考。

当您通过 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 是防止基于它的错误的最佳方法。

您将看到未定义弹出的另一个实例是使用删除运算符时。我们这些来自 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

当读取一个不存在的下标或成员时，你也会得到 undefined 返回。

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

Answer 4

请仔细阅读以下内容。它应该消除您对 JavaScript 中 null 和 undefined 之间差异的所有疑虑。此外，您可以使用本答案末尾的实用函数来获取更具体类型的变量。

在 JavaScript 中，我们可以有以下类型的变量：

1. 未声明的变量
2. 已声明但未分配的变量
3. 使用文字 undefined 分配
4. 的变量 使用文字 null
5. 分配的变量 使用 以外的任何内容分配的变量undefined 或 null

下面一一解释这些情况：

1. 未声明的变量

   • 只能使用返回字符串'undefined'的typeof运算符进行检查
   • 无法使用松散相等运算符 ( == undefined ) 进行检查，更不用说严格相等运算符 ( === undefined )，
     以及 if 语句 和 三元运算符 ( ? : ) - 这些会抛出引用错误

2. 已声明但未分配的变量< /strong>

   
   

   • typeof 返回字符串'undefined'
   • == 检查 null 返回 true
   • == 检查 undefined 返回 true
   • === 检查 null 返回 false
   • === 检查 undefined 返回 true
   • if 语句和三元运算符是否为假值 ( ? : )

3. 用文字 undefined 赋值的变量
   这些变量的处理方式与已声明但未分配的变量完全相同。

4. 用文字指定的变量 null

   • typeof 返回字符串'object'
   • == 检查 null 返回 true
   • == 检查 undefined 返回 true
   • === 检查 null 返回 true
   • === 检查 undefined 返回 false
   • if 语句和三元运算符是否为假值 ( ? : )

5. 分配除 undefined 或 null

   之外的变量

   • typeof 返回以下字符串之一：'bigint'、'boolean'、'function'、'number' , '对象', '字符串', '符号'

下面提供了对变量进行正确类型检查的算法：

1. 获取我们变量的typeof，如果不是'则返回它object'
2. 检查 null，因为 typeof null 返回 'object' 以及
3. 评估 Object.prototype.toString。 call(o) 使用 switch 语句返回更精确的值。 Object 的 toString 方法返回类似于本机/主机对象的 '[object ConstructorName]' 的字符串。对于所有其他对象（用户定义的对象），它始终返回 '[object Object]'
4. 如果最后一部分是这种情况（变量的字符串化版本为 '[object Object] '）并且参数 returnConstructorBoolean 为 true，它将尝试通过 toString 获取构造函数的名称，并且从那里提取名称。如果无法访问构造函数，则照常返回'object'。如果字符串不包含其名称，则返回 'anonymous'

（支持 ECMAScript 2020 之前的所有类型）

function TypeOf(o, returnConstructorBoolean) {
  const type = typeof o

  if (type !== 'object') return type
  if (o === null)        return 'null'

  const toString = Object.prototype.toString.call(o)

  switch (toString) {
    // Value types: 6
    case '[object BigInt]':            return 'bigint'
    case '[object Boolean]':           return 'boolean'
    case '[object Date]':              return 'date'
    case '[object Number]':            return 'number'
    case '[object String]':            return 'string'
    case '[object Symbol]':            return 'symbol'

    // Error types: 7
    case '[object Error]':             return 'error'
    case '[object EvalError]':         return 'evalerror'
    case '[object RangeError]':        return 'rangeerror'
    case '[object ReferenceError]':    return 'referenceerror'
    case '[object SyntaxError]':       return 'syntaxerror'
    case '[object TypeError]':         return 'typeerror'
    case '[object URIError]':          return 'urierror'

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

    // Keyed Collection types: 2
    case '[object Map]':               return 'map'
    case '[object WeakMap]':           return 'weakmap'

    // Set types: 2
    case '[object Set]':               return 'set'
    case '[object WeakSet]':           return 'weakset'

    // Operation types: 3
    case '[object RegExp]':            return 'regexp'
    case '[object Proxy]':             return 'proxy'
    case '[object Promise]':           return 'promise'

    // Plain objects
    case '[object Object]':
      if (!returnConstructorBoolean)
        return type

      const _prototype = Object.getPrototypeOf(o)
      if (!_prototype)              
        return type

      const _constructor = _prototype.constructor
      if (!_constructor)            
        return type

      const matches = Function.prototype.toString.call(_constructor).match(/^function\s*([^\s(]+)/)
        return matches ? matches[1] : 'anonymous'

    default: return toString.split(' ')[1].slice(0, -1)
  }
}

Answer 5

null 是一个特殊关键字，表示缺少值。

将其视为一个值，例如：

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

---

undefined属性表示变量还没有被赋值，包括null。
就像

var foo;

---

定义的空变量是数据类型未定义的null

---

一样，它们都表示没有值的变量的值

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

---

Like

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 

BUT

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

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

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

null 使用它来清空变量的值

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

Answer 6

null：变量没有值； 未定义：变量本身不存在；

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

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

Answer 7

已经给出了很多“技术”答案，从 JS 作为一种编程语言的有限角度来看，它们大多都是正确的。

但是，我想添加以下想法，特别是当您将 TypeScript 代码作为更大的项目/（企业）应用程序的一部分编写时：

• 与某种后端交谈时，您很可能会收到 JSON，
• 而某些后端正确避免在 JSON 中使用“null”（删除这些属性），其他人则不会
• 现在，而“null”可能意味着故意丢失该值，但更多时候它并不传达这种含义。大多数数据库使用“null”只是因为它们没有“未定义”类型。但其含义实际上只是“未定义”。
• 因此，您永远无法知道“null”值是否真的意味着故意缺席。因此，“空”并不能真正意味着故意选择“缺失值”。一般情况下是无法判定的。
• 因此，语义上，“null”和“未定义”实际上是完全相同的。

因此，为了协调事情，我严格反对使用“null”，并希望鼓励您停止在代码中使用“null”。这比您想象的要容易得多。别误会我的意思。我并不是说不处理“空”值，只是为了避免在代码中显式使用它们。换句话说：您的代码仍然应该能够处理来自应用程序外部的意外传递的“空”值，例如通过像 Angular，或第 3 方后端。

以下是使其成为可能的准则：

• 避免直接未定义类型保护（例如if (value === undefined) { ... }。
• 相反，使用间接类型保护（又名真实性检查）例如 if (value) { ... }
  • 只要 0 或空字符串有意义，就使用
    • 显式辅助方法，例如 Lodash 的 isNil
    • 或在比较中包含有意义的值（例如 if (!value && value !== 0) { ... })
• 考虑使用 lint 规则 禁止使用 null

Answer 8

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

通过 JavaScript：权威指南

Answer 9

理解差异的最好方法是首先理清 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 和未定义。您可以自由地明确使用这些值来传达这些含义。

那么由于这种哲学基础而产生的一些 JavaScript 特定问题是什么？

1. 没有初始值设定项的声明变量的值是未定义，因为您从未说过任何有关预期值的信息。

   让主管；
   断言（主管===未定义）；
   

2. 从未设置过的对象属性的计算结果为未定义，因为没有人说过有关该属性的任何事情。

   const 狗 = { name: 'Sparky', 年龄: 2 };
   断言（狗.breed ===未定义）；
   

3. null 和 undefined 彼此“相似”，因为 Brendan Eich 是这么说的。但它们显然并不相等。

   assert(null == undefined);
   断言（空！==未定义）；
   

4. 幸运的是，

   null 和 undefined 具有不同的类型。 null 属于Null 类型，undefined 属于Undefine 类型。这是在规范中的，但你永远不会知道这一点，因为 typeof 很奇怪，我不会在这里重复。

5. 在没有显式 return 语句的情况下到达其主体末尾的函数将返回 undefined，因为您对它返回

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

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

• 稀疏数组中的空单元格。是的，尽管它们将 === 与未定义进行比较，但它们甚至都不是未定义。

  <前><代码>$节点
  >常量 a = [1，未定义，2]
  >常量 b = [1, , 2]
  >一个
  [ 1，未定义，2 ]
  >乙
  [ 1, <1 个空项目>, 2 ]

Answer 10

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

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

Answer 11

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 类似，它基本上只是一种特殊的“零”。另一方面，未定义是真正的“无”，当您尝试在数字上下文中使用它时，它会变成NaN（“不是数字”）。

请注意，null 和 undefined 会受到 == 和 != 运算符的特殊处理，但您可以测试 true a 和 b 与表达式 (a >= b && a <= b) 的数值相等。

Answer 12

我将解释 undefined、null 和 Uncaught ReferenceError:

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

Answer 13

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

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

Null 是赋值：

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

Answer 14

tl;dr

使用 null 设置一个您知道它是对象的变量。

使用undefined设置混合类型的变量。

---

这是我对 5 个原语和对象类型的用法，解释了 undefined 或 null 的“用例”之间的区别。

String

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

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

Number

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

(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"

Boolean

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

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

Object

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

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

注意：null 的明智用法是 <对象的strong>falsy版本，因为对象始终为true，并且因为typeof null返回object。这意味着 typeof myVarObject 为 Object 和 null 类型返回一致的值。

全部

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

Answer 15

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

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

   const { a = "default" } = { a: undefined }; // a 是“默认”
   const { b = "默认" } = { b: null }; // b 为空
   

2. JSON.stringify() 保留 null 但省略 undefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   控制台.log(json); // 打印 {"nullValue":null}
   

3. typeof 运算符

   console.log(typeof undefined); // “不明确的”
   console.log(typeof null); // “对象”而不是“空”
   

Answer 16

JavaScript 中有 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(); // 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 就是一个对象。在某种程度上，我们为“a”分配了一个 null 值

Answer 17

当您在 JavaScript 中声明变量时，它会被赋予值 undefined。这意味着该变量未受影响，并且可以在将来分配任何值。它还意味着您不知道该变量在声明时将保存的值。

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

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

Answer 18

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

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

但是，如果您使用 == 检查它们，如下所示，您会发现它们都是 falsy：

null==undefined; //true

此外，您还可以将 null 分配给对象属性或一个原语，而 undefined 可以通过不分配任何东西来简单地实现。

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

Answer 19

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

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

因此对于它们两者来说，标签既是它的类型又是它的值。

它们之间的区别。例如：

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

或者：

• undefined 还没有值
• null 曾经有一个值，但现在不再有值了。

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

但是，undefined 是一个标识符。但是，在非严格 模式和严格 模式下，您都可以创建名称为 undefined 的局部变量。但这是一个糟糕的想法！

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

foo();

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

foo();

Answer 20

我想添加一个知识点，涉及null和undefined之间的细微差别。当您尝试从头开始学习 Vanilla JavaScript(JS) 时，了解这一点是很有必要的：

null 是 JS 中的保留关键字，而 undefined 是 JS 中的属性
您所在的运行时环境的全局对象。

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

var null = 'foo'

它给出以下错误：

未捕获的语法错误：意外的标记为空

同时，下面的代码成功运行，尽管我不建议在现实生活中这样做：

var undefined = 'bar'

这有效，因为 undefined 是全局对象上的一个属性 (window 对象（如果 JavaScript 在浏览器中运行）

Answer 21

null 和 undefined 都用来表示某些值的缺失。

var a = null;

a 被初始化并定义。

typeof(a)
//object

null 是 JavaScript 中的一个对象

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

var b;

b 是未定义的，未初始化的

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

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

Answer 22

根据 Ryan Morr 关于此主题的详尽文章...

“通常，如果您需要为变量或属性分配非值、将其传递给函数或从函数返回它，则 null 几乎总是最佳选择。简而言之，JavaScript 使用 undefined，程序员应该使用 null。”

请参阅探索空与未定义的永恒深渊

Answer 23

在 javascript 中，所有变量都存储为键值对。每个变量都存储为变量名：变量值/引用。

未定义表示变量已在内存中分配了空间，但没有为其分配任何值。作为最佳实践，您不应使用此类型作为作业。

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

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

Answer 24

undefined 和 null 之间的含义差异是 JavaScript 设计的一个意外，大多数时候并不重要。如果您实际上必须关心这些值，我建议将它们视为大部分可以互换的。

来自Eloquent Javascript一书

Answer 25

由于 typeof 返回 undefined，undefined 是一种类型，其中 null 是初始化器，表示该变量不指向任何对象（实际上 Javascript 中的所有内容都是对象）。

Answer 26

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

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

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

Answer 27

看看这个。输出值千字。

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 /en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla。 org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

干杯！

Answer 28

一般来说 – 不要使用 null 以避免混淆。

1. 标准库方法返回 undefined，而不是 null

let a = [10];
console.log(a[1]) //=> undefined
console.log(a.find(value => value === 5)) //=> undefined

2. 我经常在人们的代码中看到某些变量首先是 undefined，然后分配给某个值，然后通过设置为 null 来清除。这不一致，最好设置回 undefined。

尽管如此，如果框架使用它，或者用于 json 序列化，null 仍然有意义。

Answer 29

undefined 和 null 之间的差异很小，但还是有区别的。值为未定义的变量从未被初始化。值为 null 的变量被显式指定为 null 值，这意味着该变量被显式设置为没有值。如果使用 null==undefined 表达式比较 undefined 和 null，它们将相等。

Answer 30

基本上，未定义是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 作为输出。这是未定义和null之间的主要区别