首页 文章

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

提问于
浏览
874

我想知道JavaScript中 nullundefined 之间的区别 .

30 回答

  • 1

    null 是一个特殊值,意思是"no value" . null 是一个特殊对象,因为 typeof null 返回'object' .

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

  • 2

    undefinednull 之间的差异很小,但存在差异 . 值为 undefined 的变量从未初始化 . 值为 null 的变量显式赋值为 null ,这意味着该变量显式设置为没有值 . 如果使用 null==undefined 表达式比较 undefinednull ,则它们将相等 .

  • -3

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

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

    Null是一项任务:

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

    理解差异的最好方法是首先清楚你对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的问题呢?

    • 没有初始化程序的声明变量获得值 undefined ,因为您从未说过预期值是什么 .
    let supervisor;
    assert(supervisor === undefined);
    
    • 从未设置过的对象的属性求值为 undefined ,因为没有人对该属性说过什么 .
    const dog = { name: 'Sparky', age: 2 };
    assert(dog.breed === undefined);
    
    • nullundefined 彼此是"similar",因为Brendan Eich这样说 . 但它们在重点上并不相同 .
    assert(null == undefined);
    assert(null !== undefined);
    

    谢天谢地

    • nullundefined 有不同的类型 . null 属于 Null 类型, undefined 属于 Undefined 类型 . 这是在规范中,但你永远不会知道这一点,因为我不会在这里重复 typeof 古怪 .

    • 在没有显式返回语句的情况下到达其主体末尾的函数返回 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 ]
    
  • 1

    我从here挑选了这个

    未定义的值是在未为变量赋值时使用的原始值 . null值是一个原始值,表示null,empty或不存在的引用 .

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

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

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

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

    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,并为您忘记设置的内容保留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 . 除此之外,这两个特殊值几乎相同 .

  • 8

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

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

    • 未声明的变量

    • 已声明但未分配的变量

    • 用文字 undefined 分配的变量

    • 用文字 null 分配的变量

    • 使用 undefinednull 以外的任何内容分配的变量

    以下逐一解释这些案例

    • Undeclared Variables :以下适用于未声明的变量

    • 只能通过返回字符串 'undefined'typeof() 进行检查

    • 无法使用 =====if 或条件运算符 ? (抛出参考错误)进行检查

    • Declared but Unassigned Variables

    • typeof 返回字符串 'undefined'

    • == 检查 null 返回 true

    • == 检查 undefined 返回 true

    • === 检查 null 返回 false

    • === 检查 undefined 返回 true

    • if 或条件运算符 ? 返回 false

    • Variables assigned with literal undefined :这些变量的处理方式与 Declared But Unassigned Variables 类似 .

    • Variables assigned with literal null

    • typeof 返回字符串 'object'

    • == 检查 null 返回 true

    • == 检查 undefined 返回 true

    • === 检查 null 返回 true

    • === 检查 undefined 返回 false

    • if 或条件运算符 ? 返回false

    • Variables assigned with anything other than undefinednull

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

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

    • 使用 typeof 检查 undeclared / unassigned / assigned with undefined . 如果返回字符串 'undefined' 则返回 .

    • 使用 === 检查 null . 如果 true ,则返回 'null' .

    • 使用 typeof 检查实际类型 . 返回类型 if not equal to 'object'

    • 调用 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 
    }
    
  • 8

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

    JavaScript中的Null和undefined都表示没有值 . var a = null; //变量赋值为null
    var b; //未定义
    尽管两者都存在 Value 缺失,但是:未定义实际上意味着变量未初始化 . 返回任何函数的函数和没有提供值的函数参数,返回未定义的值 . 使用严格相等运算符===来区分null和undefined .

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

  • 1

    只是为了添加我的观点 -

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

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

    javascript中的null是表示地址的值,但该地址指向任何内容[不存在的引用] . 然而,它的 Value .

  • 7

    null - 这是一个赋值 . 与变量一起使用以表示无值 . (它的一个对象)

    undefined - 这是一个没有赋值的变量 . 所以javascript会为它分配一个undefined . (它的数据类型)

    undeclared - 如果根本没有创建变量,则称为未声明 .

  • 28

    TL;博士

    使用 null 设置一个您知道它是Object的变量 .

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


    这是我对5个原语和对象类型的使用,它解释了 undefinednull 的“用例”之间的区别 .

    String

    如果你知道变量只是一个字符串,而所有生命周期,按照惯例,你可以初始化它,到 ""

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

    Number

    如果您知道变量只是一个数字,而所有生命周期,按照惯例,您可以将其初始化为 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"
    

    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的智能用法是Object的 falsy 版本,因为Object始终是 true ,并且因为 typeof null 返回 object . 这意味着 typeof myVarObject 返回Object和null类型的一致值 .

    All

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

  • -1

    我会解释 undefinednullUncaught ReferenceError

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

  • 11

    当值为null时,它什么都不是,什么都不包含 . 空值或变量仍然是满的;它充满了空虚 . 空虚与null不同,这简直就是一无所获 . 例如,定义变量并将其值设置为空字符串如下所示:

    var myVariable = '';
    

    变量myVariable为空,但不为null .

    Undefined 是一个状态,有时像值一样用于表示尚未包含值的变量 . 例如 var abcd ; . 此状态与null不同,尽管null和undefined都可以以相同的方式计算 .

  • 2

    如果未初始化变量,则它是未定义的 . undefined不是一个对象 . 示例:var MyName; console.log(typeof MyName);

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

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

    示例:var MyName = null; console.log(typeof MyName);检查csole登录开发工具,它将是一个对象 .

  • 4
    • undefined 表示已声明变量但尚未赋值 .

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

    • undefined and null 是两种不同的类型:

    undefined是一个类型本身(未定义),而null是一个对象 .

    • 未分配的变量由JavaScript初始化,默认值为undefined .

    • JavaScript从不将值设置为null . 这必须以编程方式完成 .

  • 60

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

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

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

  • 1

    您可以将undefined视为表示系统级,意外或类似错误的值缺省,并将null视为表示程序级,正常或预期缺少值 .

    通过JavaScript:权威指南

  • 3

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

    现在您可以显式分配变量 null . 这意味着变量没有任何值 . 例如 - 有些人没有中间名 . 所以在这种情况下,最好将值null赋给person对象的middlename变量 .

    现在假设有人正在访问person对象的middlename变量,并且它的值为 undefined . 他不会有任何 Value . 如果它具有值 null ,则用户可以很容易地推断出中间名没有任何值,并且它不是未触及的变量 .

  • 875

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

    把它想象成一个 Value ,如:

    • "foo"是字符串,

    • true是布尔值,

    • 1234是数字,

    • null未定义 .


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

    var foo;
    

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


    都他们代表 value of a variable with no value

    AND 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
    
  • 2

    null 是一个语言关键字,其值为一个特殊值,通常用于表示缺少值 . 在null上使用typeof运算符返回字符串“object”,表示null可以被认为是指示“无对象”的特殊对象值 . 然而,在实践中,null通常被认为是其自身类型的唯一成员,并且它可用于指示数字和字符串以及对象的“无值” . 大多数编程语言都等同于JavaScript的null:您可能熟悉它为null或nil .

    JavaScript还有第二个值,表示缺少值 . undefined 值表示更深层次的缺席 . 它是尚未初始化的变量的值,以及查询不存在的对象属性或数组元素的值时获得的值 . 未定义的值也由没有返回值的函数返回,以及没有提供参数的函数参数的值 . undefined是一个预定义的全局变量(不是像null这样的语言关键字),它被初始化为未定义的值 . 在ECMAScript 3中,undefined是一个读/写变量,可以设置为任何值 . 在ECMAScript 5中更正了此错误,并且undefined在该版本的语言中是只读的 . 如果将typeof运算符应用于未定义的值,则返回“undefined”,表示此值是特殊类型的唯一成员 .

    尽管存在这些差异,但null和undefined都表明缺乏 Value ,并且通常可以互换使用 . 等于运算符==认为它们是相等的 . (使用严格相等运算符===来区分它们 . )两者都是假值 - 当需要布尔值时,它们的行为类似于false . null或undefined都没有任何属性或方法 . 实际上,使用 . 或[]访问这些值的属性或方法会导致TypeError .

    您可以将undefined视为表示系统级,意外或类似错误的值缺省,并将null视为表示程序级,正常或预期缺少值 . 如果需要将其中一个值分配给变量或属性,或者将其中一个值传递给函数,则null几乎总是正确的选择 .

  • 8

    对于 undefined 类型,只有一个值: undefined .

    对于 null 类型,只有一个值: null .

    所以对他们两个人来说, the label is both its type and its value.

    它们之间的区别 . 例如:

    • null 是一个空值

    • undefined 是缺失值

    要么:

    • undefined 尚未有 Value

    • null 有一个值,现在不再有了

    实际上, nullspecial keyword ,而不是标识符,因此您不能将其视为要分配的变量 .

    但是, undefinedidentifier . 但是,在 non-strict 模式和 strict 模式下,您可以创建名称为undefined的局部变量 . 但这是一个可怕的想法!

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

    使用JavaScript,null用于对象,undefined用于变量,属性和方法 .

    要为null,必须定义一个对象,否则它将是未定义的 .

    如果要测试对象是否存在,如果对象未定义,则会抛出错误:

    不正确:

    if (myObj !== null && typeof myObj !== "undefined")
    

    因此,您必须首先测试typeof():

    正确:

    if (typeof myObj !== "undefined" && myObj !== null)
    
  • 1

    基本上, 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
    

    Undefined 这就是你将得到的输出 .

    现在,

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

    你会得到 5 作为输出 . 这是 Undefinednull 之间的主要区别

  • 1

    在javascript中,所有变量都存储为键值对 . 每个变量都存储为variable_name:variable_value / reference .

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

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

    两者都相似,但用法和含义不同 .

  • 1

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

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

    Exploring the Eternal Abyss of Null and Undefined

  • 1

    在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是一个对象 . 在某种程度上,我们已将值null赋给'a'

  • 14

    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赋给未定义的变量 .

  • 8

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

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

    但如果您使用 == 检查它们,如下所示,您会发现它们都是假的:

    null==undefined; //true
    

    您也可以将 null 分配给对象属性或基元,而 undefined 可以通过不分配任何内容来实现 .

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

  • 2

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

    • 两者只能分别持有一个值 nullundefined ;

    • 都没有属性或方法,并且尝试读取任何属性都将导致运行时错误(对于所有其他对象,如果尝试读取不存在的属性,则获得值 undefined );

    • nullundefined==!= 运算符视为彼此相等而不是其他任何内容 .

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

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

    undefinedNaNInfinity 只是预初始化的"superglobal"变量的名称 - 它们在运行时初始化,可以被具有相同名称的普通全局变量或局部变量覆盖 .

    现在,让我们用 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 类似,它基本上只是一种特殊的"zero" . 另一方面, undefined 是真的"nothing",并且当您尝试在数字上下文中使用它时变为 NaN ("not a number") .

    请注意 nullundefined==!= 运算符接收特殊处理,但您可以使用表达式 (a >= b && a <= b) 测试 ab 的真正数字相等性 .

  • 2

    由于typeof返回undefined,undefined是一种类型,其中null是初始化器,表示变量指向无对象(实际上Javascript中的所有内容都是对象) .

相关问题