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

2020/09/18 12:31 · javascript ·  · 0评论

我想知道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

从前面的示例中可以明显看出,undefinednull是两个不同的类型: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是防止基于它的错误的最佳方法。

使用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。除此之外,这两个特殊值几乎相等。

null是一个特殊的关键字,指示缺少值。

将其视为一个值,例如:

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

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:没有变量值;未定义:本身没有变量;

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

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

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

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

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

以下逐一解释每种情况

  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. 分配给变量的变量除了 undefinednull

    • 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:权威指南

我将说明undefinednull以及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

nullundefined是两种不同的对象类型,它们具有以下共同点:

  • 两者都只能保存一个值,分别为nullundefined
  • 两者都没有属性或方法,并且尝试读取任何一个的任何属性都将导致运行时错误(对于所有其他对象,如果尝试读取不存在的属性,则将得到未定义的);
  • 运算符将nullundefined视为彼此相等,而没有其他值==!=

但是,相似之处到此结束。一次,关键字nullundefined的实现方式存在根本差异这并不明显,但是请考虑以下示例:

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

undefinedNaNInfinity只是预初始化的“超全局”变量的名称-它们在运行时进行初始化,并且可以被具有相同名称的常规全局或局部变量覆盖。

现在,让我们尝试使用null进行相同的操作

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

糟糕!nulltruefalse是保留关键字-编译器不允许您将它们用作变量或属性名称

另一个区别是,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

此外,在数字上下文中处理nullundefined的方式也存在重要区别

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(“非数字”)。

请注意,nullundefined==!=运算符得到特殊处理,但是您可以使用表达式测试ab的真数值相等(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将后两种情况区分为两个不同的值,nullundefined您可以自由地明确使用这些值来传达这些含义。

那么,由于这种哲学基础而引起的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. nullundefined值得庆幸的是有不同的类型。null属于类型Nullundefined类型Undefined这是规范中的内容,但是由于typeof我在这里不再赘述,因此您永远不会知道这一点。

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

顺便说一下,JavaScript中还有其他形式的“虚无”(学习哲学是一件好事……)

  • NaN
  • 使用从未声明过的变量并接收 ReferenceError
  • 在其时间死区中使用letconst定义的局部变量并接收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值

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

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

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

对于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();

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,当我们听到我们可能会感到困惑nullundefined,但让我们开始简单,他们都是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的变量,这意味着该变量被明确设置为不具有值。如果比较undefinednull使用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作为输出。那是Undefinednull之间的主要区别

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>

也可以看看:

干杯!

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

主要区别在于,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"

引用Marijn Haverbeke的“ Eloquent Javascript”第3版:

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

老实说,起初,我对这一建议有些怀疑。然而,在我自己的解释,这是一个lazy(VS eager)的方式来处理他们之间的分歧。也许,我们根本不必处理差异。如果需要的话,我们可以延迟我们的担心(我们必须这样做),而不必hyperactively/defensively担心这些值(nullundefined)在我们的代码中流动的每一步

PS:这不是您问题的直接答案。这只是一个相关的意见。

本文地址:http://javascript.askforanswer.com/javascriptzhongdenullheundefinedyoushenmequbie.html
文章标签: ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!