javascript运算符

javascript运算符

javascript运算符包括:
算数运算符: + - * / % (复合赋值运算 += -= *= /= %=)
自增自减运算符: ++ –
关系运算符: > < >= <= == != === !==
逻辑运算符: && || !
位运算符: ~ & | ^ << >> >>>
对象运算符: in instancesof new delete .和[] ()
其他: ?: typeof ,

发现把一堆运算符放一起，一脸蒙逼的感觉有木有,先别急我们来挑重点详解

    + - * \/ % 加减乘除模,不多说,但注意不同类型的值求值时，会行进隐式转换,例如:
    var str = "13"+14 //等于"1314" (我们常常用+连接一个""来将其他类型的值转为字符串)
    var str = "13"-14 // 等于-1
    var str = "13"*2   //等于26

    ++  -- 自增自减: 有前置和后置 例如：a++ ++a a-- --a ,区别：
            var a = 1 ; 
            var b = a++ ;
            console.log("a="+a,"b="+b); //a=2 b=1

           var a = 1; 
           var b = ++a;
           console.log("a="+a,"b="+b); //a=2 b=2
         总结一句话就是，符号后置先赋值再自增自减 ，符号前置先自增自减再赋值  

    > < >= <= ==  != ===  !==   大于 小于 大于等于  小于等于  等于  不等于  全等  不全等  
            以上不全说，就说说 ==  和 ===  的区别:
            1 == 1  //true
            "1" == 1  //true
            "1" ===  1  //false
            new String('abc') == 'abc' //true
            new String('abc') === 'abc' //false
            undefined == null //true
            undefined === null   //false  
            当两个值进行相等测试时,类型相同时直接进行"值"比较;
            当类型不同时,"=="两边会进行类型转换再比较;而"==="两边得值不会进行类型转换。

            了解了区别之后，我们再来看看"=="进行相等检测时,违反直觉的检测结果:
            0 == ''             // true
            0 == '0'            // true
            '' == '0'           // false

            false == undefined  // false
            false == null       // false
            null == undefined   // true

            false == 'false'    // false
            false == '0'        // true

            看了上面的检测，是不是感觉又凌乱了...
            所以，实际应用中, 使用"=="进行检测时, 一定要考虑到里面存在的隐患与风险

逻辑运算符

    &&  ||  !   与 或 非 ,这几个逻辑运算符，使用频率也很高，这里也只挑重点说： 
    ! 逻辑非,一般用来转换布尔值,不多说,这里我们说说有意思的"&&"和"||",
    也是使用频度非常高的运算符 。说之前，要先知道在逻辑运算中 
    0 "" false NaN  null undefined 都会判定为false，其它都为true,然后请看下面:

    var a = 1 && 2 && 3
    var b = 0 && 1 && 2
    var c = 1 && 2 && 0 
    a b c 输出分别为 3  0  0


    var x = 1 || 2 || 3
    var y = 0 || 2 || 3
    var z = 0 || 0 || 3
    x y z  输出分别为 1  2  3

    怎么理解,在"&&"和"||"中遵循"短路"原理,
    "&&"碰到false就返回,例如: a && b ,如果a为true,直接返回b, 不管b为true或false;
    "||"碰到true就返回,例如: a && b ,如果a为false,直接返回b, 不管b为true或false

    例如zepto.js 中的片段:
    window.$ === undefined && (window.$ = Zepto)

对象运算符

    本节不做单独讲解,将放在其他小节里面使用,并简要说明

其它

    ?:  typeof   三目运算符(又叫三元运算符)    类型检测
        a?b:c  如果a为true则返回b,否则返回c
        例如zepto.js中的片段:
          $.trim = function(str) {
            return str == null ? "" : String.prototype.trim.call(str)
          }
        typeof 我们经常用来做类型检测,例如:
        typeof 6  //返回"number"
        typeof "abc"  //"string"
        typeof true  //"boolean"
        typeof null  //"object"
        typeof undefined   //"undefined"
        例如zepto.js代码片段
        function likeArray(obj) { return typeof obj.length == 'number' }

好了,理解了上面的运算符之后,我们来看看zepto.js片段

    $.fn = {
        attr: function(name, value){
          var result
          return (typeof name == 'string' && !(1 in arguments)) ?
            (!this.length || this[0].nodeType !== 1 ? undefined :
              (!(result = this[0].getAttribute(name)) && name in this[0]) ? this[0][name] : result
            ) :
            this.each(function(idx){
              if (this.nodeType !== 1) return
              if (isObject(name)) for (key in name) setAttribute(this, key, name[key])
              else setAttribute(this, name, funcArg(this, value, idx, this.getAttribute(name)))
            })
        }
    }

怎么样，是不是毫无压力了…开玩笑的，反正我是一脸蒙逼了,这里我们需要了解一下，运算符的优先级,废话不多说，贴一张表，小伙伴们自己分析分析下.

JS运算符优先级（从高到低列出)

运算符	描述
. [] ()	字段访问、数组下标、函数调用以及表达式分组
++ – - ~ ! delete new typeof void	一元运算符、返回数据类型、对象创建、未定义值
/ %	乘法、除法、取模
+	加法、减法、字符串连接
<< >> >>>	移位
< <= > >= instanceof	小于、小于等于、大于、大于等于、instanceof
== != === !==	等于、不等于、严格相等、非严格相等
&	按位与
^	按位异或
|	按位或
&&	逻辑与
||	逻辑或
?:	条件
= oP=	赋值、运算赋值
,	多重求值

以上所有都是自己做的回顾,有什么不妥或错误欢迎指正