Javascript中双等号,近期径直在笔试面试

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

据此有几个常识知识:

1、对于string,number等基础项目,==和===是有分别的
  一)分化档次间比较,==之相比“转化成同1类型后的值”看“值”是不是等于,===假设类型分裂,其结果正是例外
  贰)同体系相比较,直接开始展览“值”对比,两者结果一致

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

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

 

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

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

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

  在Javascript中推断相等关系有双等号(==)和三等号(===)二种。在那之中双等号(==)是值分外,而三等号(===)是严谨相等(值及类型是或不是完全相等)。

据此有多少个常识知识:

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

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

三、基础项目与高级项目,==和===是有分其余
  1)对于==,将高端转化为根基项目,进行“值”相比
  2)因为品种分歧,===结果为false

 

换句话说,双等号(==)在运算的时候会实行类型转变,而三等号(===)则不会。

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

Javascript语言中中国共产党第五次全国代表大会亚湾原子核能发电站心数据类型(原始值,也叫简单数据类型):即 **Undefined、Null、Boolean、Number 和 String

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

前不久直接在笔试面试,平日遭遇举例12三==’1二3’、’abc’==true等题材,在那之中有回答的,也有答错的,主要缘由依旧对ECMAScript的正规未有知道明白,繁多难题从没具体分析所变成。现查阅资料后对此进行部分计算。

型**。由于这么些原始类型并吞的长空是一定的,所以可将她们存款和储蓄在非常小的内部存款和储蓄器区域

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

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

  1.二,两边都以简约类型,类型不相同,则先转移为数字比较(个中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

三,假使两边皆以援引类型(高端项目),则打开实行“指针地址”相比。

 

重点-toString()和valueOf()

有的是人见状那七个章程的第一感到就是,toString()方法将三个对象转化为字符串,valueOf方法将贰个目标转化为数值。

那种主见很片面,我们因此以下八个例子来探望:

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

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

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

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

概念三个数组arr,调用它的valueOf方法,重临值是[1, 2,
3]Javascript中双等号,近期径直在笔试面试。,开采也未曾像大家想象的同壹重返数值类型的代表。

实在确实的明亮是这般的:调用对象的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 

上述代码中大家定义了3个对象obj,obj二,定义了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 

上述代码第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

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

 

2,若是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

三,如若两边都以援引类型(高端项目),则进行进行“指针地址”比较。

 

重点-toString()和valueOf()

不知凡几人收看那三个办法的首先感觉就是,toString()方法将三个目的转化为字符串,valueOf方法将2个对象转化为数值。

那种主张很片面,我们通过以下四个例子来看望:

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,obj贰,定义了valueOf和toString方法的再次回到值,通过与一比较相等,发掘其优先调用了valueOf方法。

下一场定义了3个目的obj3,定义了valueOf和toString方法的重返值,通过与1相比相等,开掘其调用的是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方法。

下一场对象obj2与’a’的比较再次来到false,开采其尚无调用toString方法。

 

经过大家能够得出结论:

目的转化为简易类型时会优先调用valueOf方法,借使得以与简便值实行相比较则会直接比较,此时不再调用toString方法。借使调用valueOf方法后不能与简便值实行比较,则会再调用toString方法,最后获得比对的结果。

然则急需小心的一些是Date对象不满意上述的条条框框,Date对象的toString和valueOf方法都以再一次定义过的,私下认可会调用toString方法。

据此有多少个常识知识:

 

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

等性操作符(==)

  1)不一致种类间比较,==之相比“转化成同壹类型后的值”看“值”是还是不是等于,===借使类型区别,其结果便是见仁见智

 

  二)同品种比较,直接实行“值”相比,两者结果一样

一、相比的体系是String、Number、Boolean那多少个主导项目时

2、对于Array,Object等高端项目,==和===是尚未分别的

 

  进行“指针地址”相比较

当是这几中项目实行相比较时,会先将五头调换来数字,在张开相比较。

3、基础项目与高等项目,==和===是有分其他

 

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

复制代码

  二)因为品种分歧,===结果为false

1 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中动用双等号(==)决断相等的隐性转变机制:

复制代码

一,如若两边都是粗略类型:

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

  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

率先会调用对象的valueOf()方法,期待回到1个主导项目标值(测试为若重返Boolean、Number、String、null、undefined或未有重回值,则将不会接二连三调用toString方法),若再次回到的依然是2个复合对象的话,则调用其toString()方法,若如故未有回到上述基本类型的话,则直接判为不等于。

  1.贰,两边都以简简单单类型,类型差异,则先转移为数字相比较(当中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方面是大致类型,另一面是援引类型(高档项目),则高档项目隐式转变到简单类型再相比较。

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()方法将二个对象转化为字符串,valueOf方法将1个目的转化为数值。

5     return 1;

那种主见很片面,大家通过以下五个例证来看望:

6 }

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

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

概念2个obj对象,调用它的toString方法,再次回到值是[object
Object],开采没有像大家想像的1致再次来到值其剧情的字符串表示。

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

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

复制代码

概念贰个数组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’);

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

 4     },

接下来定义了2个目标obj三,定义了valueOf和toString方法的再次来到值,通过与1比较相等,发现其调用的是toString方法。

 5     toString : function(){

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

 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中学定义一个目的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     },

2、2个为字符串,另3个为数字。将字符串转换到数值再实行相比。

16     toString : function(){

三、3个操作符为对象,另三个不是目的,先选拔 valueOf()
获得目的值得类型,再依照其余规则实行相比较。

17         console.log(‘second’);

总结

18     }

上述所述是小编给我们介绍的Javascript中双等号(==)隐性转变机制,希望对我们具备协助,假诺我们有其余疑问请给自个儿留言,小编会及时还原我们的。在此也13分感激大家对剧本之家网址的支持!

19 }

您或许感兴趣的小说:

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

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

21 

22 var obj = {

23     valueOf : function(){

24         console.log(‘first’);

25         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

3、三个目的比较

 

若七个操作数指向同2个对象,则赶回true,不然重回false。

 

事关操作符(<,>)

 

1、两边都以字符串

 

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

 

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

二、有1个操作数是数值

 

若有一个操作数是数值,则将另一个改造为数值实行相比较

 

一 console.log(‘a’ > 5); //‘a’调换为数值为NaN,结果为false

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

三、有三个操作数是目的

 

调用该对象的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

复制代码

四、有三个操作数是布尔值

 

将此布尔值转变来数值,再开始展览比较

 

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

复制代码

三、操作数是数值

 

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

 

4、操作数是null,undefined,NaN

 

返回true

 

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

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

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

相关文章

发表评论

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

*
*
Website