隐性转变机制,浅析Javascript中双等号

By admin in 4858美高梅 on 2019年4月23日

  在Javascript中判别相等关系有双等号(==)和三等号(===)二种。在那之中双等号(==)是值非凡,而三等号(===)是严格相等(值及类型是还是不是完全相等)。

于是有多少个常识知识:

一、对于string,number等基础项目,==和===是有分别的
  一)分化门类间比较,==之比较“转化成同壹类型后的值”看“值”是不是等于,===如若类型不一样,其结果正是见仁见智
  二)同品种相比,直接开始展览“值”比较,两者结果1致

二、对于Array,Object等高端项目,==和===是未曾区分的
  进行“指针地址”比较

3、基础项目与高等项目,==和===是有分其余
  一)对于==,将高等转化为根基项目,实行“值”相比
  2)因为品种不相同,===结果为false

 

换句话说,隐性转变机制,浅析Javascript中双等号。双等号(==)在运算的时候会开始展览类型调换,而叁等号(===)则不会。

如:
alert(’55’ == 55); //true
alert(’55’ === 55); //false

Javascript语言中中国共产党第五次全国代表大会骨干数据类型(原始值,也叫轻巧数据类型):即 **Undefined、Null、Boolean、Number 和 String

  在Javascript中判定相等关系有双等号(==)和叁等号(===)三种。当中双等号(==)是值杰出,而3等号(===)是从严相等(值及类型是或不是完全相等)。

就此有多少个常识知识:

一、对于string,number等基础项目,==和===是有分其他
  1)区别系列间比较,==之相比较“转化成同1类型后的值”看“值”是不是等于,===要是类型分化,其结果便是例外
  二)同品种相比,直接开始展览“值”相比,两者结果一样

二、对于Array,Object等高档项目,==和===是绝非区分的
  实行“指针地址”相比较

叁、基础项目与高等项目,==和===是有分别的
  一)对于==,将高端转化为根基项目,举行“值”相比较
  二)因为项目分歧,===结果为false

 

换句话说,双等号(==)在运算的时候会议及展览开类型转变,而叁等号(===)则不会。

如:
alert(’55’ == 55); //true
alert(’55’ === 55); //false

Javascript语言中中国共产党第五次全国代表大会骨干数据类型(原始值,也叫轻易数据类型):即 **Undefined、Null、Boolean、Number 和 String

在Javascript中决断相等关系有双等号(==)和叁等号(===)三种。个中双等号(==)是值卓越,而叁等号(===)是严苛相等(值及类型是或不是完全相等)。

多年来径直在笔试面试,经常遇上举例12三==’12三’、’abc’==true等主题材料,在那之中有回答的,也有答错的,首要缘由如故对ECMAScript的规范未有知道驾驭,很多难点未有具体分析所产生。现查阅资料后对此实行部分总括。

型**。由于这一个原始类型攻下的空中是固定的,所以可将他们存款和储蓄在很小的内部存款和储蓄器区域

栈中。那样存款和储蓄便于飞快查找变量的值。(详见:

Javascript中选用双等号(==)判定相等的隐性转换机制:

一,假使两边都是轻便类型:

  壹,1,两边都以回顾类型,且项目一样,则直接实行比较。

console.log(1==1); //true
console.log("1"=="1"); //true
console.log(false==false); //true
console.log(null==null); //true
console.log(undefined==undefined); //true

  壹.2,两边都以粗略类型,类型区别,则先转移为数字相比较(在那之中Boolean只有四个值:true==一,false==0;null与undefined相等;字符串数字也正是数字值,空字符串””==0;)

console.log(1==true); //true
console.log(0==false); //true
console.log(1=="1"); //true
console.log(0==""); //true
console.log(0==null); //false
console.log(0==undefined); //false
console.log(null==undefined); //true

 

贰,尽管1方面是回顾类型,另一面是引用类型(高端项目),则高档项目隐式转变来简单类型再比较。

console.log(Object==Object); //true
console.log(Object=={}); //false
console.log(0=={}); //false

console.log(0==[]); //true
console.log(Array==Array); //true
console.log(Object==Array); //false

3,即使两边都以援引类型(高端项目),则开始展览举办“指针地址”比较。

 

重点-toString()和valueOf()

众三个人看来那七个格局的第2感到就是,toString()方法将贰个目的转化为字符串,valueOf方法将多少个对象转化为数值。

那种主张很片面,我们经过以下多少个例子来探视:

var obj={
    name:"熊仔其人",
    getName:function(){ return $(this).name; }
};

console.log(obj.toString()); //[object Object]

概念贰个obj对象,调用它的toString方法,重返值是[object
Object],发掘未有像大家想象的平等再次回到值其剧情的字符串表示。

var arr=[1,2,3];
console.log(arr.valueOf()); //(3) [1, 2, 3] 

概念贰个数组arr,调用它的valueOf方法,再次来到值是[1, 2,
3],开采也尚未像我们想像的同样重回数值类型的代表。

实在真正的知情是这般的:调用对象的toString()方法能够将对象转化为字符串,不过如若要转化为字符串不必然是调用toString方法。

大家再看看上面包车型大巴代码。

var obj= { };     
obj.valueOf=function(){ return 1; }
obj.toString=function(){ return 2; }
console.log(obj==1);    //true

var obj2= { };     
obj2.valueOf=function(){ return 2; }
obj2.toString=function(){ return 1; }
console.log(obj2==1);    //false                        

var obj3={ };
obj3.valueOf=function(){ return []; }
obj3.toString=function(){ return 1; }
console.log(obj3==1);    //true 

上述代码中我们定义了2个对象obj,obj2,定义了valueOf和toString方法的再次来到值,通过与1比较相等,开采其事先调用了valueOf方法。

接下来定义了3个对象obj三,定义了valueOf和toString方法的重返值,通过与一相比相等,开采其调用的是toString方法。

 

然后大家看下边1段代码:

var obj= { };     
obj.valueOf=function(){ return 'a'; }
obj.toString=function(){ return 2; }
console.log(obj=='a');    //true

var obj2= { };     
obj2.valueOf=function(){ return 'b'; }
obj2.toString=function(){ return 'a'; }
console.log(obj2=='a');    //false 

上述代码第22中学定义贰个对象obj,通过与字符串’a’相比开采其调用的是valueOf方法。

接下来对象obj二与’a’的可比再次来到false,开采其尚无调用toString方法。

 

经过大家能够得出结论:

目的转化为轻便类型时会优先调用valueOf方法,要是得以与简短值实行相比较则会一向相比较,此时不再调用toString方法。借使调用valueOf方法后不大概与轻巧值进行相比,则会再调用toString方法,最终赢得比对的结果。

只是急需专注的某个是Date对象不知足上述的平整,Date对象的toString和valueOf方法都以再次定义过的,暗中同意会调用toString方法。

型**。由于那几个原始类型占领的半空中是原则性的,所以可将她们存款和储蓄在相当的小的内部存款和储蓄器区域

栈中。那样存款和储蓄便于快捷检索变量的值。(详见:

Javascript中运用双等号(==)推断相等的隐性转变机制:

一,假诺两边都以简约类型:

  一,一,两边皆以大概类型,且项目同样,则一直开始展览相比。

console.log(1==1); //true
console.log("1"=="1"); //true
console.log(false==false); //true
console.log(null==null); //true
console.log(undefined==undefined); //true

  一.贰,两边都以总结类型,类型分歧,则先转移为数字相比较(个中Boolean唯有两个值:true==一,false==0;null与undefined相等;字符串数字也正是数字值,空字符串””==0;)

console.log(1==true); //true
console.log(0==false); //true
console.log(1=="1"); //true
console.log(0==""); //true
console.log(0==null); //false
console.log(0==undefined); //false
console.log(null==undefined); //true

 

二,假设壹方面是大致类型,另三只是援引类型(高等项目),则高等项目隐式转变到轻便类型再比较。

console.log(Object==Object); //true
console.log(Object=={}); //false
console.log(0=={}); //false

console.log(0==[]); //true
console.log(Array==Array); //true
console.log(Object==Array); //false

三,即便两边都是引用类型(高端项目),则开展实行“指针地址”相比较。

 

重点-toString()和valueOf()

许多少人看来这多少个方法的首先认为就是,toString()方法将3个对象转化为字符串,valueOf方法将三个目标转化为数值。

那种主见很片面,大家透过以下七个例子来看看:

var obj={
    name:"熊仔其人",
    getName:function(){ return $(this).name; }
};

console.log(obj.toString()); //[object Object]

概念贰个obj对象,调用它的toString方法,再次回到值是[object
Object],开采未有像大家想象的一模同样重返值其剧情的字符串表示。

var arr=[1,2,3];
console.log(arr.valueOf()); //(3) [1, 2, 3] 

概念二个数组arr,调用它的valueOf方法,重返值是[1, 2,
3],开掘也从没像大家想像的一样再次来到数值类型的代表。

骨子里真正的知情是那般的:调用对象的toString()方法能够将对象转化为字符串,可是只要要转正为字符串不必然是调用toString方法。

大家再看看上面包车型客车代码。

var obj= { };     
obj.valueOf=function(){ return 1; }
obj.toString=function(){ return 2; }
console.log(obj==1);    //true

var obj2= { };     
obj2.valueOf=function(){ return 2; }
obj2.toString=function(){ return 1; }
console.log(obj2==1);    //false                        

var obj3={ };
obj3.valueOf=function(){ return []; }
obj3.toString=function(){ return 1; }
console.log(obj3==1);    //true 

上述代码中我们定义了八个对象obj,obj2,定义了valueOf和toString方法的再次来到值,通过与一相比相等,开掘其事先调用了valueOf方法。

下一场定义了三个对象obj三,定义了valueOf和toString方法的再次来到值,通过与壹相比相等,开采其调用的是toString方法。

 

然后我们看下边一段代码:

var obj= { };     
obj.valueOf=function(){ return 'a'; }
obj.toString=function(){ return 2; }
console.log(obj=='a');    //true

var obj2= { };     
obj2.valueOf=function(){ return 'b'; }
obj2.toString=function(){ return 'a'; }
console.log(obj2=='a');    //false 

上述代码2中定义四个对象obj,通过与字符串’a’相比发掘其调用的是valueOf方法。

下一场对象obj二与’a’的相比重临false,开采其尚无调用toString方法。

 

经过大家得以得出结论:

目的转化为简便类型时会优先调用valueOf方法,固然能够与轻松值进行比较则会一向相比,此时不再调用toString方法。假设调用valueOf方法后不也许与轻易值进行相比,则会再调用toString方法,最后获得比对的结果。

可是必要小心的某个是Date对象不满意上述的规则,Date对象的toString和valueOf方法都是重新定义过的,暗许会调用toString方法。

于是有几个常识知识:

 

一、对于string,number等基础项目,==和===是有分别的

等性操作符(==)

  一)差异类型间相比较,==之相比“转化成同壹类型后的值”看“值”是或不是等于,===假如类型差异,其结果正是见仁见智

 

  二)同类别对比,直接进行“值”比较,两者结果一致

一、相比的档期的顺序是String、Number、Boolean这个大旨项目时

2、对于Array,Object等高端项目,==和===是平昔不区分的

 

  进行“指针地址”比较

当是这几中项目举行相比较时,会先将两头转变来数字,在拓展比较。

三、基础项目与高端项目,==和===是有分别的

 

  一)对于==,将高端转化为底蕴项目,实行“值”相比较

复制代码

  2)因为品种不一样,===结果为false

一 console.log(一 == true); // true调换来数字为一,由此结果为true

换句话说,双等号(==)在运算的时候会开始展览类型转变,而叁等号(===)则不会。

如:

3 console.log(‘123’ == 123); //true

alert('55' == 55); //true
alert('55' === 55); //false

Javascript语言中中国共产党第五次全国代表大会亚湾原子核能发电站心数据类型(原始值,也叫轻松数据类型):即
Undefined、Null、Boolean、Number 和 String
型。由于那几个原始类型占有的半空中是原则性的,所以可将他们存款和储蓄在很小的内部存储器区域

伍 console.log(‘abc’ == true);
//’abc’转换来数字为NaN,结果为false,ECMAScript规定,NaN与别的值相比较都以false,包罗NaN==NaN

  • 栈中。那样存款和储蓄便于急忙检索变量的值;

Javascript中应用双等号(==)决断相等的隐性转换机制:

复制代码

一,假如两边都是简单类型:

二、上述基本类型与引用类型相比较时

  壹,1,两边都是轻易类型,且项目同样,则直接开始展览相比较。

 

console.log(1==1); //true
console.log("1"=="1"); //true
console.log(false==false); //true
console.log(null==null); //true
console.log(undefined==undefined); //true

第1会调用对象的valueOf()方法,期待回到3个主导项目标值(测试为若重返Boolean、Number、String、null、undefined或尚未再次来到值,则将不会一而再调用toString方法),若重临的依然是三个复合对象的话,则调用其toString()方法,若依旧未有回到上述基本项目标话,则直接判为不对等。

  一.二,两边都以简轻便单类型,类型差异,则先转移为数字相比(当中Boolean只有几个值:true==1,false==0;null与undefined相等;字符串数字相当于数字值,空字符串””==0;)

 

console.log(1==true); //true
console.log(0==false); //true
console.log(1=="1"); //true
console.log(0==""); //true
console.log(0==null); //false
console.log(0==undefined); //false
console.log(null==undefined); //true

复制代码

二,假使一方面是粗略类型,另一面是引用类型(高等项目),则高档项目隐式调换来轻便类型再比较。

1 var obj = {};

console.log(Object==Object); //true
console.log(Object=={}); //false
console.log(0=={}); //false
console.log(0==[]); //true
console.log(Array==Array); //true
console.log(Object==Array); //false

贰 console.log(obj == ‘一’)
//obj.valueOf()重回那个目标,由此接着调用obj.toString()重临'[object
Object]’字符串,按基本项目标可比艺术,都转变来数字,开采不对等,由此结果是false

三,假若两边都是引用类型(高档项目),则开始展览举行“指针地址”相比较。

3 //重写obj的toString方法

重点-toString()和valueOf()

4 obj.toString() = function(){

过多少人收看那五个点子的首先以为正是,toString()方法将2个对象转化为字符串,valueOf方法将贰个目标转化为数值。

5     return 1;

那种主见很片面,大家透过以下多个例子来看看:

4858美高梅 ,6 }

var obj={
  name:"熊仔其人",
  getName:function(){ return $(this).name; }
};
console.log(obj.toString()); //[object Object]

7 console.log(obj == ‘一’); //结果就为true了

概念多个obj对象,调用它的toString方法,再次回到值是[object
Object],开掘并未有像大家想像的均等重回值其内容的字符串表示。

8 console.log(obj == true); //结果也为true

var arr=[1,2,3];
console.log(arr.valueOf()); //(3) [1, 2, 3] 

复制代码

概念2个数组arr,调用它的valueOf方法,重返值是[1, 2,
3],开掘也未曾像大家想像的①模同样再次回到数值类型的象征。

复制代码

骨子里真的的知道是那般的:调用对象的toString()方法可以将对象转化为字符串,可是一旦要转正为字符串不明确是调用toString方法。

 1 var obj = {

我们再看看上边包车型地铁代码。

 2     valueOf : function(){

var obj= { };   
obj.valueOf=function(){ return 1; }
obj.toString=function(){ return 2; }
console.log(obj==1);  //true
var obj2= { };   
obj2.valueOf=function(){ return 2; }
obj2.toString=function(){ return 1; }
console.log(obj2==1);  //false                                      
var obj3={ };
obj3.valueOf=function(){ return []; }
obj3.toString=function(){ return 1; }
console.log(obj3==1);  //true 

 3         console.log(‘first’);

上述代码中我们定义了一个对象obj,obj二,定义了valueOf和toString方法的重临值,通过与1对比相等,发掘其事先调用了valueOf方法。

 4     },

然后定义了二个对象obj三,定义了valueOf和toString方法的重临值,通过与1相比相等,开采其调用的是toString方法。

 5     toString : function(){

接下来大家看下边1段代码:

 6         console.log(‘second’);

var obj= { };   
obj.valueOf=function(){ return 'a'; }
obj.toString=function(){ return 2; }
console.log(obj=='a');  //true
var obj2= { };   
obj2.valueOf=function(){ return 'b'; }
obj2.toString=function(){ return 'a'; }
console.log(obj2=='a');  //false 

 7     }

上述代码第22中学定义3个对象obj,通过与字符串’a’比较开采其调用的是valueOf方法。

 8 }

然后对象obj二与’a’的比较再次来到false,开采其尚无调用toString方法。

 9 console.log(obj == 1); //结果为 first false

透过大家得以得出结论:

10 

对象转化为轻松类型时会优先调用valueOf方法,若是能够与简短值举办相比较则会一向相比较,此时不再调用toString方法。假如调用valueOf方法后不恐怕与轻巧值进行相比较,则会再调用toString方法,最后获得比对的结果。

11 var obj = {

然而供给注意的少数是Date对象不满足上述的平整,Date对象的toString和valueOf方法都以双重定义过的,暗中同意会调用toString方法。

12     valueOf : function(){

PS:js的双等号隐式调换规则

13         console.log(‘first’);

行使双等号举行相比的时候,当七个操作数类型不均等时,双等号会进行一个隐式调换,调换到同样种类再比较,以下是转变规则,在红宝书P5壹页都能查到。(自个儿三番五次忘记,照旧感觉好记性不比烂笔头,写一写总是影响深远)

14         return null; //或者return undefined

一、有叁个操作数为布尔值,将布尔值调换到数值再拓展比较,false为0,true为壹.

15     },

贰、三个为字符串,另1个为数字。将字符串转换到数值再拓展比较。

16     toString : function(){

三、3个操作符为对象,另三个不是目的,先采纳 valueOf()
获得目标值得类型,再根据其余规则举办比较。

17         console.log(‘second’);

总结

18     }

以上所述是小编给大家介绍的Javascript中双等号(==)隐性调换机制,希望对我们有着帮忙,如若我们有别的疑问请给自身留言,我会及时苏醒大家的。在此也格外谢谢大家对台本之家网址的援助!

19 }

您大概感兴趣的稿子:

  • 详解JavaScript中双等号引起的隐性类型调换

20 console.log(obj == 1); //结果为 first false

21 

22 var obj = {

23     valueOf : function(){

24         console.log(‘first’);

2伍         return {}; //恐怕return别的复合对象

26     },

27     toString : function(){

28         console.log(‘second’);

29     }

30 }

31 console.log(obj == 1); //结果为 first second false

复制代码

 

 

对于undefined和null,ECMAScript规定null==undefined结果为true;在可比等性在此以前,无法将null和undefined调换到别的值。

 

1 console.log(null == undefined); //true

2 console.log(null == 0); //false

3 console.log(0 == undefined); //false

三、四个目标相比较

 

若三个操作数指向同三个目的,则赶回true,不然再次回到false。

 

涉及操作符(<,>)

 

一、两边都以字符串

 

都以字符串时,按字符串对应的字符编码相比

 

1 console.log(‘abc'<‘adc’) //true

2、有一个操作数是数值

 

若有3个操作数是数值,则将另1个转变为数值进行比较

 

1 console.log(‘a’ > 5); //‘a’转变为数值为NaN,结果为false

2 console.log(‘2.3’ > 1); // true

3、有一个操作数是目标

 

调用该目的的valueOf方法,用重回的结果用前面包车型地铁条条框框相比,若未有valueOf方法,则调用toString方法

 

复制代码

 1 var obj = {};

 2 console.log(obj < 5); //false

 3 var obj = {

 4     valueOf: function() {

 5         console.log(‘first’);

 6         return 2;

 7     },

 8     toString: function() {

 9         console.log(‘second’);

10     }

11 }

12 console.log(obj < 5); //first true

复制代码

4、有二个操作数是布尔值

 

将此布尔值调换来数值,再进行比较

 

1 console.log(‘3’ > true); //true

与NaN比较的都将赶回false

 

布尔操作符(!)

 

1、操作数是目的

 

其他对象都回到false

 

1 var obj = {};

2 console.log(!obj); //false

二、操作数是字符串

 

空字符串再次来到true,非空重回false

 

复制代码

1 var a = ‘OK’;

2 var b = ‘  ‘;

3 var c = ”;

4 console.log(!a); //false

5 console.log(!b); //false

6 console.log(!c); //true

复制代码

3、操作数是数值

 

0返回true,非0(包括Infinity)返回false

 

肆、操作数是null,undefined,NaN

 

返回true

 

1 console.log(!null); //true

2 console.log(!NaN); //true

3 console.log(!undefined); //true

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有