js中的运算符

2016-10-19  本文已影响0人  jxnu薛哥

运算符,加减乘除一直都是语言的基础,和小学数据逻辑也很接近,可以说是简单的已经不能再简单了。但是在js中,总有让你打脸的地方

1. 加法运算#

(1)加法运算符<code>(+)</code>是最常见的运算符之一,但是使用规则却相对复杂。因为在JavaScript语言里面,这个运算符可以完成两种运算,既可以处理算术的<b>加法</b>,也可以用作字符串<b>连接</b>。

// 加法
1 + 1 // 2  没有对象或字符串, 数值相加
true + true // 2    Number(true)==1
1 + true // 2

// 字符串连接
'1' + '1' // "11"
'1.1' + '1.1' // "1.11.1"

1.如果运算子是对象,先自动转成原始类型的值。

即先执行该对象的<code>valueOf</code>方法,如果结果还不是原始类型的值,再执行<code>toString</code>方法;如果对象是<code>Date</code>实例,则先执行<code>toString</code>方法

2.两个运算子都是原始类型的值以后,只要有一个运算子是字符串,则两个运算子都转为字符串,执行字符串连接运算。
3.否则,两个运算子都转为数值,执行加法运算。

'1' + {foo: 'bar'} // "1[object Object]" 对象调用toString之后字符串相加
'1' + 1 // "11"  第一个是字符串,则使用字符串拼接
'1' + true // "1true" 
'1' + [1] // "11"

上面代码中,由于运算符左边是一个字符串,导致右边的运算子都会先转为字符串,然后执行字符串连接运算。

这种由于参数不同,而改变自身行为的现象,叫做“重载”(overload)。由于加法运算符是运行时决定到底执行那种运算,使用的时候必须很小心。

'3' + 4 + 5 // "345"
3 + 4 + '5' // "75"
//相等于
(3+4) + '5'

加法运算符会将其他类型的值,自动转为字符串,然后再执行连接运算。

var x = 1;
x + '' // "1" 转字符串1

[1, 2] + [3]  // 1,23
//相等于
"1,2" + "3"  // 数组先转为对应的字符串再进行拼接

(2)加法运算符一定有左右两个运算子,如果只有右边一个运算子,就是另一个运算符,叫做“数值运算符”。

+ - 3 // 等同于 +(-3)
+ 1 + 2 // 等同于 +(1 + 2)
+ '1' // 1
1 +  //   SyntaxError: Unexpected end of input

<b>加法运算符以外的其他算术运算符(比如减法、除法和乘法),都不会发生重载。它们的规则是:所有运算子一律转为数值,再进行相应的数学运算。</b>

1 - '2' // -1
1 * '2' // 2
1 / '2' // 0.5
var now = new Date();
typeof (now + 1) // "string"
typeof (now - 1) // "number

2. 余数运算符(%)#

需要注意的是,运算结果的正负号由第一个运算子的正负号决定。

-1 % 2 // -1
1 % -2 // 1
-1% -2 // -1 负数对比自己小的数求余都是自身
-1 % -1 // -0

3. 比较运算符的算法#

1.如果运算子是对象,先自动转成原始类型的值(即先执行该对象的valueOf方法,如果结果还不是原始类型的值,再执行toString方法)。
2.如果两个运算子都是字符串,则按照字典顺序比较(实际上是比较Unicode码点)。
3.否则,将两个运算子都转成数值,再进行比较。

[2] > [1] // true
// 等同于  '2' > '1'

[2] > [11] // true
// 等同于 '2' > '11'

{x: 2} > {x: 1} // false

// 等同于 '[object Object]' > '[object Object]'

4. 相等运算符和严格相等运算符#

(1)简单说,它们的区别是相等运算符<code>(==)</code>比较两个值是否相等,严格相等运算符<code>(===)</code>比较它们是否为“同一个值”。如果两个值不是同一类型,严格相等运算符<code>(===)</code>直接返回false,而相等运算符<code>(==)</code>会将它们转化成同一个类型,再用严格相等运算符进行比较。

/**类型不同,直接返回false*/
1 === "1" // false  
true === "true" // false 

/**类型相同且值相同*/
1 === 0x1 // true 注:typeof 0x1 === "number"

NaN === NaN // false Nan与任何值都不相等
+0 === -0 // true 除了作为分母,它俩性质一样

(2)两个复合类型(对象、数组、函数)的数据比较时,不是比较它们的值是否相等,而是比较它们是否指向同一个对象。

{} === {} // false
[] === [] // false
(function (){} === function (){}) // false

var v1 = {};
var v2 = v1;
v1 === v2 // true

(3)<code>undefined</code>和<code>null</code>与自身严格相等,所以,判断两个参数时,还需谨慎。

undefined === undefined // true
null === null // true

var v1;
var v2;
v1 === v2 // true

(4)注意,对于两个对象的比较,严格相等运算符比较的是地址,而大于或小于运算符比较的是值。

new Date() > new Date() // false 值比较
new Date() < new Date() // false 值比较
new Date() === new Date() // false 地址比较

5. 布尔值运算符#

5.1概述
布尔运算符用于将表达式转为布尔值,一共包含四个运算符。

5.2 !运算符
对于非布尔值的数据,取反运算符会自动将其转为布尔值。规则是,以下六个值取反后为<code>true</code>,其他值取反后都为<code>false</code>(取反运算符有转换数据类型的作用)。

!undefined // true
!null      // true
!false     // true
!0         // true(包括+0和-0)
!NaN       // true
!''        // true

!54 // false
!'hello' // false
![] // false
!{} // false

!!x
// 等同于
Boolean(x)

5.3 且运算符
如果第一个运算子的布尔值为<code>true</code>,则返回第二个运算子的值(注意是值,不是布尔值);如果第一个运算子的布尔值为<code>false</code>,则直接返回第一个运算子的值,且不再对第二个运算子求值。

't' && '' // ""
't' && 'f' // "f"
't' && (1 + 2) // 3
'' && 'f' // ""
'' && '' // ""

var x = 1;
(1 - 1) && ( x += 1) // 0
x // 1

5.4 或运算符
如果第一个运算子的布尔值为<code>true</code>,则返回第一个运算子的值,且不再对第二个运算子求值;如果第一个运算子的布尔值为false,则返回第二个运算子的值。

    't' || '' // "t"
    't' || 'f' // "t"
    ''  || 'f' // "f"
    ''  || ''  // ""

6. 位运算符#

6.1 概述
或运算(or):符号为|,表示若两个二进制位都为0,则结果为0,否则为1(有1则1)。
与运算(and):符号为&,表示若两个二进制位都为1,则结果为1,否则为0(11则1)。
否运算(not):符号为~,表示对一个二进制位取反。
异或运算(xor):符号为^,表示若两个二进制位不相同,则结果为1,否则为0。(同0异1)

位运算符直接处理每一个比特位(bit),所以是非常底层的运算,好处是速度极快,缺点是很不直观。位运算符只对整数起作用,如果一个运算子不是整数,会自动转为整数后再执行。另外,虽然在JavaScript内部,数值都是以64位浮点数的形式储存,但是做位运算的时候,是以32位带符号的整数进行运算的,并且返回值也是一个32位带符号的整数。

//转32为整数
function toInt32(x) { 
return x | 0;
}
toInt32(1.001) // 1
toInt32(1.999) // 1
toInt32(1) // 1
toInt32(-1) // -1

//一个整数大于32位的数位都会被舍去
toInt32(Math.pow(2, 32) + 1) // 1
toInt32(Math.pow(2, 32) - 1) // -1

6.2 或和与

0 | 3 // 3
0 & 3 // 0

/**
  *位运算只对整数有效,遇到小数时,会将小数部分舍去,只保留整数部分。
  *所以,将一个小数与0进行或运算,等同于对该数去除小数部分,即取整数位
  *不适用超过32位整数最大值2147483647的数
  */
2.9 | 0 // 2
-2.9 | 0 // -2

6.3 取反运算
将每个二进制位都变为相反值(0变为1,1变为0)

~ 3 // -4
0000 0000 0000 0000 0000 0000 0000 0011
->
1111 1111 1111 1111 1111 1111 1111 1100
//JavaScript内部采用补码形式表示负数,即需要将这个数减去1,
//再取一次反,然后加上负号,才能得到这个负数对应的10进制值
->减一
1111 1111 1111 1111 1111 1111 1111 1011
->取反
0000 0000 0000 0000 0000 0000 0000 0100
->加上负号
-4
//可以简单记忆成,一个数 与 自身的取反值相加,等于-1

~2 // -3
~-3 // 2

//对一个整数连续两次“否运算”,得到它自身。
~~3 // 3

所有的位运算都只对整数有效。否运算遇到小数时,也会将小数部分舍去,只保留整数部分。所以,对一个小数连续进行两次否运算,能达到取整效果。使用否运算取整,是所有取整方法中最快的一种
对于其他类型的参数,否运算也是先用Number转为数值,然后再进行处理

~~2.9 // 2
~~47.11 // 47

// 以下例子相当于~Number('011')
~'011' // -12
~'42 cats' // -1
~'0xcafebabe' // 889275713
~'deadbeef' // -1

6.4 异或运算
同0异1

0 ^ 3 // 3

“异或运算”有一个特殊运用:互换变量值

var a = 1;
var b = 2;
a ^= b, b ^= a, a ^= b;
a // 2
b // 1

0001
0010

a=0011
->
b=0001
->
a=0010

6.5 左移运算符
左移运算符表示将一个数的二进制值向左移动指定的位数,尾部补0,即乘以2的指定次方。

4 << 1// 8
-4 << 1// -8

RGB转HEX

var color = {r: 186, g: 218, b: 85};
// RGB to HEX
// (1 << 24)的作用为保证结果是6位数
var rgb2hex = function(r, g, b) {
 return '#' + ((1 << 24) + (r << 16) + (g << 8) + b) .toString(16) .substr(1);
}
rgb2hex(color.r,color.g,color.b);
//#bada55

6.6 右移运算
右移运算符表示将一个数的二进制值向右移动指定的位数,头部补0,即除以2的指定次方(最高位即符号位不参与移动)

4 >> 1// 2
/*
4的二进制:0000 0000 0000 0000 0000 0000 0000 0100
右移一位: 0000 0000 0000 0000 0000 0000 0000 0010
*/

1>>1 // 0

-4 >> 1 // -2
/*

7. void运算符#

是不是经常会看到这样一句代码:

<a href="javascript:void(0)">链接</a>

虽然知道这个功能是点击链接没反应,但是,并不知道为什么要这样用,是吗?让我们一起探究一下吧

void运算符的作用是执行一个表达式,然后不返回任何值,或者说返回undefined。因此,上面的a链接才不会执行跳转。

var x = 3;
void (x = 5) //undefined
x // 5

//void 的优先级很高,和其它运算符在一起,需要括号括起来
void 4 + 7 // NaN
//等于
void(4) + 7

8. 逗号运算符#

逗号运算符用于对两个表达式求值,并返回后一个表达式的值。

'a', 'b' // "b"
var x = 0;
var y = (x++, 10);
x // 1
y // 10
上一篇下一篇

猜你喜欢

热点阅读