运算符

运算符 (operators) 

运算符是发起运算最简单的形式:分很多种: 一元运算符,二元运算符,三元运算符等

运算符归类:

数学运算符,比较运算符,逻辑运算符,赋值运算符,按位运算符,条件三元运算符

1.数学运算符

包含:+ - * / %()   即 加减乘除取余

 计算顺序: 先算小括号,再乘除取余

隐式转换,所有带字符串的运算都会尽可能的转为数字进行计算,加号比较特殊,会连接字符。

注意:number和number 类型的数学运算结果都是number

数学运算中:只有纯字符串、布尔值、null能够进行隐式转换。

 // 隐式转换,就是没有写parseInt和parseFloat 也能帮你转换
         console.log(26-'2'); //24
         console.log(3*'8');   //24
         console.log('3'*'8'); //24
         console.log(48/'2');   //24
          console.log('24' % 55); //24

不纯的字符串和undefined 是不能进行隐式转化,结果都是NaN

  console.log(3*'8天');  // NaN
   console.log(3* undefined); //NaN

加法比较特殊,因为+号同时是加法和连字符的符号,所以加法在面对字符串的时候没有隐式转换。

     console.log(3+'8');// 38
         console.log(3*null); //0
         console.log(3*false); //0
         console.log(3*true);//3
         console.log(3+true);//4
         console.log(3+false);//3

总结:无论哪种运算,只要出现了undefined参与运算,都是NaN

  字符串‘8’、 false、true、null都能隐式转换

   加号特殊,面对字符串‘8’会连接字符

NaN参与运算:得到的结果都是NaN

   console.log(Infinity +1000); //Infinity
         console.log(Infinity-1000); //Infinity
         console.log(Infinity/1000); //Infinity
         console.log(Infinity-Infinity); //NaN
         console.log(Infinity/Infinity); //NaN
         console.log(Infinity*Infinity); //Infinity
         console.log(0/0); //NaN
         console.log(9/0);  //Infinity
         console.log(NaN + 2);// NaN
          console.log(NaN - 2);//NaN
          console.log(NaN * 2); //NaN
          console.log(NaN / 2); //NaN
          console.log(NaN % 2); //NaN

2.比较运算符

比较运算符的正统,都是number 和number的数据运算,比较它的操作数会返回一个Boolean 布尔类型的值。要么是true(真),要么是false(假)。> 大于

< 小于
>= 大于等于
<= 小于等于
== 相等,判断值相等,不判断数据类型
=== 全等,除了判断数值是否相等,还要判断数据类型是否相等
!= 不等,取反,永远与相等判断相反
!== 不全等,取反,永远与全等于判断相反

a.正常情况下,数字与数字进行比较

      console.log(5>6);// false
         console.log(5<6); //true
         console.log(5<=6); //true
         console.log(5>=6);//false
         console.log(5==5);//true
         console.log(5===5);//true
         console.log(5!=5);// false
         console.log(5!===5);//false
         console.log(5=='5'); //true
         console.log(5==='5'); //false
         console.log(5!='5');//false
         console.log(5!=='5')//true

注意:

== 叫做“相等判断”,不会判断类型,它会进行隐式转换

==="全等于",不仅仅比较数值是否相等,还比较数据类型是否相等

!===的反面,如果==运算是true,那么!=false

!=====的反面,如果===运算是true,那么!==false

b.stringstring也能进行比较运算,比较的是字符编码顺序(Unicode)。

 字符编码顺序:0~9    A~Z   a~z   顺序越往后越大

 //string和string也能进行比较运算,比较的是字符编码顺序(Unicode)。
  //字符编码顺序:0~9、A~Z、a~z,顺序越往后比较时越大。
   console.log("a" < "b"); //true
   console.log("A" < "B"); //true
   console.log("A" < "a"); //true
   console.log("1" < "A"); //true
   console.log("blank" < "blue"); //true,一位一位比较,直到比出大小
   console.log("23" < "3"); //true,因为string和string比较,比的不是数字,是字符编码顺序

c.与数字进行比较运算时,纯数字字符串会被转为数字,null转换0false转换0true转换1

console.log(null < 0.0001);  // true
        console.log(null > -0.0001); // true
        console.log(null == 0);      // false,具体原因,后面讲解object介绍
        console.log(false == 0);     //true
        console.log(true == 1);      //true

 d.stringnumber比,string会被隐式转换为number 

非正常情况下:数字与其他数据比较,其他数据比较(除字符串与字符串比较)

'123'-123 , true-1, false-0 ,''-0, undefineds-NaN , 'hello'-NaN

         console.log(1<''); //false
         console.log(1==''); //false;
         console.log(0=='hello');//false
         console.log(0==undefined); //false

e.特殊值参与比较:NaNInfinity

   //  NaN 参与:
         console.log(NaN==NaN); // false
         console.log(NaN===NaN); //false
         console.log(NaN!=NaN);//true
         console.log(NaN<0); //false
         console.log(NaN>=0); //false
         console.log(NaN!==0); //true
    //Infinity 参与,也普通数字:
    console.log(Infinity >100); //true
    console.log(Infinity>=100); //true
    console.log(Infinity<100); //false
    console.log(Infinity<=100); //false
    console.log(Infinity==100);//false
    console.log(Infinity!=100); //true
    // Infinity 与自身比较
    console.log(Infinity>Infinity); //false
    console.log(Infinity==Infinity); //true
    console.log(Infinity >=Infinity); //true
    console.log(Infinity!==Infinity); //false

值得注意的是:3>2>1  分析:3>2 输出的是true, true又是1,1>1  输出结果是false

3.逻辑运算符

逻辑运算符常用于布尔类型值之间,当操作数都是布尔值的时候,返回值也是布尔值。 (计算顺序:非>与>或)

&& 逻辑“与”运算符,交集,两个条件都成立才为真
|| 逻辑“或”运算符,并集
! 逻辑“非”运算符

  短路语法:

短路语法就是将逻辑与、或模拟成电路短路的效果。

非正常情况:布尔类型的值或者其他类型的值进行混合逻辑运算,运算过程中其他的数据类型会隐式转换为布尔类型的值,运算完之后返回值不一定是布尔值,而是对应的位置的某个具体值。

 隐式转换为false假:null0NaN,空字符串("")undefined

隐式转换为true真:除了上面的,全是真。

逻辑与(短路语法)

    //逻辑与,如果a为真,则输出b,  如果a 为假,输出自己本身
          console.log( false && 8); //false
          console.log(null &&8); // null
          console.log(true &&8); // 8
          console.log(12&&13); //13
          console.log(true&&NaN); // NaN
          console.log(undefined &&哈哈); //undefined
          console.log(哈哈&& undefined); //报错

逻辑或(短路语法)

       // 逻辑或 如果a 为真,则输出a,如果a为假,则输出b
          console.log(false || null); // null
          console.log(123 || '哈哈'); //123
          console.log(0||18); //18
          console.log(18||0); //18
          console.log(undefined || NaN); //undefined

4.赋值运算符

赋值运算符必须有变量参与

= 简单的赋值,不需要运算
+= 加等于
-= 减等于
*= 乘等于
/= 除等于
%= 取余等于
++ 每次在原基础上加1
-- 每次在原基础上减1

        var a=1;
        a+=2; // a=a+2;
        console.log(a);//3
        var d=100;
         d%=10//d=d%10
         console.log(d); //0
         var f=10;
         console.log(f++);//10
         console.log(f); //11

 综合运算符的顺序:! ++ --贴身 → 数学运算符 → 比较运算符 → 逻辑运算符 → 赋值运算符

        var a= 3<6 && 7<14;
         console.log(a); //true   原式 true && true =true
         var b=1+2<3+3&&3+4<2*7;
         console.log(b);  // true 原式 true && true
         var c=flase+true &&13;
         console.log(c);  // 原式1&&13=13
原文地址:https://www.cnblogs.com/smivico/p/7715173.html