JavaScript操作符

2017-10-24  本文已影响9人  Sketch

一元操作符

只能操作一个值的操作符。

递增和递减操作符

  1. 前置型：位于要操作的变量之前；
  2. 后置型：位于要操作的变量之后。

如：

    var age = 24;
    ++ age;
    //等同于
    var age = 24;
    age = age + 1;

    var age = 24;
    -- age;
    //等同于
    var age = 24;
    age = age - 1;

副效应：执行前置递增和递减操作时，变量的值都在语句被求值前改变。

  var age = 24;
  var newage = --age + 2;
  console.log(age);         //值为23
  console.log(newage);      //值为25
  console.log(age + newage);         //值为48

后置型递增和递减操作是在包含她们的语句被求值之后才执行。

  var age = 24;
  var newage = age-- + 2;
  console.log(age);         //值为23
  console.log(newage);      //值为26
  console.log(age + newage);         //值为49

递增和递减操作符遵循下列规则：

  var a = 24;
  var b = "a";
  var c = true;
  var d = 1.1;
  var e = {
    valueOf: function() {
      return -1;
    }
  };
  a++;
  b++;
  c++;
  d--;
  e++;
  console.log(a);   //值为25
  console.log(b);   //值为NaN
  console.log(c);   //值为2
  console.log(d);   //值为0.10000000000000009
  console.log(e);   //值为0

一元加和减操作符

一元加操作符以一个(+)表示，但是放在数值前面不会产生影响。

再对非数值应用一元操作符时，会先对值进行转换。

一元操作符还能用于表示负数，也就是将正数转换为负数，但对非数值时，也会先对它进行转换。

位操作符

这部分内容来自于developer.mozilla.org/

有符号32位整数

位操作符用于在最基本的层次上，即按照内存中表示数值的位来操作数值。

所有的按位操作符的操作数都会被转成补码（two's complement）形式的有符号32位整数。补码形式是指一个数的负对应值（negative counterpart）为数值的所有比特位反转后，再加1。反转比特位即该数值进行’非‘位运算，也即该数值的反码。例如下面为整数314的二进制编码：

00000000000000000000000100111010

下面编码 ~314，即 314 的反码：

11111111111111111111111011000101

最后，下面编码 -314，即 314 的补码：

11111111111111111111111011000110

补码保证了当一个数是正数时，其最左的比特位是0，当一个数是负数时，其最左的比特位是1。因此，最左边的比特位被称为符号位（sign bit）。

0 是所有比特数字0组成的整数。

0 (base 10) = 00000000000000000000000000000000 (base 2)

-1 是所有比特数字1组成的整数。

-1 (base 10) = 11111111111111111111111111111111 (base 2)

-2147483648（十六进制形式：-0x80000000）是除了最左边为1外，其他比特位都为0的整数。

-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)

2147483647（十六进制形式：0x7fffffff）是除了最左边为0外，其他比特位都为1的整数。

2147483647 (base 10) = 01111111111111111111111111111111 (base 2)

数字-2147483648 和 2147483647 是32位有符号数字所能表示的最小和最大整数。

按位逻辑操作符

从概念上讲，按位逻辑操作符按遵守下面规则：

按位操作符（Bitwise operators） 将其操作数（operands）当作32位的比特序列（由0和1组成），而不是十进制、十六进制或八进制数值。例如，十进制数9，用二进制表示则为1001。按位操作符操作数字的二进制形式，但是返回值依然是标准的JavaScript数值。

下面的表格总结了JavaScript中的按位操作符：

运算符 用法 描述
按位与（ AND） a & b 对于每一个比特位，只有两个操作数相应的比特位都是1时，结果才为1，否则为0。
按位或（OR） a | b 对于每一个比特位，当两个操作数相应的比特位至少有一个1时，结果为1，否则为0。
按位异或（XOR） a ^ b 对于每一个比特位，当两个操作数相应的比特位有且只有一个1时，结果为1，否则为0。
按位非（NOT） ~ a 反转操作数的比特位，即0变成1，1变成0。
左移（Left shift） a << b 将 a 的二进制形式向左移 b (< 32) 比特位，右边用0填充。
有符号右移 a >> b 将 a 的二进制表示向右移b(< 32) 位，保留符号位（即正负号标记）。
无符号右移 a >>> b 将 a 的二进制表示向右移b(< 32) 位，丢弃被移出的位，并使用 0 在左侧填充。

布尔操作符

布尔操作符一共有以下3个：

  1. 逻辑非（not）(!)
  2. 与（and)(&&)
  3. 或（or)(||)

逻辑非(!)

逻辑非操作符由一个叹号(!)表示，可以用于任何值。无论这个值是什么数据类型，这个操作符都会返回一个布尔值。

逻辑非操作符遵循下列规则：

例如：


  var a = {
    function(){
      return 1;
    }
  };
  console.log(!a);              //false
  console.log(!"");             //true
  console.log(!"hello world"); //false
  console.log(!0);             //true
  console.log(!2017);          //false
  console.log(!null);          //true
  console.log(!NaN);                   //true

如果同时使用两个逻辑非操作符，可以得到这个值对应的布尔值。

逻辑与(&&)

逻辑与操作符由 && 表示，有两个操作数，如：

var result = true && false;

其值表为：

第一个操作符 第二个操作符 结果
true true true
true flase false
false true false
false flase false

逻辑与操作符可以应用于任何类型的操作数。

逻辑与操作符遵循下列规则：

如果第一个操作数是false，无论第二个操作数是什么值，结果都为false。

逻辑或(||)

逻辑或操作符由 || 表示，有两个操作数，如：

var result = true || false;

其值表为：

第一个操作符 第二个操作符 结果
true true true
true flase true
false true true
false flase false

逻辑与操作符遵循下列规则：

如果第一个操作数是true，无论第二个操作数是什么值，结果都为true。

乘性操作符

3个乘性操作符：

  1. 乘法；
  2. 除法；
  3. 求模。

如果参与乘性计算的某个操作符不是数值，后台会先使用number()转型函数将其转换为数值。

乘法

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

乘法操作符遵循下列规则：

  1. 数值 * 数值，执行常规乘法计算；
  2. x * NaN，结果为NaN；
  3. Infinity * 0，结果为NaN；
  4. Infinity * y（y不等于0），结果为+-Infinity；
  5. Infinity * Infinity，结果为Infinity。

除法

除法操作符由一个 / 表示，执行两个数值的除法运算。

除法操作符遵循下列规则：

  1. 数值 / 数值，执行常规除法计算；
  2. x / NaN，结果为NaN；
  3. 0 / 0，结果为NaN；
  4. 非零有限数 / 0，结果为+-Infinity；
  5. Infinity / Infinity，结果为结果为NaN；
  6. Infinity ／ 任何非零数，结果为+-Infinity。

求模

求模（余数）操作符由一个 % 表示。

求模操作符遵循下列规则：

  1. 数值 % 数值，执行常规求模计算；
  2. 无穷大值 % 有限大值，结果为NaN；
  3. 有限大值 % 0，结果为NaN；
  4. Infinity % Infinity，结果为NaN；
  5. 有限大值 % 无穷大值，结果为有限大值；
  6. 0 % 任何数，结果为0。

加性运算符

加法

加法操作符由一个 + 表示。

加法操作符遵循下列规则：

  var a = 5;
  var b = 10;
  console.log("5加10的值为：" + a + b);   //5加10的值为：510
  console.log("5加10的值为：" + (a + b));         //5加10的值为：15

减法

加法操作符由一个 - 表示。

加法操作符遵循下列规则：

  1. x - NaN，结果为NaN；
  2. Infinity - Infinity，结果为NaN；
  3. -Infinity - -Infinity，结果为NaN；
  4. Infinity - -Infinity，结果为Infinity；
  5. -Infinity - Infinity，结果为-Infinity；
  6. +0 - +0 = +0;
  7. +0 - -0 = -0;
  8. -0 - -0 = +0.

关系操作符

关系操作符一共有4个：

  1. 小于(<)；
  2. 大于(>)；
  3. 小于等于(>=)；
  4. 大于等于(>=)。

关系操作符遵循下列规则：

  1. 如果两个操作数都是数值，执行数值比较；
  2. 如果两个操作符都是字符串，执行两个字符串对应的字符编码值比较；
  3. 如果两个操作符其中一个是数值，将另一个转换为数值再进行比较；
  4. 如果两个操作符其中一个是布尔值，将其转换为数值再进行比较。
  var a = "Brick";
  var b = "alphabet";
  console.log(a < b);                                 //true
  console.log(a.toLowerCase() < b.toLowerCase());    //false

相等操作符

相等和不相等

先转换再比较

相等操作符由 == 表示；

不相等操作符由 != 表示。

相等操作符遵循下列规则：

  1. 如果包含布尔值：将false转换为0，true转换为1；
  2. 如果包含字符串和数值，将字符串转换为数值；
  3. 如果一个操作符石对象，另一个不是则遵循：

全等和不全等

仅比较不转换

全等操作符由 === 表示；

不全等操作符由 !== 表示。

null == underfined，返回true；

null === underfined，返回false，因为它们是不同类型的值。

条件操作符

语法

condition ? expr1 : expr2

参数

condition:计算结果为true或false的表达式。

expr1, expr2:值可以是任何类型的表达式。

描述
如果条件值为真值（true），运算符就会返回 expr1 的值；否则， 就会返回 expr2 的值。

  var a = 13;
  var b = 16;
  var max = (a > b) ? a : b;
  console.log(max);          //返回值为16

赋值操作符

赋值操作符由 = 表示。

简单赋值操作：

  var age = 18;

复合赋值（在 = 前面添加其他操作符）操作：

  var age = 18;
      age += 10;
      //等同于
      age = age + 10;

逗号操作符

使用逗号操作符可以在一条语句中执行多个操作，如：

//逗号操作符用于声明多个变量
  var a = 1, b = 2, c = 3;
//逗号操作符用于赋值
  var a = (1,2,3,4);
//由于4是表达式中的最后一项，因此a的值就是4

运算符优先级汇总表

Operator precedence

练习

// Number + Number -> 数字相加
console.log(1+1);       //2

// String + String -> 字符串连接
console.log("2"+"4");   //"24"

// Number + String -> 字符串连接
console.log(2+"4");     //"24"

// 只有一个字符串参数 -> 数值
console.log(+"4");      //4

var a = 1;
a+++a;
//  a+++a -> (a++)+a，a++返回值为1，a自增运算结果为2，即1+2=3
typeof a+2;
//  typeof a+2 -> (typeof a)+2，typeof a返回值为number，即number+2="number2"

var a = 1;
var b = 3;
console.log( a+++b );
//  a+++b -> (a++)+b，a++返回值为1，即1+3=4
上一篇下一篇

猜你喜欢

热点阅读