JS中的运算符

112 阅读3分钟

JS 运算符分类

  1.算术运算符
          加减乘除  取余(求余数)
                  + - * / %
          注:+ 运算符,相加时如果两边都是数字,那么会运算数学的相加操作
              相加时如果两边有一个不是数字的,比如出现一个字符串,那么运行的不是相加,而是拼接操作
                    拼接操作只会出现在+,其他符号不出现
              其他运算符在遇到两边有非数字类型时,会将其转换为数字(这一步叫做隐性转换),然后再运算
          例:console.log(1 + 1) //先算小括号里的,再运算
              console.log(5 + '0')  
              //数字5 + 字符串'0'  --> 因为加号两边出现了一个非数字类型的字符串,所以会运行两个值的拼接
              console.log(5 - 0)//5
              console.log(5 - '0')  //5   
              //两边出现了一个字符串类型的0,Js会帮助我们将其他类型先转换为数字,然后再运算减法 
              console.log(3 * 4)//12
              console.log(5 * '0')//0
              console.log(6 / 2)//3
              console.log(6 / '2')//3
              console.log(5 % 1)//0
              console.log(6 % '2')//0
              console.log(5 / 0)//Infinity 表明 无穷的意思
              console.log(5 % 0)//NaN

    2.赋值运算符
        =  +=  -=  *=  /=  %=  !=
          += 相当于是“我自身” 加上一个新值,就可以用这个 += 来优化
          例:+=
                var a = 1
                a += 10//a += 10 --->a = a + 10
                console.log(a)//11 
              -=
                var b = 2
                b -= 2//b -= 2  --->b = b - 2 --->b = 0
                console.log(b)//0
              *=
                var c = 2
                c *= 5 //c *= 5 --->c = c * 5
                console.log(c)//10
              /=
                var d = 10
                d /= 2 //d /= 2 --->d = d / 2
                console.log(d)//5

    3.比较运算符
        >  <  >=  <=  ==或===  !=或!==
        比较运算符 比较运算符两边的值之后,返回一个布尔值,也就是返回一个truefalse
        注:在 js 中 = 表示赋值号
        == 和 === 的区别(面试备选题):
                       == 在 js 中判断时会做隐式转换,也就是 说只会对比值是否相等,不回对比数据类型
                       === 在 js 中判断时不会做隐式转换,也就是说,在对比时除了会对比值是否相等,还会判断数据类型
        != 和 !== 的区别:
                  不同点:!== 会对比数据类型
                          != 不会对比数据类型
                  相同点:判断符号两边的值是否不相等,不相等时返回 true ,相等时返回 false
             例:console.log(1 < 5)//true
                console.log(1 <= 1)//true
                console.log(1 == 1)//true
                console.log(999 === 999)//true

                console.log(1 == '1')//true   不会比较数据类型
                console.log(1 === '1')//false  会比较数据类型

                console.log(3 != 3)//false
                console.log(3 != 4)//true

                console.log(3 != '3')//false   不会比较数据类型
                console.log(3 !== '3')//true  会比较数据类型

              
    4.逻辑运算符(非0就为真)
            &&  ||  ! 
              &&  逻辑与(相当于并且的意思)
              ||  逻辑或(相当于或者的意思)
              !   逻辑非(取反,反义词)

             逻辑&&(与)运算符的特性!!!
                      符号左边的值 如果为真(也就是转为布尔值后为true),那么会返回 符号右边的值
                      如果左边的值为假(也就是转为布尔值后为false),那么会将自身返回出去
              逻辑||(或)运算符的特性!!!
                      符号左边的值 为真,那么会将自身返回出去
                                  为假,那么会将符号右侧的值返回出去
              逻辑!(非)运算符的特性!!!
                      语法:!值
                      返回值:将值转换为布尔值后,做一个取反的操作,也就是true改变成falsefalse变成true
            例://&&
                console.log(1 && 100)//100
                console.log(0 && 99)//0
                console.log(true && 'qwer')//qwer
                console.log(false && 'qwer')//false

                //||
                console.log(1 || 100)//1
                console.log(0 || 99)//99

                //!
                console.log(!99)//false
                console.log(!0)//true
                console.log(!true)//false
    5.自增自减运算符
        ++   --
        语法(++ --语法相同):
                    1.++值
                    2.值++

                自增运算符的能力就是将自身的值+1
                自减运算符的能力就是将自身的值-1

                自增自减运算符写法不同,运行结果也不同
                    1.++值(++在前)
                          如果++在前,那么会先将自身的值 +1   然后参与其它
                    2.值++(++在后)
                          如果++在后,那么会先参与周围的运算,然后自身的值+1
           例:var z = 1
               var x = 1

               console.log(++z)//2
               console,log(x++)//1  因为它会先在控制台显示后,再加一