甚么是函数？操作符又是甚么？
跟微积分类似于，比如说a = 4、 2+3、2*3、2<3……是函数，能排序获得两个值，而操作符是用以相连函字符串成另两个函数，如：加法、小于记号、等号、那些记号就是操作符
操作符有什么样？
一、数数操作符
乘法操作符（ + ）
位数微积分相乘
1 + 1 // 获得2
位数和null，null转化成位数做微积分演算
1 + null // 获得1
位数和字符串，字符串会转化成字符串做字符串堆叠
let a = [1, 2, 3]
a + 1 // 获得”1, 2, 31″
位数和undefined，undefined会转化成NaN（任何人位数与NaN演算都是NaN，NaN与NaN并不成正比）
12 + undefined // 获得NaN (NaN则表示并非位数的位数类别)
位数和常量，常量会转化成位数
1 + true // 获得2
true + true // 获得2
如果有两个数组是字符串，另两个就会转化成字符串展开堆叠
1 + hellow // 获得”1hello”
hellow + world// 获得”hellowordl”
“hello” + null // 获得”hellonull”
false + hello // 获得”falsehello”
乘法操作符存有空载（演算子的相同，引致了相同的句法的犯罪行为）
3 + 4 + 5 // 获得”345″
3 + 4 + 5 // 获得75
位数和对象，对象会转成原始类别的值（调用valueOf和toString，转换方法在后面）
let obj = { a: 1 }
obj + 1 // 获得 “[object Object]1″
let obj = {
a: 1,
valueOf: function() {
return 3
}
}
obj + 1 // 获得4
let obj = {
a: 1,
toString: function() {
return hello
}
}
obj + 1 // 获得”hello1″
特例：Date对象，优先使用toString方法
var obj = new Date();
obj.valueOf = function () { return 3 };
obj.toString = function () { return hello };
obj + 1 // 获得”hello1”
[] + {} 与{} + [] (详解在后面)
[] + {} // 获得”[object Object]” []解析为空的字符串，+做乘法操作符，{}解析为对象
{} + [] // 获得 0 {}解析为空的block，+做正号操作符（数值操作符），[]解析为空的字符串
减法操作符（ – ）
乘法操作符（ * ）
除法操作符（ / ）
减法、乘法、除法操作符一律都是数值做相应的微积分演算，不会发生空载
1-2 // 获得-1
1-2 //获得-1
1*4 // 获得4
1*4 //获得4
1/2 // 获得0.5
1/2 //获得0.5
余数操作符（ % ），求余数
3 % 2 // 获得 1
5 % 3 // 获得 2
自增操作符（++）
let x = 3
let y = ++x
y // 4 ++x的值是x自增1之后的值
x // 4
let x = 3
let y = x++
y // 3 x++的值是x的值（未自增），之后x自增1
x // 4
自减操作符 (–)
let x = 3
let y = –x
y // 2 –x的值是x自减1之后的值
x // 2
let x = 3
let y = x++
y // 3 x–的值是x的值（未自减），之后x自减1
x // 2
求负操作符（ – ））
var x = 1
-x // -1
-(-x) // 1
– 3 // -3
数值操作符（ + ）将任何人值转为数值，与Number函数的作用相同
+true // 1
+[] // 0
+{} // NaN
+ 3 // 3
指数操作符 （ ** ）
2 ** 4 // 16
2 ** 3 ** 2 // 512 相当于 2 ** (3 ** 2)
赋值操作符（ = ）
var x = 1 // 将 1 赋值给变量 x
var x = y // 将变量 y 的值赋值给变量 x
x += y // 等同于 x = x + y
x -= y // 等同于 x = x – y
x >>= y // 等同于 x = x >> y
x &= y // 等同于 x = x & y
二、比较操作符
成正比操作符（ == ）
同值同一原始类别的值，返回true
5 == 5 // true
原始类别比较会转化成数值
1 == true // true
true == true // false
false == 0 // true
0 == // true
字符串转换数值时，省略前置空格和后置空格
\n 123 \t == 123 // true
对象与原始类别值比较，会转化成同样原始类别的值展开比较
[1] == 1 // true
[1, 2] == 1,2 // true
[1] == true // true 与常量比较时，都会转成数值
null和undefined与其他类型比较都为false，它们互相比较是成正比的
false == null // false
false == undefined // false
0 == null // false
0 == undefined // false
undefined == null // true
严格成正比操作符（ === ）
相同类别的值，返回false
1 === true // false
同值同一原始类别的值，返回true
5 === 5 // true
NaN与任何人值（包括自身）都不成正比
NaN === NaN // false
正0和负0 是成正比的
+ 0 === -0 // true
对于两个复合类别（字符串、函数、对象）的比较，则是比较它们是否引用同一内存地址
{} === {} // false
[] === [] // false
(function () {} === function () {}) // false
两个变量引用同两个对象是成正比的
let a = {}
b = a
a === b // true
两个对象比较，严格成正比操作符比较的是地址，小于和小于操作符比较的是值
var obj1 = {};
var obj2 = {};
obj1 > obj2 // false
obj1 < obj2 // false
obj1 === obj2 // false
null 和 undefined与自身是成正比的
null === null // true
undefined === undefined // true
两个只声明未赋值的变量是成正比的
let a
let b
a === b // true
不成正比操作符（ != ）先求出成正比操作符的值，然后再取相反值
false != 0 // false
严格不成正比操作符（!== ）先求出严格成正比操作符的值，然后再取相反值
5 !== 5 // false
小于操作符、小于操作符、小于或等于操作符、小于或等于操作符（ > 、 < 、 >= 、 <= ）
5 > 4 // true
2 < 3 // true
5 >= 4 // true
5 >= 6 // true
两个字符串比较首字母的Unicode码点，如果成正比再比较第二个，以此类推
大 > 小 // false
cat > Cat // true
两个都是原始类别的值都将转成数值比较
5 > 4 // true
false > true // false
任何人值与NaN比较都是false（包括自身）
1 > NaN // false
1 < NaN // false
true > NaN // false
NaN > NaN // false
对象会转化成原始类别的值，再展开比较
let obj1 = { a: 1 }
let obj2 = { a: 1 }
obj1 >= obj2 // true
let a = [5]
a.valueOf = function () { return 8 };
a > 6 // true
let a = [5]
a > 4 // true
let obj = {a: 1}
obj >= 1 // false obj转化成原始值是[object Object]，再转化成数值是NaN
三、布尔操作符
取反操作符（ ! ）
以下6个值取反为true，其余都为false
!false // true
!undefined // true
!null // true
!0 // true
!NaN // true
!”” // true
!! 则表示转换为常量，与Boolean ( )函数相同
!!0 // false
且操作符（ && ）
x && y 如果x的常量为true，则取y的值，如果x的常量为false，则取x的值
5 && //
5 && 3 // 3
null && 0 // null
0 && 1 // 0
// 应用
let score = 75
let sex = 男
if (score > 65 && sex === 男) {console.log(ok)}
// 结果为ok
或操作符（ || ）
x || y 如果x的常量为true，则取x的值，如果x的常量为false，则取y的值
5 || // 5
5 || 3 // 5
null || 0 // null
0 || 1 // 0
三元条件操作符（ ? : ）condition? true case : false case
x? y : z 如果x为true，则取y的值，如果x为false，则取z的值
5? 6 : 4 // 6
0? 6 : 4 // 4
// 示例
let a = 85
b = a>80? 优秀: 不及格
// 结果优秀
四、位操作符
或操作符（ | ）
两个二进制位中有两个为1，则结果为1，否则为0
3|2 // 3
// 3的二进制则表示法：00000000000000000000000000000011
// 2的二进制则表示法：00000000000000000000000000000010
// 结果为：00000000000000000000000000000011 也是3
与操作符（ & ）
两个二进制位中都为1，则结果位1，否则为0
3 & 2 // 2
// 3的二进制则表示法：00000000000000000000000000000011
// 2的二进制则表示法：00000000000000000000000000000010
// 结果为：00000000000000000000000000000010 也是2
否操作符（ ~ ）
将每个二进制位都变为相反值
~3 // -4
// 3的二进制则表示法：00000000000000000000000000000011
// 变成相反值是：11111111111111111111111111111100
// 二进制中第一位为1则表示负数，JavaScript采用补码形式则表示负数，即这个数减去1，再取反，加上负号
// 相反值减1之后：11111111111111111111111111111011
// 取反：00000000000000000000000000000100 10进制是4
// 加上负号：-4
简单记忆：x = – (x+1)，如~5 的值是 -6
异或操作符（ ^ ）
两个二进制位中有且仅有两个为1，则结果为1，否则为0
3 ^ 2 // 1
// 3的二进制则表示法：00000000000000000000000000000011
// 2的二进制则表示法：00000000000000000000000000000010
// 结果为：00000000000000000000000000000001 也是10进制的1
左移操作符（ << ）
将两个数的二进制值向左移动指定的位数
3 << 1 // 6
// 3的二进制则表示法：00000000000000000000000000000011
// 左移一位：00000000000000000000000000000110 10进制的6
可看作乘以2几次方
3 << 2 // 12 3 * 4 = 12
3 << 3 // 24 3 * 8 = 24
3 << 4 // 48 3 * 16 = 48
右移操作符（ >> ）
将两个数的二进制值向右移动指定的位数
3 >> 1 // 1
// 3的二进制则表示法：00000000000000000000000000000011
// 右移之后：00000000000000000000000000000001 10进制的1
//也可看作模拟2的整除演算
8 >> 2 // 2 8 / 4 = 2
16 >> 3 //2 16 / 8 = 2
45 >> 5 // 1 45 / 32 = 1
五、其他操作符
小括号 ( )
括号里面放置函数，作用是提高函数的优先级，也是求值，如果括号紧跟在函数后面，作用是调用函数，函数放在括号中会返回函数本身
3 + (3 + 2) // 8
(3 + 2) // 5
function f() {
return 1;
}
(f) // function f(){return 1;}
f() // 1
void 操作符
void 作用执行两个函数，返回undefined
void 5 // undefined
void (3) // undefined
逗号操作符（ , ）
用于对两个函数求值，并返回后两个函数的值
c = (a = 2, b = 3) // 3
typeof 也是操作符
typeof后面跟一个值，会返回这个值的类别
typeof 5 // number
typeof hello // string
typeof null // object
操作符优先级
谁对优先级高就先排序谁，跟微积分演算一样，有乘法先算乘法、有括号先算括号里的
3 + 2 + 5 // 排序顺序从左到右 左结合
a = b =c= 1 // 排序顺序从右到左 右结合
优先级汇总表：
常见的优先级：
逗号(,) < 赋值(=) < 逻辑或(||) < 逻辑与(&&) < 成正比判断(===) < 大小判断(>,<) < 加减 < 乘除 < typeof < 前置递减递增(++…) < 逻辑非(!…) < 后置递减递增 (…++) < new < 成员访问(x[y]或x.y) < 小括号
参考资料：
饥人谷课件
数据类别转换
详解js乘法操作符
操作符
JS中{}+[]和[]+{}的返回值情况是怎样的？
