标签：

JavaScript描述了一组用于操作数据值的操作符，包括算数操作符、位操作符、关系操作符等。JavaScript中的操作符不同之处在于，它们能够适用于很多类型的值。

一、一元操作符

只能操作一个值得操作符叫做一元操作符。

1.前置递增递减操作符

递增有两种类型：前置性和后置型。前置型位于操作的变量之前，先执行值的变化然后求值。

var age1 = 18;
var age2 = ++age1 + 2;
alert(age1);    // 19
alert(age2);    // 21

对于age1而言，由于前置递增的结果，age1的值加1结果为19，而age2,这是由于age2等于age1的值前置递增之后然后加2，由于先执行加法操作，age1的值变为19，然后再加2的结果就是21。

前置递减结果也是类似的，先执行减法运算，然后再求值。

var age1 = 18;
var age2 = --age1 + 2;
alert(age1);    // 17
alert(age2);    // 19

对于age1,经过前置递减--age1减1值为17。对于age2而言，由于age1的值经过前置递减后变为17，然后再加2，age2的值就是19。

2.后置递增递减操作符

递减也有两种类型：前置型和后置型。与前置型操作符的不同之处在于，后置型位于操作的变量之后，先执行求值然后执行值的变化。

var age1 = 18;
var age2 = age1++ + 2;
alert(age1);    // 19
alert(age2);    // 20

对于age1而言，由于后置递增的结果，age1的值加1结果为19，而对于age2，由于age1先执行取值18，然后再加2，所以结果就是20。

后置递减类似，先执行取值，然后再执行减法运算。

var age1 = 18;
var age2 = age1-- + 2;
alert(age1);    // 17
alert(age2);    // 20

age1由于后置递减，值减1变为17。而对于age2而言，由于age1先执行取值18，然后再加2，结果就为20。

这4个操作符不仅适用整数，还可以用于字符串、布尔值、浮点数和对象。递增、递减操作符遵循以下规则：

• 应用于一个包含有效数字的字符串时，先将其转换为数字，再执行加减1的操作。字符串变量变成数值变量。
• 应用于一个不包含有效数字的字符串时，将变量的值设为NaN。字符串变量变成数值变量。
• 应用于布尔值时，先将true/false转换成1/0,然后执行加减1的操作。布尔值变量变成数值变量。

• 应用于浮点数时，先调用valueOf()方法以取得一个可供操作的值。然后对该值应用前述规则。如果结果是NaN,则调用toString()方法后再应用前述规则。对象变量变成数值变量。

  var str1 = "9";
  var str2 = "abc";
  var b = false;
  var f = 1.1;
  var obj = {
      valueOf : function() {
          return 0;
      }   
  };
  str1++;     // 数值10
  str2++;     // NaN
  b++;        // 1
  f--;            // 0.1000000000000009
  obj--;      // -1

3.一元加、减操作符

一元加、减操作符主要用于算数运算,对于非数值类型，也可用于数值转换。

一元加操作符放在数值前不会对数值产生任何影响。

var num = 9;
num = +num; // 值仍然为9，相当于添加了一个正号

对于非数值，一元加操作符会像Number()转型函数一样对这个值执行转换。例如：

var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1;
var obj = {
    valueOf : function() {
        return -1;
    }
};
s1 = +s1;   // 1
s2 = +s2;   // 1.1
s3 = +s3;   // NaN
b = +b;     // 0
f = +f;     // 1.1
obj = +obj; // -1

一元减操作符主要用于表示负数。

var num = 9;
num = -num;     // -9

将一元减操作符应用于非数值时，会遵循与一元加操作符相同的规则：

var s1 = "01";
var s2 = "1.1";
var s3 = "abc";
var b = false;
var f = 1.1;
var obj = {
    valueOf :function(){
        return -1;
    }
};

s1 = -s1;   // -1
s2 = -s2;   // -1.1
s3 = -s3;   // NaN
b = -b;     // 0
f = -f;     // -1.1
obj = -obj; // 1

二、位操作符

位操作符是按内存中表示数值的位来操作数值。

1.按位非(NOT)

按位非操作由一个波浪线(~)表示，执行按位非的结果就是返回数值的反码。

var num1 = 5;       // 0000000000000000000000000001001
var num2 = ~num1;   // 1111111111111111111111111111110
alert(num2);        // -6

对5执行按位非操作，结果为-6。这也验证了按位非操作的本质：操作数的负值减1。

2.按位与(AND)

按位与有一个和号字符(&)表示，只有在两个数值对应位都是1才返回1，否则返回0。

var r = 2 & 3;
alert(r);   // 2， 10 & 11 = 10

3.按位或(OR)

按位或操作符有一个竖线符号(|)表示，只要在两个数对应位有一个为1就返回1，两个位都为0时才返回0。

var r = 2 | 5;
alert(r);   // 7,010 | 101 = 111

4.按位异或(XOR)

按位异或操作符有一个插入符号(^)表示，当两个数对应位不同时返回1，两个位上都为1或0时，返回0。

var r = 3 ^ 5;
alert(r);   // 6,011 ^ 101 = 110

5.左移

左移操作由两个小于号(<<)表示，这个操作符会将数值的所有位向左移动指定的位数。例如：

var n1 = 3; // 二进制11
var n2 = n1 << 5;   // 二进制1100000，十进制96

在向左移位后，原数值的右侧多出5个空位。左移操作会以0来填充这些空位，左移不会影响操作数的符号位，左移1位相当于乘以2。

6.有符号的右移

有符号的右移由两个大于号(>>)表示。这个操作数会将所有数值位向右移动，但保留符号位。有符号的右移1位相当于除以2。

var n1 = 64;
var n2 >> 6；    // 等于二进制10，即十进制2

移位过程中，原数值中出现空位在符号位和数值位中间，JavaScript会用符号位填充。

7.无符号右移

无符号右移由3个大于号(>>>)表示。数值的所有位都会向右移动指定的位数。对于整数来说，无符号右移和有符号右移结果相同。

var n1 = 64;
var n2 >>> 6；   // 等于二进制10，即十进制2

但是对于负数来说，情况就不一样了。首先，无符号右移是以0来填充。其次，无符号右移会把负数的二进制码当成正数的二进制码。

var n1 = -64    ;   // 等于二进制11111111111111111111111111000000
var n2 = n1 >>> 5;  // 等于十进制134217726

这里n2的结果是将n1的二进制11111111111111111111111111000000当成整数的二进制，换算成十进制是4294967232。然后再把这个值右移5位，结果变成1111111111111111111110，即十进制134217726。

三、布尔操作符

布尔操作符一共有3个：非(！)、与(&&)、或(||)。

1.逻辑非

与其他编程语言不同，在JavaScript中，无论是什么数据类型，都会返回一个布尔值。逻辑非首先将操作数转换为布尔值，然后再求反。逻辑非操作符遵循下列规则：

• 如果操作数是对象，返回false
• 如果操作数是空字符串，返回true
• 如果操作数是非空字符串，返回false
• 如果操作数是数值0，返回true
• 如果操作数是任意非0数值，返回false
• 如果操作数是null，返回true
• 如果操作数是NaN，返回true
• 如果操作数是undefined，返回true

下面几个例子展示上述规则：

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

逻辑非也可将一个值转换为对应的布尔值。同时使用两个逻辑非操作符，实际上就会模拟Boolean()转型函数的行为。第一个逻辑非操作会基于无论什么操作数返回一个布尔值，二第二个逻辑非操作则对该布尔值求反，于是得到了这个值真正对应的布尔值。结果与Boolean()相同。

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

2.逻辑与

逻辑与用“&&”表示。有两个操作数，形式为：

var result = exp1 && exp2;

exp1、exp2既可以是数值，也可以是表达式。只有exp1和exp2都为true时返回结果为true，否则返回false。

逻辑与也可以应用于任何类型。在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值；它遵循以下规则：

• 如果第一个操作数是对象，则返回第二个操作数
• 如果第二个操作数是对象，则只有在第一个操作数的求值结果为true的情况下才会返回该对象
• 如果两个操作数都是对象，则返回第二个操作数
• 如果有一个操作数是null，则返回null
• 如果有一个操作数是NaN,则返回NaN
• 如果有一个操作数是undefined，则返回undefined

逻辑与操作属于短路操作，即如果第一个操作数能够决定结果，就不会对第二个操作数求值。也就是说，如果第一个操作数是false，第二个操作数(表达式)就不会执行了。

3.逻辑或

逻辑或由“||”表示，有两个操作数，形式为：

var result = exp1 || exp2;

当两个操作数中有一个为true时，结果就为true，当两个都为false时，才返回false。

与逻辑与相似，逻辑或也能应用于布尔值；此时，它遵循下列规则：

• 如果第一个操作数是对象，则返回第一个操作数
• 如果第一个操作数的求值结果为false，则返回第二个操作数
• 如果两个操作数都是对象，则返回第一个操作数
• 如果两个操作数都是null，则返回null
• 如果两个操作数都是NaN，则返回NaN
• 如果两个操作数都是undefined，则返回undefined

逻辑或同样也是短路操作符。如果第一个操作数为true，就不会对第二个操作数求值，结果返回true。

四、乘性操作符

JavaScript中定义了3个乘性操作符：乘法、除法和求模。与其他语言不同的是，在操作非数值的情况下会自动执行类型转换。如果某个操作数不是数值，后台会先使用Number()将其转换为数值。

1.乘法

乘法操作符由一个星号(*)表示，用于计算两个数值的乘积。

var result = 12 *23;

在处理特殊值的情况下，乘法操作符遵循下列特殊的规则：

• 如果操作数都是数值，则执行常规的乘法运算。如果乘积超过了JavaScript数值的表示范围，则返回Infinity或-Infinity
• 如果一个操作数是NaN,则结果为NaN
• 如果是Infinity与0相乘，则结果是NaN
• 如果是Infinity与非0数值相乘，则结果是Infinity或-Infinity,取决于有符号操作数的符号
• 如果是Infinity与Infinity相乘，则结果是Infinity
• 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后再应用上面的规则。

2.除法

除法操作符由斜线符号(/)表示。形式为：

var result = 6 / 3;

与乘法操作符类似，除法操作符对特殊值的处理规则如下：

• 如果操作符都是数值，执行常规的除法计算。如果结果超过了JavaScript数值的表示范围，则返回Infinity或-Infinity
• 如果有一个操作数是NaN，则结果是NaN
• 如果是Infinity被Infinity除，则结果是NaN
• 如果是零被零除，则结果为NaN
• 如果非零的有限数被零除，结果为Infinity或-Infinity
• 如果是Infinity被任何非零数值除，则结果是Infinity或-Infinity
• 如果有一个操作数不是数值，则在后台调用Number()将其转换为数值，然后应用上面的规则

3.求模

求模即求余数。用百分号(%)表示,用法：

var result = 7 % 3; // 1

求模操作符处理特殊值时，遵循以下规则：

• 如果操作数都是数值，执行常规的除法计算，返回除得的余数
• 如果被除数是无穷大值而除数是有限大的数值，则结果是NaN
• 如果被除数是有限大的数值而除数是零，则结果为NaN
• 如果是Infinity被Infinity除，则结果是NaN
• 如果被除数是有限的数值而除数是无穷大的数值，则结果是被除数
• 如果被除数是零，则结果是零
• 如果有一个操作数不是数值，则调用Number()将其转换为数值，然后应用上面的规则

五、加性操作符

与乘性操作符相似，加性操作符也会在后台转换不同的数据类型。

1.加法

加法操作符的使用形式如下：

var result = 1 + 2;

如果两个操作符都是数值，执行常规的加法计算，然后根据如下规则返回结果：

• 如果有一个操作数是NaN，则结果是NaN
• Infinity加Infinity，则结果是Infinity
• -Infinity加-Infinity，则结果是-Infinity
• Infinity加-Infinity，则结果是NaN
• +0加+0，结果是+0
• -0加-0，结果是-0
• +0加-0，结果是+0

如果有一个操作数是字符串，规则如下：

• 两个操作数都是字符串，则将第二个操作数与第一个操作数拼接起来
• 只有一个操作数是字符串，则将另一个操作数转换为字符串，然后再将两个字符串拼接起来

如果有一个操作数是对象、数值或布尔值，则调用它们的toString()方法取得相应的字符串值，然后再应用前面关于字符串的规则。对于undefined和null，则分别调用String()函数取得字符串“undefined”和“null”。

2.减法

加法操作符与加法操作符相似。

在处理各种数据类型时遵循如下规则：

• 如果两个操作数都是数值，则执行常规算术运算操作
• 如果有一个操作数是NaN，则结果是NaN
• 如果是Infinity减Infinity，则结果是NaN
• 如果是-Infinity减-Infinity，则结果是NaN
• 如果是Infinity减-Infinity，则结果是Infinity
• 如果是-Infinity减-Infinity，则结果是-Infinity
• 如果是+0减+0，则结果是+0
• 如果是+0减-0，则结果是-0
• 如果是-0减-0，则结果是+0
• 如果有一个操作数是字符串、布尔值、null或undefined，则先执行Number()函数将其转换为数值，然后再执行减法计算。
• 如果有一个操作数是对象，则调用对象的valueOf()取得该对象的数值。如果没有valueOf()方法，则调用其toString()并得到字符串转换为数值。

举几个例子：

var result1 = 5 - true; // 4
var result2 = NaN - 1;  // NaN
var result3 = 5 - 3;    // 2
var result4 = 5 - "";   // 5
var result5 = 5 - "2";  // 3
var result6 = 5 - null; // 5

六、关系操作符

当关系操作符中使用了非数值时，处理遵循如下规则：

• 如果两个操作数都是数值，则执行数值比较
• 如果两个操作数都是字符串，则比较两个字符串对应的字符编码值
• 如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较
• 如果一个操作数是对象，则调用这个对象的valueOf()方法，用得到的结果按照上述规则进行比较。如果没有valueOf，则调用toString，然后再比较
• 如果一个操作数是布尔值，则将其转化为数值，然后再执行比较

在比较字符串时，实际比较的是两个字符串中对应位置的每个字符的字符编码值。

举一个例子：

var result1 = "B" < "a";    // true
var result2 = "b" < "a";    // false

原因是B的字符编码是66，a的编码是97，b的编码是98。

对于两个数字字符串的情况，情况是有点不同：

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

因为比较的是两个字符串，而字符串比较的是字符编码。“2”的字符编码是50，“3”的字符编码是51。

如果一个操作数是数值，结果就不一样了：

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

依据上述“如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较”的规则，“23”会转换为23，然后与3比较。

对于不能转换为数值的字符串返回结果都是false。

var result1 = NaN < 5;
var result2 = NaN >= 5;

七、相等操作符

JavaScript中提供两种相等操作符：

• 相等：先转换再比较
• 全等：不作转换，直接比较

1.相等和不相等

JavaScript中相等操作符由“==”表示，不相等由“!=”表示。这两个操作符都会先对操作数进行强制转型，然后再比较它们的相等性。

在转换不同的数据类型时，相等和不相等操作时遵循下列基本规则：

• 如果有一个操作数是布尔值，则先执行转换(false-0，true-1)
• 如果一个操作数是字符串，另一个操作数是数值，则先将字符串转换为数值
• 如果一个操作数是对象，另一个操作数不是，则调用对象的valueOf()方法，用得到的基本类型与值再进行比较

这两个操作符在进行比较时，遵循下列规则：

• null和undefined是相等的
• 比较之前，null和undefined不能转换为其他值
• 如果两个操作数都是对象，则比较它们是不是同一个对象。

2.全等和不全等

全等和不全等的区别在于：不会进行类型转换。

var result1 = ("55" != 55);     // false
var result2 = ("55" !== 55);    // true

null == undefined会返回true，因为它们是类似的值；但null === undefined会返回false，因为它们是不同的类型。

JavaScript:操作符

标签：

原文地址：http://www.cnblogs.com/xiaoxiaoyihan/p/5054578.html