运算符

运算符也叫操作符
通过运算符可以对一个或多个值进行运算,并获取运算结果
比如：typeof就是运算符，可以来获得一个值的类型，它会将该值的类型以字符串的形式返回
"number" "string" "boolean" "undefined" "object"

一元运算符

• 只需要一个操作数

• 正号

• 正号不会对数字产生任何影响
• 负号
• 负号可以对数字进行符号的取反
• 对于非Number类型的值，它会将先转换为Number，然后再运算
• 可以对一个其他的数据类型使用+,来将其转换为number，它的原理和Number()函数一样

        var a = 123;
        a = +a;
        a = -a;
        
        a = true;
        a = -a;
        
        a = "18";
        a = +a;

二元运算符

• 传递两个及两个以上参数的运算。

算数运算符

• 当对非Number类型的值进行运算时，会将这些值转换为Number然后在运算
• 任何值和NaN做运算都得NaN
• +可以对两个值进行加法运算，并将结果返回,如果对两个字符串进行加法运算，则会做拼串，会将两个字符串拼接为一个字符串，并返回,任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串做拼串的操作

•  - 可以对两个值进行减法运算，并将结果返回
  

• * 可以对两个值进行乘法运算
  

• / 可以对两个值进行除法运算
• % 取模运算（取余数）

var a = 123;
        var result = typeof a;
        // console.log(result);
        // console.log(typeof a);

        result = a + 1;
        result = 456 + 789;
        result = true + 1;
        result = true + false;
        result = 2 + null;
        result = 2 + NaN;
        result = "123" + "456";
        result = "你好" + "小帅哥";
        // console.log(result);

        var str = "锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦";
        // console.log(str);

        result = 123 + "1";
        result = true + "hello";
        // console.log(result);

        //任何值和字符串相加都会转换为字符串，并做拼串操作
        /*
        我们可以利用这一特点，来将一个任意的数据类型转换为String
            我们只需要为任意的数据类型 + 一个 "" 即可将其转换为String
            这是一种隐式的类型转换，由浏览器自动完成，实际上它也是调用String()函数
        */
        var c = 123;
        c = String(c);

        c = null;
        c = c + "";

        // console.log(typeof c);
        // console.log(c);

        c = 123;
        // console.log("c = " + c);

        result = 1 + 2 + "3";//33
        result = "1" + 2 + 3; //123

        result = 100 - 5;//95
        result = 100 - true;//99
        result = 100 - "1";//99

        result = 2 * 2;//4
        result = 2 * "8";
        result = 2 * undefined;//NaN
        result = 2 * null;//0

        result = 4 / 2;//2
        result = 3 / 2;//1.5
        // console.log("result = "+result);

        /*
        任何值做- * /运算时都会自动转换为Number
        我们可以利用这一特点做隐式的类型转换
            可以通过为一个值 -0 *1 /1来将其转换为Number
            原理和Number()函数一样，使用起来更加简单
        */
        var d = "123";
        d = d - 0;
        // console.log(typeof d);
        // console.log(d);

        result = 9 % 3;//0
        result = 9 % 4;//1
        result = 9 % 5;//4

逻辑运算符

• ! 非：取反

    var a = true;
        //对a进行非运算
        a = !a;
        //console.log("a = " + a); -->false

var b = 10;
b = !!b; -->True,两次取反值不变

• && 与

两个值中只要有一个值为false就返回false，只有两个值都为true时，才会返回true.
与”属于短路的与，如果第一个值为false，则不会看第二个值
        //只要有一个false，就返回false
        result = true && false;
        result = false && true;
        result = false && false;
与运算：如果两个值都为true，则返回后边的
        var result = 2 && 1;
        
        //与运算：如果两个值中有false，则返回靠前的false
        //false && true
        result = 0 && 2;
        result = 2 && 0;
        //false &&　false
        result = NaN && 0;
        result = 0 && NaN;

• ||或

 两个值中只要有一个true，就返回true，如果两个值都为false，才返回false
 JS中的“或”属于短路的或，如果第一个值为true，则不会检查第二个值
        result = true || false;
        result = false || true ;
        result = true || true ;
如果第一个值为true，则直接返回第一个值
        result = 2 || 1;
        result = 2 || NaN;
        result = 2 || 0;
        
        //如果第一个值为false，则直接返回第二个值
        result = NaN || 1;
        result = NaN || 0;
        
        result = "" || "hello";
        
        result = -1 || "你好";

赋值运算符

        += 
            a += 5 等价于 a = a + 5
        -=
            a -= 5 等价于 a = a - 5
        *=
            a *= 5 等价于 a = a5
        /=
            a /= 5 等价于 a = a / 5
        %=
            a %= 5 等价于 a = a % 5

关系运算符><>=<=

    a= 5>4//true
    a=5>10//false
    a=5>=4//true
    console.log(1>'0')//true
    console.log(10>null)//true
    console.log(10>'hello')//false 
    //任何值和Nan比较都是false，10和字符串hello比较hello会变成nan
    // 一边数字一边字符从字符串左边第一位开始比较
    a=11<'5'//false
    //两边都是字符串的时候会比较Unicode编码
    a='a'<'b'//true
    a='abc'<'b'//无论几位数都会从左边第一位开始比较
    a='11'<'5'//从左边第一位比较
    a='1194561235'< +'5'//false

    //相等运算符== 全等运算符：不会做类型转换===全等还包括数据类型
    '123'==122//true

    '123'===123//false
    null==undefined//true
    null===undefined//false
    //不全等：!==
    1 != '1'//false
    1 !=='1'//true

相等运算符

• 相等运算符用来比较两个值是否相等，如果相等会返回true，否则返回false

使用 == 来做相等运算
当使用==来比较两个值时，如果值的类型不同，则会自动进行类型转换，将其转换为相同的类型，然后再比较

不相等用来判断两个值是否不相等，如果不相等返回true，否则返回false
使用 != 来做不相等运算
不相等也会对变量进行自动的类型转换，如果转换后相等它也会返回false
        
全等 ===
- 用来判断两个值是否全等，它和相等类似，不同的是它不会做自动的类型转换
如果两个值的类型不同，直接返回false

不全等 !===
用来判断两个值是否不全等，和不等类似，不同的是它不会做自动的类型转换,如果两个值的类型不同，直接返回true

         //console.log(1 == 1); //true
    
    var a = 10;
    
    //console.log(a == 4); //false
    
    //console.log("1" == 1); //true
    
    //console.log(true == "1"); //true
    
    //console.log(null == 0); //false
    
    /*
    undefined 衍生自 null
        所以这两个值做相等判断时，会返回true
     */
    //console.log(undefined == null);//true
    
    /*
    NaN不和任何值相等，包括他本身
     */
    //console.log(NaN == "1"); //false
    //console.log(NaN == "undefined"); //false
    //console.log(NaN == NaN); //false      
    var b = NaN;        
    //判断b的值是否是NaN
    //console.log(b == NaN);//无法判断，只会返回false
    /*
    可以通过isNaN()函数来判断一个值是否是NaN,如果该值是NaN则返回true，否则返回false
     */
    //console.log(isNaN(b)); //true     
    //console.log(10 != 5); //true
    //console.log(10 != 10); //false
    //console.log("abcd" != "abcd"); //false
    //console.log("1" != 1);//false     
    //console.log("123" === 123);//false
    //console.log(null === undefined);//false
    console.log(1 != "1"); //true