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

时间：2011-02-22 10:30:10

标签： javascript null undefined

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

37 个答案:

答案 0 :(得分：916)

在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'

答案 1 :(得分：63)

我是从here

中选择的
  

未定义的值是变量未使用时的原始值   被分配了一个值。

     

null值是一个原始值，表示null，为空，   或者不存在的参考文献。

当您通过var声明变量并且不为其赋值时，它将具有未定义的值。如果您尝试使用WScript.Echo（）或alert（）此值，您将看不到任何内容。但是，如果你向它添加一个空白字符串，那么突然它会出现：

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

您可以声明一个变量，将其设置为null，并且行为是相同的，除了您将看到“null”打印出来与“undefined”相对应。这确实是一个小差异。

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

undefined == null
null == undefined
然而，它们被认为是两种不同的类型。虽然undefined是一个all类型，但null被认为是一个特殊的对象值。你可以通过使用typeof（）来看到这一点，它返回一个表示变量的一般类型的字符串：

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

运行上面的脚本将产生以下输出：

undefined
object

无论它们是不同类型，如果您尝试访问其中任何一个的成员，它们仍将保持相同的行为，例如：也就是说他们会抛出异常。使用WSH，您将看到可怕的“'varname'为null或不是对象”，如果您很幸运（但这是另一篇文章的主题）。

您可以明确地将变量设置为未定义，但我强烈反对它。我建议只将变量设置为null，并为您忘记设置的内容保留undefined值。同时，我真的鼓励你总是设置每个变量。 JavaScript的范围链与C风格的语言链不同，即使是资深程序员也容易混淆，将变量设置为null是防止基于它的错误的最佳方法。

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

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。除此之外，这两个特殊值几乎是等价的。

答案 2 :(得分：33)

This is the difference

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

答案 3 :(得分：29)

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

将其视为一种价值，如：

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

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

var foo;

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

它们都表示没有值的变量的值

和 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

<强> 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

答案 4 :(得分：15)

null ：变量缺少值; 未定义：缺少变量本身;

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

JS可能非常友好地使用 null 隐式初始化新声明的变量，但它没有。

答案 5 :(得分：14)

请仔细阅读以下内容。它将消除你所有的疑虑 JavaScript中 null 和 undefined 之间的区别。您还可以使用下面给出的效用函数来准确确定类型。

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

  1. 未声明的变量
  2. 已声明但未分配的变量
  3. 使用文字未定义
    4. 分配的变量
  4. 使用文字 null
    5. 指定的变量
  5. 分配了未定义或 null
    6. 以外的变量的变量

    下面逐一解释每一个案例

    1. 未声明的变量：以下适用于未声明的变量

      • 只能通过 typeof（）检查，后者返回字符串＆＃39; undefined＆＃39;
      • 无法使用 == 或 === 或如果或条件运算符？进行检查（抛出）参考错误）

    2. 已声明但未分配的变量

      • typeof 返回字符串＆＃39; undefined＆＃39;
      • == 检查 null 返回 true
      • == 检查未定义返回 true
      • === 检查 null 返回 false
      • === 检查未定义返回 true
      • 如果或条件运算符？返回 false

    3. 使用文字分配的变量 未定义 ：这些变量的处理方式与声明但未分配的变量

    4. 使用文字分配的变量 null

      • typeof 返回字符串＆＃39; object＆＃39;
      • == 检查 null 返回 true
      • == 检查未定义返回 true
      • === 检查 null 返回 true
      • === 检查未定义返回 false
      • 如果或条件运算符？返回false

    5. 使用 未定义 或 null 以外的任何内容分配的变量

      • typeof会返回以下字符串之一：＆＃39; string＆＃39; ，＆＃39; number＆＃39; ，＆＃39;布尔＆＃39; ，＆＃39;功能＆＃39; ，＆＃39;对象＆＃39; ，＆＃39;符号＆＃ 39;

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

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

        5. 您还可以使用以下实用程序功能来确定类型。它目前支持所有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 
}

答案 6 :(得分：9)

我会解释undefined，null和Uncaught ReferenceError：

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

答案 7 :(得分：8)

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

  • 两者分别只能包含一个值 null 和 undefined ;
  • 都没有属性或方法，并且尝试读取任何属性都将导致运行时错误（对于所有其他对象，如果您尝试读取非值，则会获得值未定义 - 存在的财产）;
  • 值 null 和 undefined 被认为彼此相等，而==和!=运营商则认为不相同。
然而，相似之处在此结束。这一次，关键字 null 和 undefined 的实施方式存在根本差异。这并不明显，但请考虑以下示例：

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

未定义， 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 会从==和!=运算符获得特殊处理，但您可以测试 a 和 b ，表达式为(a >= b && a <= b)。

答案 8 :(得分：8)

  

您可以将undefined视为表示系统级别，意外或类似错误的值，并将null视为表示程序级别，正常或预期的值缺失。

通过JavaScript：权威指南

答案 9 :(得分：8)

未定义表示已声明变量但没有值：

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

Null是一项任务：

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

答案 10 :(得分：7)

TL;博士

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

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

这是我对5个基元和对象类型的使用，它解释了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"

<强>对象

如果您知道某个变量只是一个Object，而按照惯例，您可以将其初始化为null：

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

注意：关闭null的智能用法是Object的 falsy 版本，因为Object总是true，因为typeof null返回{{ 1}}。这意味着object返回Object和null类型的一致值。

所有

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

答案 11 :(得分：5)

null是一个特殊值，意思是“没有价值”。 null是一个特殊对象，因为typeof null会返回'object'。

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

答案 12 :(得分：4)

在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);

这将给出undefined;我们已经声明了一个变量但是我们没有为这个变量赋值任何值;  但如果我们写

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

所以null是一个对象。在某种程度上，我们为'a'

指定了一个null值

答案 13 :(得分：4)

了解这些差异的最好方法是，首先要清楚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 ]

答案 14 :(得分：3)

好的，当我们听到null和undefined时，我们可能会感到困惑，但让我们开始很简单，它们都是 falsy 并且在很多方面类似，但很奇怪JavaScript的一部分，使它们有一些重大差异，例如， typeof null为'object'，而 typeof undefined为{ {1}}。

'undefined'

但是，如果您使用typeof null; //"object" typeof undefined; //"undefined"; 检查它们，如下所示，您会发现它们都是 falsy ：

==

此外，您可以将null==undefined; //true 分配给对象属性或基元，而null可以通过不分配任何内容来实现。{/ p>

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

Null and Undefined

答案 15 :(得分：3)

  

JavaScript中的Null和undefined都表示没有值。

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

尽管存在价值缺失的事实但是：未定义   实际上意味着变量未初始化。返回的函数   什么都没有，没有提供任何值的函数参数，   返回未定义的值。使用严格相等运算符===来   区分null和undefined。

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

答案 16 :(得分：2)

检查一下。输出价值一千个单词。

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>

另请参阅：

干杯！

答案 17 :(得分：2)

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

  1. Object destructuring 对于这两个值的工作方式有所不同： 
    function update_limit_for_products( $limit, $products ) {
    $limit = 1000;

    return $limit;

}

add_filter( 'woocommerce_api_bulk_limit', 'update_limit_for_products', 10, 2 );
  2. JSON.stringify（）保留const { a = "default" } = { a: undefined }; // a is "default" const { b = "default" } = { b: null }; // b is null ，但省略了null 
    undefined
  3. 运营商类型 
    const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
console.log(json); // prints {"nullValue":null}

答案 18 :(得分：2)

在javascript中声明变量时，会为其分配值undefined。这意味着变量不受影响，将来可以分配任何值。它还意味着您不知道此变量在声明时将保留的值。

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

现在假设有人正在访问person对象的middlename变量，并且其值为undefined。他不知道开发人员是否忘记初始化此变量或者它是否没有任何值。如果它具有值null，则用户可以轻松地推断出中间名没有任何值，并且它不是未触及的变量。

答案 19 :(得分：2)

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

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

因此，对于他们两个，标签既是其类型又是其价值。

他们之间的区别。例如：

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

或者：

  • undefined尚未有价值
  • null有一个值，现在不再有了

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

但是，undefined是标识符。但是，在non-strict模式和strict模式下，您可以创建名称为undefined的局部变量。但这是一个可怕的想法！

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

foo();

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

foo();

答案 20 :(得分：2)

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

var a = null;

a已初始化并定义。

typeof(a)
//object

null是JavaScript中的对象

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

var b;

b未定义且未初始化

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

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

答案 21 :(得分：2)

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

答案 22 :(得分：1)

基本上，未定义是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

之间的主要区别

答案 23 :(得分：1)

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

undefined 表示变量在内存中已被赋予空格，但没有赋值给它。作为最佳实践，您不应将此类型用作任务。

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

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

答案 24 :(得分：1)

undefined和null之间的差异很小，但存在差异。值为undefined的变量从未初始化。值为null的变量显式赋值null，这意味着变量显式设置为没有值。如果您使用undefined表达式比较null和null==undefined，它们将是相同的。

答案 25 :(得分：1)

Per Ryan Morr关于这个主题的全面文章......

＆＃34;通常，如果您需要为变量或属性分配非值，将其传递给函数，或者从函数返回它，则null几乎总是最佳选择。简单来说，JavaScript使用undefined，程序员应该使用null。＆＃34;

请参阅Exploring the Eternal Abyss of Null and Undefined

答案 26 :(得分：1)

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

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

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

答案 27 :(得分：1)

<块引用>

undefined 和 null 的含义不同是 JavaScript 设计的一个意外，大多数时候无关紧要。如果您确实需要关注这些值，我建议您将它们视为可互换的。

来自Plot书

答案 28 :(得分：0)

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

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

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

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

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

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

答案 29 :(得分：0)

null 的类型是 Object，而 undefined 的类型是 undefined。 Null 表示“没有值”，而 undefined 表示“不存在”。

typeof undefined; //undefined
typeof null; // Object
undefined !== null; //true
undefined == null; //true
undefined === null; //false
var var1;
var1; //undefined 
var var2 = null;
var2; //null

答案 30 :(得分：0)

在Javascript中，null是一个空值或不存在的值，必须对其进行分配。但是“未定义”表示已声明变量，但尚未定义值。

let a = null;  
console.log(a);    // null
let b;         
console.log(b);    // undefined

在JS中，null和undefined都是原始值。您还可以查看以下代码行

console.log(typeof null); //Object
console.log(typeof undefined); //Object
console.log(10+null); // 10
console.log(10+undefined); //NaN

答案 31 :(得分：0)

Marijn Haverbeke引用的“ Eloquent Javascript”第三版中的语录：

undefined和null之间的含义差异是Java语言设计的偶然原因，并且在大多数情况下并不重要。如果您确实需要关注这些值，我建议将它们视为可互换的

老实说，起初，我对这一建议有些怀疑。但是，以我自己的理解，这是一种lazy（相对于eager）的解决方式。也许，我们根本不必处理差异。如果需要的话，我们可以推迟我们的担忧（直到必须这样做），而不必hyperactively/defensively担心，因为这些值（null和undefined）流过我们的每一步。代码。

PS：这不是您问题的直接答案。这只是一个相关的观点。

答案 32 :(得分：0)

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

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

  

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

let number;
number; // => undefined
  

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

     

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

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

由于obj中不存在lastName属性，因此JavaScript正确地将obj.lastName评估为未定义。

在其他情况下，您知道变量期望包含一个对象或一个函数返回一个对象。但是由于某种原因，您无法实例化该对象。在这种情况下，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

答案 33 :(得分：0)

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

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

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

var null = 'foo'

它给出以下错误：

  

未捕获到的SyntaxError：意外的令牌为空

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

var undefined = 'bar'

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

答案 34 :(得分：-1)

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

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

null是一个对象。如果你想要一些变量为null，则使用null。存在变量但是值不可知。它应该以编程方式分配给变量。 null不会自动初始化。

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

答案 35 :(得分：-3)

只是添加我的观点 -

在C ++等编译语言[或IDE中标记警告]的情况下，优化编译器会删除一个仅声明且从未在任何地方使用过的变量。它最终意味着变量不存在，因为它的内存永远不会被分配。

在javascript解释器的情况下，[我猜]变量仅被视为存在于给定值的点。在此之前，它的类型是“未定义”，并且没有为其分配内存。而且，它的类型是未定义的。

javascript 中的null是表示地址的值，但该地址指向的是[不存在的引用]。然而，它是一个价值。

答案 36 :(得分：-4)

Null始终是存在于内存中的未知对象，而未定义则不是。

相关问题
最新问题