了解运算符

三元运算符（三目）

条件 ？ 条件是true返回的结果 ： 条件是false时返回的结果

 var max=3>4 ? 3 : 4;
 var i=1;
 var s=--i ? i++ : ++i;
  //var s --1 ? 1++ : ++1
 console.log(s); //1

  var  a=6,
       b=5,
       c=5;
  var max=a>b ? (a>c ? a : (c>b ? c : b)) : b>c ? b : (c>a ? c : a);
 //  max= 6>5  (5>5 ?  6 : (5>5 ? 5 : 5)) : 5>5 ? 5 :(5>6 ?  5 : 6)
        console.log(max); //6


  var s=3>5 ? false : true;//返回布尔值的三元运算时，不用些三元方式
        var s=3>5;
        var obj= s ? s : 5;//判断一个值是否存在，如果不存在重新赋值，或
        var obj=s || 5;
   var s= s===0 ? 0 : 5;//判断是否是0 如果不是0，就返回另一个值，与
        var s= s && 5

 > < >= <= == === != !==
   var a="aa";
   var b="ab";
   console.log(b>a);//判断字符串大小时先判断字符串首字符的ascii 或者 Unicode码值,如果相同判断后面字符的比较结果


console.log(true>false);//隐式转换为数值
console.log(true>"");
console.log("a">1);//字符串与数值比较时，字符串转换为数值再比较
console.log(undefined>null);

console.log("1"==1);//true
console.log(""==0);//true
console.log(0==false);//true
console.log(""==false);//true
0==""== false
undefined==null
console.log(undefined==null);// true判读空的结果是否相同  

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

NaN永远不和任何内容相等，包括NaN

    var a="a";
    if(a==NaN){
        判断a是否是NaN
        isNaN()里面的内容会自动隐式转换为数值
    if(isNaN(a)){
        console.log("非数值");
    }
  var obj={a:1};
        var obj1={a:1};
        console.log(obj==obj1);//flase
        // 引用地址不同
        console.log([]==[]);//flase

!= 不相等
        console.log(0!=null);//true
        console.log([]!=[]);//true

&& 与 || 或 ！非

1）&& 与 一假即假 遇到第一个条件为假，则停止后续的判断，返回其假值，否则则一直运行到最后，若最后一个条件为真，则返回该值 2）|| 或
一真即真 遇到第一个条件为真，则停止后续的判断，返回其真值，否则则一直运行到最后，若最后一个条件为假，则返回该值 3）！非 取反

true && true =true;
true && false =false;
false && true =false;
false && false =false;

true || true =true;
true || false =true;
false || true =true;
false || false =false;

var a=1;
a=a-- && ++a;
s=--a && ++a;
a=a++ && --a;
console.log(s,a); //0，0
  && 运算的两端，如果有一端转换为布尔值是false，就把这个值返回出去（值是什么就返回什么，不是返回false）
  如果两端转换为布尔值都是true，就返回&&运算符右侧的值，先运行左侧再运行右侧
  如果左侧运算的结果是false，直接返回左侧值，不运算右侧

var a=1;
a=--a || a++;
a=a-- || a++;
如果||的左侧的结果是ture，就直接返回左侧，不运算右侧，熔断
console.log(a); //-1

  var obj;
  obj=obj || {};
  var obj1={};
  //如果obj是"" 0  false undefined null NaN这种写法就可以进入条件
 if(!obj){
 if(obj==null){
    if(obj===null){
         obj={};
    }
//!取反值，先将内容转换为布尔值，然后去反值
  console.log(!10);//false
  console.log(!"");//true
//所有！运算符得到的结果都是布尔值
  console.log(!obj1); 
  console.log(obj==!obj1);
  console.log(![]==[]);//true
  console.log([]==[]);//false

isNaN（） 用来判断是不是非数值
返回值 true => 非数值
false => 数值

=== 会判断数据的值和类型，必须完全相同才为true ！==（绝对不等） 和 === 都不会隐式转换 位运算 位非运算 ~ 加1取负

console.log(~3);//-4

位与运算  &
console.log(5&6);//4
位或运算 |
console.log(7|6);//7

位异或运算 ^ (转为进制然后计算) 参加运算的两个数据，按二进制位进行“异或”运算。 运算规则：0^0=0； 0^1=1；
1^0=1； 1^1=0； 即：参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。 注：
交换律：A^B=BA 结合律：A^BC=A^(BC)=(A^B)C 自反律：A^BB=A^0=A X^X=0 ,X^0=X
“异或运算”的特殊作用： （1）使特定位翻转 找一个数，对应X要翻转的各位，该数的对应位为1，其余位为零，此数与X对应位异或即可。
例：X=10101110，使X低4位翻转，用X ^ 0000 1111 = 1010 0001即可得到。 （2）与0相异或，保留原值 ，X
^ 0000 0000 = 1010 1110。 从上面的例题可以清楚的看到这一点。

var pass=7856;
var key=2534;
var value=pass^key;
console.log(pass^key); //5974
console.log(value^key); //7856

<<左移位   >>右移位
console.log(24>>2);
11000>>2 ==> 110
8<<2 100000==>32

1<<n   求2的多少次幂

console.log(1<<5);
console.log( (0x0000FF<<16).toString(16))

赋值运算符

   var a=3;
    a+=5;//a=a+5;
    a+="";//快速转换字符串
    
        var a=3;
        // a+=5;//a=a+5;
        // a+="";//快速转换字符串

        // a*=3;
        // a/=3;
        // a%=2;
        // a-=2;
        // 赋值运算符也是有结果的
        var s=a+=2;  //a=a+2  
        console.log(s,a);  //5,5
        if(a-=2){
            console.log("a");2
        }

一元运算符

 var a="3";
 a++;//a=a+1
 a+=1;//31
 a++;//一元运算符强制将值转换为数值+1
 var a=3;
 console.log(a+=1);// a=a+1 a->返回结果  //4
 console.log(a++);// a->返回出来  a=a+1;   //3
 console.log(++a);//a=a+1 a->返回结果  //4
 a++和++a a的结果相同 返回结果不同
 
 var x=1;
 x=2-3-4-5
 1+2+2+3+4
 var y=x++ + x + x++ + x++ + x++;
 var y=x + ++x + x++ +x++ + x++;
 console.log(y,x); //-23，-2

算术运算符

强类型 弱类型
强类型 可以改变变量的值，但是不能改变变量的类型
弱类型 可以改变变量的值和类型
编译型语言 解释型语言
将代码转换为计算机机器语言，这个过程就叫做编译。先编译再运行，这就是编译型语言
边运行边解释，解释为计算机机器语言
js是解释型语言，也是弱类型语言

字符相加 隐式转换 多种数据类型不同时进行运算需要将这些数据转换为相同类型才能运算，这个过程就是隐式转换

var a="a";
        var b=3;
        // var b=true;
        console.log(a+b); //a3

遇到字符串相加时，另一种数据隐式转换为字符型.String()
var s=10;
        s=s+"";
        console.log(s);
        等号是赋值，因此先运算等号右边的结果，然后赋值给等号左边

布尔值相加，不包含加字符
布尔值转换为数值，除字符外所有内容都是隐式 转换为数值运算 Number() 任何数值加NaN都为NaN Object 对象相加时都会转换为字符串相加

   var a={a:1};
        var b={b:1};
        console.log(a+b); //[object Object][object Object]

var arr=[1,2,3];//数组转换为字符串时是将数组的元素转换为字符串相连
        var a={a:1};
        console.log(arr+a);//1,2,3

减法 乘法 除法 取模都遵循转换为数值运算

   var a=true;//1
    // var b=false;//0
    var b="5";
    // var b;
    // var b=null;
    // var b={a:1};
          console.log(a*b);//5

最后

以上就是完美眼睛为你收集整理的了解运算符的全部内容，希望文章能够帮你解决了解运算符所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。