GVKun编程网logo

JavaScript中的null和undefined（javascript null undefined）

8

本文将为您提供关于JavaScript中的null和undefined的详细介绍，我们还将为您解释javascriptnullundefined的相关知识，同时，我们还将为您提供关于ECMAScrip

本文将为您提供关于JavaScript中的null和undefined的详细介绍，我们还将为您解释javascript null undefined的相关知识，同时，我们还将为您提供关于ECMAScript中原始类型Null和Undefined小结、JavaScript JavaScript中null和undefined区别分析、JavaScript null和undefined区别分析_javascript技巧、javascript – null和undefined不一致的比较的实用信息。

本文目录一览：

JavaScript中的null和undefined（javascript null undefined）

JavaScript中的null和undefined（javascript null undefined）

1.概述

　　null和undefined属于js中两种不同的基本数据类型，都可以表示“没有”，含义非常相似。将一个变量赋值为undefined或null，老实说，语法效果几乎没区别。并且在if语句的判断条件中，它们都会自动转为false，相等运算符（==）甚至直接报告两者相等

var a = null;
var b = undefined;
if (!a) {
  console.log(''a is false'');
}//a is false
if (!b) {
  console.log(''b is false'');
}//b is false
if (null == undefined) {
  console.log(''null == undefined is true'')
}//null == undefined is true

　　null是一个表示“空”的对象，转为数值时为0；undefined是一个表示"此处无定义"的原始值，转为数值时为NaN。

Number(null); // 0
null + 9; // 9
Number(undefined); // NaN
undefined + 9; // NaN

2.用法和含义

　　对于null和undefined，大致可以像下面这样理解。null表示空值，即该处的值现在为空。调用函数时，某个参数未设置任何值，这时就可以传入null，表示该参数为空。比如，某个函数接受引擎抛出的错误作为参数，如果运行过程中未出错，那么这个参数就会传入null，表示未发生错误。undefined表示“未定义”，下面是返回undefined的典型场景。

// 变量声明了，但没有赋值
var i;
i // undefined

// 调用函数时，应该提供的参数没有提供，该参数等于 undefined
function f(x) {
  return x;
}
f() // undefined

// 对象没有赋值的属性
var  o = new Object();
o.p // undefined

// 函数没有返回值时，默认返回 undefined
function f() {}
f() // undefined

 

 

原文出处：https://www.cnblogs.com/gongming/p/11609339.html

ECMAScript中原始类型Null和Undefined小结

ECMAScript中原始类型Null和Undefined小结

文章最新版地址：http://leeyee.github.io/blog/2013/05/07/javascript-null-undefined


  var param; var param = undefined; var param = null; 未定义
param == ''undefined'' false false  false 报错。param未定义
param === ''undefined'' false   false   false   报错。param未定义
param == undefined true true true 报错。param未定义
param === undefined true  true  false 报错。param未定义
typeof param undefined   undefined  object undefined 
typeof param == ''undefined'' true  true  false  true 
typeof param === ''undefined'' true  true false  true 
typeof param == undefined false  false  false  false 
typeof param === undefined false false  false  false
if(param) false  false  false  报错。param未定义 
if(typeof param) true true true  true  


结论：

  • null 表示无值，而 undefined 表示一个未声明的变量，或已声明但没有赋值的变量，或一个并不存在的对象属性。
  • 声明但不赋值，默认为undefined;即 var param ; 等价于 var param = undefined;
  • undefined不同于未定义，但typeof并不区分undefined和未定义;因此typeof(undefined)与typeof(未定义变量)的输出值都是undefined;
  • 当函数无明确返回值时，默认返回的为undefined;如：( function foo(){ })
  • typeof(null)返回的是对象，但null == undefined返回true；这是由于值undefined其实是从值null派生过来的，因此ECMAScript将其定义为一样的;
  • null 虽然 == undefined，但undefined是声明了变量但未对其初始化时赋值时赋予该变量的值，null则表示尚未存在的对象;
  • 只能用 === 运算来测试某个值是否是未定义的，因为 == 运算符认为 undefined 值等价于 null;
  • 函数或方法返回值为对象时，如果该返回的对象找不到则该函数或方法通常返回的是null;
  • typeof方法返回的是变量的引用类型的字符名称。因此if(typeof param)为永真。如果要判断引用类型，可以使用instanceof，但此时变量的声明应使用new关键字创建。
测试代码： 


function test1() {
          var param;// 定义但未赋值
          console.log("1. var param; --> ", "定义但未赋值");
          console.log(" 1.1. param == ''undefined'' <--> ", param == ''undefined''); // false
          console.log(" 1.2. param == undefined <--> ", param == undefined);// true
         
          console.log("      1.1.1 param === ''undefined'' <--> ", param === ''undefined''); // false
          console.log("      1.2.1 param === undefined <--> ", param === undefined);// true
         
          console.log(" 1.3. typeof param <--> ", typeof param); // undefined
          console.log(" 1.4. typeof param == ''undefined'' <--> ",
                   typeof param == ''undefined''); //true
          console.log(" 1.5. typeof param == undefined <--> ",
                   typeof param == undefined);//false
          console.log("      1.4.1 typeof param === ''undefined'' <--> ",
                   typeof param === ''undefined''); //true
          console.log("      1.5.1 typeof param === undefined <--> ",
                   typeof param === undefined);//false
          param ? console.log(" 1.6. if(param) return true") : console
                   .log(" 1.6. if(param) return false");

          typeof param ? console.log(" 1.7. if(typeof param) return true")
                   : console.log(" 1.7. if(typeof param) return false");

     }
     function test2() {
          console.log("2. param未定义");
          console.log(" 2.1. param == ''undefined'' <--> ", "报错，param未定义");
          console.log(" 2.2. param == undefined <--> ", "报错，param未定义");
          console.log(" 2.3. typeof param <--> ", typeof param); // undefined
          console.log(" 2.4. typeof param == ''undefined'' <--> ",
                   typeof param == "undefined");//true
          console.log(" 2.5. typeof param == undefined <--> ",
                   typeof param == undefined);//false
                         console.log("      2.4.1 typeof param === ''undefined'' <--> ",
                   typeof param === ''undefined'');//true
          console.log("      2.5.1 typeof param === undefined <--> ",
                   typeof param === undefined);//false

          console.log(" 2.6. if(param) 由于param未定义，因此报错");
          typeof param ? console.log(" 2.7. if(typeof param) return true")
                   : console.log(" 2.8. if(typeof param) return false");

     }
     function test3() {
          var param = null;
          console.log("3. var param = null;   -->", "定义默认为null");
          console.log(" 3.1. param == ''undefined'' <--> ", param == ''undefined''); // false
          console.log(" 3.2. param == undefined <--> ", param == undefined);// true
         
          console.log("      3.1.1 param === ''undefined'' <--> ", param === ''undefined''); // false
          console.log("      3.2.1 param === undefined <--> ", param === undefined);// true
         
          console.log(" 3.3. typeof param <--> ", typeof param); // object
          console.log(" 3.4. typeof param == ''undefined'' <--> ",
                   typeof param == ''undefined''); //false
          console.log(" 3.5. typeof param == undefined <--> ",
                   typeof param == undefined);//false
         
           console.log("      3.4.1 typeof param === ''undefined'' <--> ",
                   typeof param === ''undefined''); //false
          console.log("      3.5.1 typeof param === undefined <--> ",
                   typeof param === undefined);//false
         
          param ? console.log(" 3.6. if(param) return true") : console
                   .log(" 3.6. if(param) return false");

          typeof param ? console.log(" 3.7. if(typeof param) return true")
                   : console.log(" 3.7. if(typeof param) return false");

     }
     function test4() {
          var param = undefined;
          console.log("4. var param = undefined;   -->", "定义默认为undefined");
          console.log(" 4.1. param == ''undefined'' <--> ", param == ''undefined''); // false
          console.log(" 4.2. param == undefined <--> ", param == undefined);// true
          console.log(" 4.3. typeof param <--> ", typeof param); // undefined
          console.log(" 4.4. typeof param == ''undefined'' <--> ",
                   typeof param == ''undefined''); //true
          console.log(" 4.5. typeof param == undefined <--> ",
                   typeof param == undefined);//false
          param ? console.log(" 4.6. if(param) return true") : console
                   .log(" 4.6. if(param) return false");

          typeof param ? console.log(" 4.7. if(typeof param) return true")
                   : console.log(" 4.7. if(typeof param) return false");
     }
     test1();
     test2();
     test3();
     test4();


测试结果：


1. var param; --> 定义但未赋值
  1.1. param == ''undefined'' <--> false
  1.2. param == undefined <--> true
       1.1.1 param === ''undefined'' <--> false
       1.2.1 param === undefined <--> true
  1.3. typeof param <--> undefined
  1.4. typeof param == ''undefined'' <--> true
  1.5. typeof param == undefined <--> false
       1.4.1 typeof param === ''undefined'' <--> true
       1.5.1 typeof param === undefined <--> false
  1.6. if(param) return false
  1.7. if(typeof param) return true
2. param未定义
  2.1. param == ''undefined'' <--> 报错，param未定义
  2.2. param == undefined <--> 报错，param未定义
  2.3. typeof param <--> undefined
  2.4. typeof param == ''undefined'' <--> true
  2.5. typeof param == undefined <--> false
       2.4.1 typeof param === ''undefined'' <--> true
       2.5.1 typeof param === undefined <--> false
  2.6. if(param) 由于param未定义，因此报错
  2.7. if(typeof param) return true
3. var param = null;   -->定义默认为null
  3.1. param == ''undefined'' <--> false
  3.2. param == undefined <--> true
       3.1.1 param === ''undefined'' <--> false
       3.2.1 param === undefined <--> false
  3.3. typeof param <--> object
  3.4. typeof param == ''undefined'' <--> false
  3.5. typeof param == undefined <--> false
       3.4.1 typeof param === ''undefined'' <--> false
       3.5.1 typeof param === undefined <--> false
  3.6. if(param) return false
  3.7. if(typeof param) return true
4. var param = undefined;   -->定义默认为undefined
  4.1. param == ''undefined'' <--> false
  4.2. param == undefined <--> true
  4.3. typeof param <--> undefined
  4.4. typeof param == ''undefined'' <--> true
  4.5. typeof param == undefined <--> false
  4.6. if(param) return false
  4.7. if(typeof param) return true

JavaScript JavaScript中null和undefined区别分析

JavaScript JavaScript中null和undefined区别分析

一时间不好回答，特别是undefined，因为这涉及到undefined的实现原理。于是，细想之后，写下本文，请各位大侠拍砖。 
总所周知：null == undefined 
但是：null !== undefined 
那么这两者到底有啥区别呢？ 
请听俺娓娓道来... 
null 
这是一个对象，但是为空。因为是对象，所以 typeof null 返回 'object' 。 
null 是 JavaScript 保留关键字。 
null 参与数值运算时其值会自动转换为 0 ，因此，下列表达式计算后会得到正确的数值： 
表达式：123 + null　　　　结果值：123 
表达式：123 * null　　　　结果值：0 
undefined 
undefined是全局对象（window）的一个特殊属性，其值是未定义的。但 typeof undefined 返回 'undefined' 。 
虽然undefined是有特殊含义的，但它确实是一个属性，而且是全局对象（window）的属性。请看下面的代码： 

复制代码代码如下:

alert('undefined' in window);//输出：true 
var anObj = {}; 
alert('undefined' in anObj); //输出：false 

从中可以看出，undefined是window对象的一个属性，但却不是anObj对象的一个属性。 
注意：尽管undefined是有特殊含义的属性，但却不是JavaScript的保留关键字。 
undefined参与任何数值计算时，其结果一定是NaN。 
随便说一下，NaN是全局对象（window）的另一个特殊属性，Infinity也是。这些特殊属性都不是JavaScript的保留关键字！ 
提高undefined性能 
 当我们在程序中使用undefined值时，实际上使用的是window对象的undefined属性。 
同样，当我们定义一个变量但未赋予其初始值，例如： 
var aValue; 
这时，JavaScript在所谓的预编译时会将其初始值设置为对window.undefined属性的引用， 
于是，当我们将一个变量或值与undefined比较时，实际上是与window对象的undefined属性比较。这个比较过程中，JavaScript会搜索window对象名叫‘undefined'的属性，然后再比较两个操作数的引用指针是否相同。 
由于window对象的属性值是非常多的，在每一次与undefined的比较中，搜索window对象的undefined属性都会花费时 间。在需要频繁与undefined进行比较的函数中，这可能会是一个性能问题点。因此，在这种情况下，我们可以自行定义一个局部的undefined变 量，来加快对undefined的比较速度。例如： 
复制代码代码如下:

function anyFunc() { 
var undefined; 
//自定义局部undefined变量 
if(x == undefined) 
//作用域上的引用比较 
while(y != undefined) 
//作用域上的引用比较 
}; 

其中，定义undefined局部变量时，其初始值会是对window.undefined属性值的引用。新定义的局部undefined变 量存在与该函数的作用域上。在随后的比较操作中，JavaScript代码的书写方式没有任何的改变，但比较速度却很快。因为作用域上的变量数量会远远少 于window对象的属性，搜索变量的速度会极大提高。 
这就是许多前端JS框架为什么常常要自己定义一个局部undefined变量的原因！

JavaScript null和undefined区别分析_javascript技巧

JavaScript null和undefined区别分析_javascript技巧

一时间不好回答，特别是undefined，因为这涉及到undefined的实现原理。于是，细想之后，写下本文，请各位大侠拍砖。
总所周知：null == undefined
但是：null !== undefined
那么这两者到底有啥区别呢？
请听俺娓娓道来...
null
这是一个对象，但是为空。因为是对象，所以 typeof null 返回 ''object'' 。
null 是 JavaScript 保留关键字。
null 参与数值运算时其值会自动转换为 0 ，因此，下列表达式计算后会得到正确的数值：
表达式：123 + null　　　　结果值：123
表达式：123 * null　　　　结果值：0
undefined
undefined是全局对象（window）的一个特殊属性，其值是未定义的。但 typeof undefined 返回 ''undefined'' 。
虽然undefined是有特殊含义的，但它确实是一个属性，而且是全局对象（window）的属性。请看下面的代码：

复制代码 代码如下:

alert(''undefined'' in window);//输出：true
var anObj = {};
alert(''undefined'' in anObj); //输出：false

从中可以看出，undefined是window对象的一个属性，但却不是anObj对象的一个属性。
注意：尽管undefined是有特殊含义的属性，但却不是JavaScript的保留关键字。
undefined参与任何数值计算时，其结果一定是NaN。
随便说一下，NaN是全局对象（window）的另一个特殊属性，Infinity也是。这些特殊属性都不是JavaScript的保留关键字！
提高undefined性能
当我们在程序中使用undefined值时，实际上使用的是window对象的undefined属性。
同样，当我们定义一个变量但未赋予其初始值，例如：
var aValue;
这时，JavaScript在所谓的预编译时会将其初始值设置为对window.undefined属性的引用，
于是，当我们将一个变量或值与undefined比较时，实际上是与window对象的undefined属性比较。这个比较过程中，JavaScript会搜索window对象名叫‘undefined''的属性，然后再比较两个操作数的引用指针是否相同。
由于window对象的属性值是非常多的，在每一次与undefined的比较中，搜索window对象的undefined属性都会花费时 间。在需要频繁与undefined进行比较的函数中，这可能会是一个性能问题点。因此，在这种情况下，我们可以自行定义一个局部的undefined变 量，来加快对undefined的比较速度。例如：
复制代码 代码如下:

function anyFunc() {
var undefined;
//自定义局部undefined变量
if(x == undefined)
//作用域上的引用比较
while(y != undefined)
//作用域上的引用比较
};

其中，定义undefined局部变量时，其初始值会是对window.undefined属性值的引用。新定义的局部undefined变 量存在与该函数的作用域上。在随后的比较操作中，JavaScript代码的书写方式没有任何的改变，但比较速度却很快。因为作用域上的变量数量会远远少 于window对象的属性，搜索变量的速度会极大提高。
这就是许多前端JS框架为什么常常要自己定义一个局部undefined变量的原因！

javascript – null和undefined不一致的比较

javascript – null和undefined不一致的比较

我很想知道为什么 
null == undefined

返回true但是

null >= undefined

返回false

包含大于运算符的值是否会以不同方式强制执行？

解决方法

tl; dr> =在这种情况下最终将两个参数强制转换为数字：undefined被强制转换为NaN,而null被强制转换为0,这是不相等的.对于==,规范明确定义null == undefined为true.

事实上,这些值在两种情况下都会被强制执行(从某种意义上说,至少 – = =的情况是特殊的).让我们在规范的帮助下一次考虑一个.

> =运算符的algorithm使用“Abstract Relational Comparison Algorithm”,其由其他关系运算符共享.从规范中的描述,我们看到该算法执行以下操作：

>将参数转换为基元(已经为null和undefined).
>检查参数是否为字符串(它们不是).
>如果它们不是字符串,则算法将参数转换为数字(请参阅步骤3.a.和3.b.)并执行与结果的比较.

最后一点是关键.从ToNumber table开始,我们看到undefined被强制转换为NaN,算法认为任何与NaN的比较都是假的(参见步骤3.c.和3.d.).因此,null> = undefined是false.

对于另一种情况,==,故事实际上要简单得多：spec explicitly states null == undefined为真,作为“抽象等式比较算法”的一部分(参见步骤2.和3).因此,null == undefined为true.

今天关于JavaScript中的null和undefined和javascript null undefined的分享就到这里，希望大家有所收获，若想了解更多关于ECMAScript中原始类型Null和Undefined小结、JavaScript JavaScript中null和undefined区别分析、JavaScript null和undefined区别分析_javascript技巧、javascript – null和undefined不一致的比较等相关知识，可以在本站进行查询。

本文标签：

上一篇GetManifestResourceStream 加载为null（getresourceasstream报错）

下一篇python-----利用filecmp删除重复文件（python删除文件中的重复内容）

相关文章