By

文章目录
  1. 1. JavaScript系列——操作符
    1. 1.1. 一元操作符
    2. 1.2. 位操作符
    3. 1.3. 布尔操作符
      1. 1.3.1. 逻辑非
      2. 1.3.2. 逻辑与
      3. 1.3.3. 逻辑或
    4. 1.4. 加和减操作符
      1. 1.4.1. 加法
      2. 1.4.2. 减法
    5. 1.5. 相等操作符
    6. 1.6. 逗号操作符

JavaScript系列——操作符

一元操作符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
var s1 = "2"; 
var s2 = "z"; 
var b = false; 
var f = 1.1; 
var o = {  
    valueOf: function() { 
        return -1; 
    } 
}; 
s1++;     // 值变成数值 3   --先转为数值类型
s2++;     // 值变成 NaN   
b++;      // 值变成数值 1   --false先转为0，true先转为1
f--;      // 值变成 0.10000000000000009（由于浮点舍入错误所致）  --执行-1
o--;      // 值变成数值-2  --调用valueOf方法 返回为数值就-1，其他按上面的规则


var s1 = "01"; 
var s2 = "1.1"; 
var s3 = "z"; 
var b = false; 
var f = 1.1; 
var o = { 
    valueOf: function() { 
        return -1; 
    } 
}; 
 
s1 = +s1;      // 值变成数值 1 
s2 = +s2;      // 值变成数值 1.1 
s3 = +s3;      // 值变成 NaN 
b = +b;        // 值变成数值 0 
f = +f;        // 值未变，仍然是 1.1 
o = +o;        // 值变成数值-1 

s1 = -s1;         // 值变成了数值-1 
s2 = -s2;         // 值变成了数值-1.1 
s3 = -s3;         // 值变成了 NaN 
b = -b;           // 值变成了数值 0 
f = -f;           // 变成了-1.1 
o = -o;           // 值变成了数值 1

位操作符

ECMAScript 中的所有数值都以 IEEE-754 64 位格式存储，但位操作符并不直接操作 64 位的值。而是先将 64 位的值转换成 32 位的整数，然后执行操作，最后再将结果转换回 64 位。对于有符号的整数，32 位中的前 31 位用于表示整数的值。第 32 位用于表示数值的符号：0 表示正数，1 表示负数。

负数同样以二进制码存储，但使用的格式是二进制补码。计算一个数值的二进制补码，需要经过下列 3 个步骤： 
(1) 求这个数值绝对值的二进制码（例如，要求18 的二进制补码，先求 18 的二进制码）； 
(2) 求二进制反码，即将 0 替换为 1，将 1 替换为 0； 
(3) 得到的二进制反码加 1。 
要根据这 3 个步骤求得18 的二进制码，首先就要求得 18 的二进制码，即： 
0000 0000 0000 0000 0000 0000 0001 0010 
然后，求其二进制反码，即 0 和 1 互换： 
1111 1111 1111 1111 1111 1111 1110 1101 
最后，二进制反码加 1： 
1111 1111 1111 1111 1111 1111 1110 1101  + 1=1111 1111 1111 1111 1111 1111 1110 1110
这样，就求得了18 的二进制表示，即 11111111111111111111111111101110

布尔操作符

逻辑非

1
2
3
4
5
6
7
8
9
10
11
12
13
14
alert(!false);         // true 
alert(!"blue");        // false 
alert(!0);             // true 
alert(!NaN);           // true 
alert(!null);          // true 
alert(!undefined);     // true 
alert(!"");            // true 
alert(!12345);         // false

alert(!!"blue");      //true 
alert(!!0);           //false 
alert(!!NaN);         //false 
alert(!!"");          //false 
alert(!!12345);       //true

逻辑与

如果2个操作数都是布尔类型，就按照惯例得到返回值，如果2个操作数不是布尔类型，则遵循以下规则：
1.如果第一个操作数是对象，则返回第二个操作数； 
2.如果第二个操作数是对象，则只有在第一个操作数的求值结果为  true 的情况下才会返回该 
对象； 
3.如果两个操作数都是对象，则返回第二个操作数； 
4.如果有一个操作数是 null，则返回 null； 
5.如果有一个操作数是 NaN，则返回 NaN； 
6.如果有一个操作数是 undefined，则返回 undefined。
逻辑与操作属于短路操作，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值。

逻辑或

与逻辑与操作相似，如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值；此时，它遵循下
列规则： 
1.如果第一个操作数是对象，则返回第一个操作数； 
2.如果第一个操作数的求值结果为 false，则返回第二个操作数； 
3.如果两个操作数都是对象，则返回第一个操作数； 
4.如果两个操作数都是 null，则返回 null； 
5.如果两个操作数都是 NaN，则返回 NaN； 
6.如果两个操作数都是 undefined，则返回 undefined。 
与逻辑与操作符相似，逻辑或操作符也是短路操作符。

加和减操作符

加法

1
2
3
4
var result1 = 5 + 5;       // 两个数值相加 
alert(result1);            // 10 
var result2 = 5 + "5";     // 一个数值和一个字符串相加 
alert(result2);            // "55"
如果有一个操作数是对象、数值或布尔值，则调用它们的 toString()方法取得相应的字符串值，
然后再应用前面关于字符串的规则。对于 undefined 和 null，则分别调用 String()函数并取得字符
串"undefined"和"null"

减法

如果有一个操作数是字符串、布尔值、null 或 undefined，则先在后台调用 Number()函数将
其转换为数值，然后再根据前面的规则执行减法计算。如果转换的结果是  NaN，则减法的结果
就是 NaN；
如果有一个操作数是对象，则调用对象的 valueOf()方法以取得表示该对象的数值。如果得到
的值是 NaN，则减法的结果就是 NaN。如果对象没有 valueOf()方法，则调用其 toString()
方法并将得到的字符串转换为数值。

1
2
3
4
5
6
7
8
var result1 = 5 - true;    // 4，因为 true 被转换成了 1 
var result2 = NaN - 1;     // NaN 
var result3 = 5 - 3;       // 2 
var result4 = 5 - "";      // 5，因为"" 被转换成了 0 
var result5 = 5 - "2";     // 3，因为"2"被转换成了 2 
var result6 = 5 - null;    // 5，因为 null 被转换成了 0 

var result = "23" < "3";    //true

相等操作符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
null == undefined   //true  
true == 1           //true 
"NaN" == NaN        //false  
true == 2           //false 
5 == NaN            //false  
undefined == 0      //false 
NaN == NaN          //false  
null == 0           //false 
NaN != NaN          //true  
"5"==5              //true 
false == 0          //true 

var result1 = ("55" == 55);    //true，因为转换后相等 
var result2 = ("55" === 55);   //false，因为不同的数据类型不相等

var result1 = ("55" != 55);     //false，因为转换后相等 
var result2 = ("55" !== 55);    //true，因为不同的数据类型不相等

逗号操作符

1
2
var num1=1, num2=2, num3=3;
var num = (5, 1, 4, 8, 0); // num 的值为 0
文章目录
  1. 1. JavaScript系列——操作符
    1. 1.1. 一元操作符
    2. 1.2. 位操作符
    3. 1.3. 布尔操作符
      1. 1.3.1. 逻辑非
      2. 1.3.2. 逻辑与
      3. 1.3.3. 逻辑或
    4. 1.4. 加和减操作符
      1. 1.4.1. 加法
      2. 1.4.2. 减法
    5. 1.5. 相等操作符
    6. 1.6. 逗号操作符