类型转换

Author: YuChengKai

JS/JS-en.md

@@ -50,6 +50,75 @@ b.name = 'EF'
 console.log(a) // EF
 ```
 
+# Type Conversion
+
+## Converting to Boolean
+
+Other than `undefined`， `null`， `false`， `NaN`， `''`， `0`， `-0`, all of the values, including objects, are converted to `true`.
+
+## Objects to Primitive Types
+
+When objects are converted, `valueOf` and `toString` will be called, respectively in order. These two methods can also be overridden.
+
+```js
+let a = {
+    valueOf() {
+        return 0
+    }
+}
+```
+
+## Arithmetic Operators
+
+Only for additions, if one of the parameters is a string, the other will be converted to the string as well. For all other operations, as long as one of the parameters is a number, the other will be converted to a number.
+
+Additions will invoke three types of type conversions: to primitive types, to numbers, and to string.
+
+```js
+1 + '1' // '11'
+2 * '2' // 4
+[1, 2] + [2, 1] // '1,22,1'
+// [1, 2].toString() -> '1,2'
+// [2, 1].toString() -> '2,1'
+// '1,2' + '2,1' = '1,22,1'
+```
+
+Note the expression `'a' + + 'b'` for addition.
+
+```js
+'a' + + 'b' // -> "aNaN"
+// since ++ 'b' -> NaN
+// You might have seen + '1' -> 1
+```
+
+## `==` operator
+
+![](https://user-gold-cdn.xitu.io/2018/3/30/16275cb21f5b19d7?w=1630&h=1208&f=png&s=496784)
+
+`toPrimitive` in the above figure is converting objects to primitive types.
+
+`===` is usually recommended to compare to values. However, if you would like to know if a value is `null`, you can use `xx == null`.
+
+Let's take a look at an example `[] == ![] // -> true`. The following explains why the expression evaluates to `true`.
+
+```js
+// [] converting to true, then take the opposite to false
+[] == false
+// with #8
+[] == ToNumber(false)
+[] == 0
+// with #10
+ToPrimitive([]) == 0
+// [].toString() -> ''
+'' == 0
+// with #6
+0 == 0 // -> true
+```
+
+## Comparison Operator
+
+1. If it's an object, `toPrimitive` is used.
+2. If it's a string, `unicode` character index is used to compare.
 
 #### Typeof