js运算之运算符

一.运算法则

支持以下数学运算：

加法 + ,

减法 - ,

乘法 * ,

除法 / ,

取余 % ,

求幂 ** .

1.重点说明取余

a.取余的运算方法为 a % b 的结果是 a 整除 b 所得 的 余数。

b.为了同时得到除法运算后的整数和余数可以用除法和取余配合使用。

如下代码所示：

        var e=1000
        var f=parseInt(e/60)
        var g=e%60
        console.log(f,g)

e/60本来是16.6666但是用parseint方法可以将结果取整就得到了16。

结果就是商为16余数为40。

同时如果想要将结果连在一起可以再到中间加上一个空的双引号让结果是字符串的形式连在一起。

2.运算优先级问题

a.运算优先级与数学运算法则中规定的一样

b.不过当有字符串参入其中的话要注意两点

1.例一：1+“2”*3+4 运算中并不会因为2加了双引号而直接先和1连接在一起，而是会先与三想乘变成数字类型的6然后再与其它数字进行正常的加法运算。

2.例二：“1”+“2”+3+4当2乘3变成了6之后会因为有一个字符串参加了加法运算而使后面所有的数字全部连在一起。

二.赋值运算符

1.我们知道赋值符号 = 也是一个运算符。但优先级非常低，只有 3 。

这也是为什么，当我们赋值时，比如 x = 2 * 2 + 1 ，所有的计算先执行，然后 = 才执行，

将计算结果存储到 x 。

2.连续赋值两次第二次的会将第一次的进行覆盖。

3.数值交换

        var m=5
        var n=6
        var c
        c=m
        m=n
        n=c
        console.log(m,n)

如上所示给m赋值为5，给n赋值为6

此时想要交换m和n的值可以先声明c但是不给其赋值，后面再让c=m，m=n，n=c就将它们的值相互转换了。

4.原地修改

我们经常需要对一个变量做运算，并将新的结果存储在同一个变量中。

可以用+=，-=，*=，/=，%=

        var d=5
        d+=1
        console.log(d)

        var x=10
        x*=10
        console.log(x)

如上代码所示，第一个运行结果为6。第二个运行结果为100。

三.比较运算符

1.比较运算符遵循比大小原则，符合规定条件的会显示true反之则为false

如下

        var sum=100
        console.log(sum>200)

运行结果即为false

2.相关比较运算符还有

大于 / 小于： a > b ， a < b 。

大于等于 / 小于等于： a >= b ， a <= b 。

检查两个值的相等： a == b ，请注意双等号 == 表示相等性检查，而单等号 a = b 表示赋

值。

检查两个值不相等。 不相等在数学中的符号是 ≠ ，但在 JavaScript 中写成 a != b 。

3.相关注意事项

a.==

用于比较两边的值是否相等，不管数据类型

如1=='1'

两个值是一样的，所以得到true

b.===

比较符号两边的值和数据类型是否都相等

如1=='1'

两个值虽然一样，但是因为数据类型不一样，所以得到false

        var age= "22"
        console.log(age===22)
        console.log(parseInt(age)===22)

如上代码所示因为22用双引号引用起来了所以当用===判断时会因为它的数据类型不同而给出结果为false，但此时可以用第三行代码加上一个parseint方法将字符串类型转换成数字类型，结果就是true了。

c.true==1结果是正确的，但是true===1就是错误的

d.“”==0结果是正确的，但是改成三等于就是false

e.undefined==0是false的，改成三等于也是false

null==0和null>0都是错的，null>=0则是对的。

另一方面， undefined 和 null 在相等性检查 == 中不会进行任何的类型转换，它们有自己独
立的比较规则，所以除了它们之间互等外，不会等于任何其他的值。

f.！=比较符号两边的值是否不等

例1:  1!='1'因为不等于只比较其数值而不比较其数据类型所以运行结果为false。

所以1!=true的运行结果也是false。

        var a=1
        var b=true
        console.log(a!=b)

注意实际应用中可能得到的是一个字符串类型或布尔值，所以运算时要给运算值加上一个parsfloat进行数字类型的转换。但是如果只是判断的话可以用！==来判断。

4.字符串比较

a.在比较字符串的大小时，JavaScript 会使用“字典（dictionary）”或“词典（lexicographical）”顺序
进行判定。
换言之，字符串是按字符（母）逐个进行比较的。

b.1. 首先比较两个字符串的首位字符大小。
2. 如果一方字符较大（或较小），则该字符串大于（或小于）另一个字符串。算法结束。
3. 否则，如果两个字符串的首位字符相等，则继续取出两个字符串各自的后一位字符进行比较。
4. 重复上述步骤进行比较，直到比较完成某字符串的所有字符为止。
5. 如果两个字符串的字符同时用完，那么则判定它们相等，否则未结束（还有未比较的字符）的
字符串更大

四.逻辑运算符

1.&&（与）

a.两个 & 符号表示 && 与运算符：

result = a && b;

在传统的编程中，当两个操作数都是真值时，与运算返回 true ，否则返回 false ：

alert( true && true ); // true
alert( false && true ); // false
alert( true && false ); // false
alert( false && false ); // false

符号左右两边都为真时结果才是真，只要有一边符号是假则全部都是假。

b.用与运算符来找第一个真值的原理

从左到右依次计算操作数。

在处理每一个操作数时，都将其转化为布尔值。如果结果是 false ，就停止计算，并返回这个

操作数的初始值。

如果所有的操作数都被计算过（例如都是真值），则返回最后一个操作数。

换句话说，与运算返回第一个假值，如果没有假值就返回最后一个值。

上面的规则和或运算很像。区别就是与运算返回第一个假值，而或运算返回第一个真值。

例如

// 如果第一个操作数是真值，
// 与运算返回第二个操作数：
alert( 1 && 0 ); // 0
alert( 1 && 5 ); // 5
// 如果第一个操作数是假值，
// 与运算将直接返回它。第二个操作数会被忽略
alert( null && 5 ); // null
alert( 0 && "no matter what" ); // 0

c.&&还可以保证对数据类型转换的安全进行

如

        var y
        console.log(y.tostring())

可以知道假如获取到的值为一个未被定义的值，此时用tostring去进行转换就会导致报错还会导致后面的代码无法再继续运行。但是可以用与运算符来加上一层保险。

如

        var y
        console.log(y && y.tostring())

此时用与将y转为布尔值后发现其是未定义的不能转换，此时与符号就只会运算到y就停止并输出y而不会继续后面的运算而导致报错。

2.||（或）

a.两个竖线符号表示“或”运算符：

result = a || b ;

在传统的编程中，逻辑或仅能够操作布尔值。如果参与运算的任意一个参数为 true ，返回的结

果就为 true ，否则返回 false 。

alert( true || true ); // true
alert( false || true ); // true
alert( true || false ); // true
alert( false || false ); // false

或类型和与类型是相反的，只要左右两边的符号有一个是真的就全是真的，反之则全是假的。

b.用或运算符来找第一个真值的原理

或运算符 || 做了如下的事情：

从左到右依次计算操作数。

处理每一个操作数时，都将其转化为布尔值。如果结果是 true ，就停止计算，返回这个操作

数的初始值。

如果所有的操作数都被计算过（也就是，转换结果都是 false ），则返回最后一个操作数。

返回的值是操作数的初始形式，不会做布尔转换。

换句话说，一个或运算 || 的链，将返回第一个真值，如果不存在真值，就返回该链的最后一个

值。

alert( 1 || 0 ); // 1（1 是真值）
alert( null || 1 ); // 1（1 是第一个真值）
alert( null || 0 || 1 ); // 1（第一个真值）
alert( undefined || null || 0 ); // 0（都是假值，返回最后一个值）

c.应用

获取变量列表或者表达式中的第一个真值。
例如，我们有变量 firstName 、 lastName 和 nickName ，都是可选的（即可以是
undefined，也可以是假值）。

我们用或运算 || 来选择有数据的那一个，并显示出来（如果没有设置，则用

"Anonymous" ）：

let firstName = "";
let lastName = "";
let nickName = "SuperCoder";
alert( firstName || lastName || nickName || "Anonymous"); // SuperCoder

如果所有变量的值都为假，结果就是 "Anonymous" 。

d.或在实际中的应用

如在访问别人空间时如果没有留言就会显示“这个家伙很懒”反之则是留言内容。可以用如下代码实现。

        var z=""
        document.write(z||"这个家伙很懒，什么也没留下。")

因为z的赋值为空字符串所以用或是不能将其转换为布尔值，则会继续往后面转换第二个，发现不是空字符串，所以转换为布尔值后为true并输出。 

 3.注意

4.!（非） 

a.运算原理

1. 将操作数转化为布尔类型： true/false 。

2. 返回相反的值。

例如

alert( !true ); // false
alert( !0 ); // true

b.两个非运算 !! 有时候用来将某个值转化为布尔类型

第一个！将数据类型转换成布尔值并取反，第二个！再次取反。就变成了实际的布尔类型了。

c.与运算、或运算串联的结果  

alert( null || 2 && 3 || 4 );

与运算 && 的优先级比 || 高，所以它第一个被执行。

结果是 2 && 3 = 3 ，所以表达式变成了：

null || 3 || 4

现在的结果就是第一个真值： 3 。

 五.自增自减运算符

1.自增 ++ 将变量与 1 相加：

a.后置自增：

        var b=10
        console.log(b++)

会返回11，并把b的值变成11。 

注意

当运算符置于变量后，被称为“后置形式”： counter++ 。

当运算符置于变量前，被称为“前置形式”： ++counter 。

b.前置自增

        //前置自增
        var a=10
        console.log(++a)

会先返回10，然后把a的值变成11。 

c.练习

        //练习
        var n=10
        var res=++n + n++ + ++n
        console.log(n,res)

第一个++n的值为11，后面n++的返回值为11，但是会将n的值变为12去进行第三步计算得到13

所以和为11+11+13等于35。

2.自减 -- 将变量与 1 相减：

 相关运算和前面的自增型相同，在此不再赘述。

3.注意：

++/-- 运算符同样可以在表达式内部使用。它们的优先级比绝大部分的算数运算符要高。  

虽然运算是从左往右运行，如

let counter = 1;
alert( 2 * counter++ ); // 2，因为 counter++ 返回的是“旧值”

 但是因为自增自减的优先级更高，所以会先自增自减再进行乘法运算。

六.条件运算符‘ ？’

1.解释：

这个运算符通过问号 ? 表示。有时它被称为三元运算符，被称为 “ 三元 ” 是因为该运算符中有三个

操作数。实际上它是 JavaScript 中唯一一个有这么多操作数的运算符。

2.三元运算：就是是用两个符号组成一个语句 

a.语法：条件？条件为true的时候执行，：条件为false的时候执行

let result = condition ? value1 : value2;

计算条件结果，如果结果为真，则返回 value1 ，否则返回 value2 。

b.实际场景应用：购物优惠

        //满200减10 满100减5
        var sum=200
        var youhuisum=sum>200?sum-10:(sum>100?sum-5:sum)
        document.write(youhuisum)

后面用括号括起来是为了保证其作为一个整体优先进行运算。