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

Question

我想知道JavaScript null和undefinedJavaScript 之间的区别.

Answer 1

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

Answer 2

我从这里选了这个

未定义的值是在未为变量赋值时使用的原始值.

null值是一个原始值,表示null,empty或不存在的引用.

通过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.除此之外,这两个特殊值几乎相同.

Answer 3

null是一个特殊关键字,表示缺少值.

把它想象成一个价值,如:

• "foo"是字符串,
• true是布尔值,
• 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 

但

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 

Answer 4

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

Answer 5

null:变量缺少值; undefined:缺少变量本身;

..where变量是与值关联的符号名称.

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

Answer 6

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

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

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

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

以下是使其成为可能的指南：

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

Answer 7

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

在JavaScript中,我们可以使用以下类型的变量.

1. 未申报的变量
2. 声明但未分配的变量
3. 分配有文字未定义的变量
4. 用文字null分配的变量
5. 分配了undefined或null以外的任何变量

下面逐一解释每个案例

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

   • 只能通过typeof()检查,返回字符串'undefined'
   • 无法使用==或===或if或条件运算符进行检查？ (抛出参考错误)

2. 声明但未分配的变量

   • typeof返回字符串'undefined'
   • == check with null返回true
   • == check with undefined返回true
   • === check with null返回false
   • === check with undefined返回true
   • if或条件运算符？返回false

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

4. 用文字 null分配的变量

   • typeof返回字符串'object'
   • == check with null返回true
   • == check with undefined返回true
   • === check with null返回true
   • ===使用undefined检查返回false
   • if或条件运算符？返回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 
}

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而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它们与===未定义相比，它们也不是。

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

Answer 10

我会解释undefined,null并且Uncaught ReferenceError:

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

Answer 11

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

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

Null是一项任务:

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

Answer 12

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).

Answer 13

null是一个特殊值,意思是"没有价值".null是一个特殊的对象,因为typeof null返回'对象'.

另一方面,undefined表示变量尚未声明,或者未赋值.

Answer 14

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

此外，在上面function if(a == null)是相同的if(!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'

Answer 15

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"

宾语

如果您知道变量只是一个对象,而所有生命周期,按照惯例,您可以将其初始化为null:

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

注意:关闭null的智能用法是对象的虚假版本,因为Object始终是true,因为typeof null返回object.这意味着typeof myVarObject返回Object和null类型的一致值.

所有

如果您知道某个变量具有混合类型(所有生命周期中的任何类型),按照惯例,您可以将其初始化为undefined.

Answer 16

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

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

但是如果你用==下面的方法检查它们，你会发现它们都是假的：

null==undefined; //true

您也可以分配null给一个对象属性或一个基元，而undefined可以通过不分配任何东西来简单地实现。

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

Answer 17

当你在 javascript 中声明一个变量时，它被赋值为undefined。这意味着该变量未受影响，将来可以分配任何值。这也意味着您不知道此变量在声明时将保存的值。

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

现在假设有人正在访问您的 person 对象的 middlename 变量并且它的值为undefined。他不知道开发人员是否忘记初始化这个变量，或者它是否没有任何值。如果它有 value null，那么用户可以很容易地推断出中间名没有任何值，它不是一个未触及的变量。

Answer 18

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

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

所以对于他们两个来说，标签既是它的类型，也是它的值。

他们之间的区别。例如：

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

或者：

• undefined 还没有价值
• null 有一个价值，不再

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

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

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

foo();

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

foo();

Answer 19

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

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

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

var null = 'foo'

它给出以下错误：

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

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

var undefined = 'bar'

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

Answer 20

除了不同的意思，还有其他的不同：

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"