const num = 10;
num.toString(); //'10'
num.toString(2); //'1010'
num.toString(8); //'12'
num.toString(10); //'10'
num.toString(16); //'a'

String(null); //'null'
let value;
String(value); //'undefined'
String(12); //'123'
String(true); //'true'

String(1); //显式转换 '1'
String(1.2); //显式转换 '1.2'
String(null); //显式转换 'null'
String(undefined); //显式转换 'undefined'
String(true); //显式转换 'true'
String(false); //显式转换 'false'
1 + ''; //隐式转换  操作符+号 且其中一个操作数为string类型。结果'1'

to number

在 JavaScript 中有三个函数可以将非数值显式转化为数值：

1. Number()
2. parseInt()
3. parseFloat()

Number函数基于如下规则完成转化过程。

1. boolean类型，true为1 ,false转化为0。

2. 数值，直接返回。

3. null，返回 0。

4. undefined，返回NaN。

5. 字符串，应用以下规则：

   • 如果字符串是数值或者前面带加减号的情况，则转化为一个十进制数值。

     Number('123'); //123
     Number('+123'); //123
     Number('-123'); //-123
     Number('123abc'); //NaN
     Number('0012'); //12 忽略前面的0
     

   • 如果字符串包含有效的浮点值如1.2，则会转化为相应的浮点值。（同样会忽略前面的 0）

   • 如果字符串包含有十六进制格式如0xf,则会转化为与该十六进制对应的十进制整数值。

   • 如果是空字符串，则返回0

   • 如果字符串包含除了上述以外的其他字符，则返回NaN

parseInt函数更专注于字符串是否包含数值模式，字符串前面的空格会被忽略，从第一个非空格字符开始转化，如果第一个字符不是数值、+或者-号，则直接返回 NaN。（注意：空字符也会被转化为NaN）。如果第一个字符是数值、+或者-号，则依次检测每个字符，直到遇到非数值字符或者到字符末尾。

parseInt('123blue'); //123
parseInt(''); //NaN
parseInt('123.123'); //123

注意：parseInt 函数是能识别不同的整数格式，如十六进制或者八进制，也就是说如果是以0x开头，则会被解释为十六进制整数，如果以0开头，且紧跟着数值字符，则会被解释为八进制。但不同的数值格式其实很容易混淆，因此 parseInt 接受第二个参数，用于制定底数（也就是进制数），如果需要解析的值为十六进制，则第二个参数传入 16，以便正确解析。不传底数，就是 parseInt 自己决定如何解析。为了避免解析错误，建议带上第二个参数。

parseInt('010'); //10
parseInt('010', 8); //8 八进制
parseInt('0xA'); //10
parseInt('0xAF'); //175
parseInt('AF', 16); //175 如果传了进制数，则16进制可以省略前面的`0x`
parseInt('AF'); //NaN

parseFloat函数的工作方式和parseInt函数类似，都是从第一个字符开始检测，同样，也是解析到字符串末尾或者解析到一个无效的浮点数值字符为止。这意味着第一次出现的小数点是有效的，但第二次以及后面出出现的小数点则无效。此时后面的字符也会被忽略。但 parseFloat 和 parseInt 不同的点在于 parseFloat 始终忽略字符串开头的 0，parseFloat 不支持传入进制数，十六进制会解析成 0，因此 parseFloat 只解析十进制数值。

parseFloat('123blue'); //123
parseFloat('123.12.1'); //123.12
parseFloat('00123.12.1'); //123.13
parseFloat('0xA'); //0
parseFloat('3.125e7'); //31250000

隐式转化的情况有以下几种：

1. 比较操作符（<,>,<=,>=）
2. 按位操作符（| & ^ ~）
3. 四则运算 （- + \* / %） 其中操作符为+号，一方操作数为 string 类型，则隐式转化为 string 类型,。
4. 一元操作符 （+）
5. loose equality operator == ，也包括!=

转化规则参考 Number 函数

注意：虽然Number(null)为 0，但null==0为 false，null==undefined为 true。NaN 不等于任何值，包括它自己。

to boolean

调用 Boolean 函数 显示转化为 boolean，或者遇到逻辑操作符(|| && !) 则会隐式转化为 boolean 类型。 除了以下几种情况转为 false，其他则为 true。

Boolean(''); // false
Boolean(0); // false
Boolean(-0); // false
Boolean(null); // false
Boolean(undefined); // false
Boolean(NaN); // false
Boolean(false); // false

即使是[]或者{}对象，也会转化为 true

Boolean({}); // true
Boolean([]); // true
Boolean(function() {}); // true

function ToPrimitive(input, preferredType) {
  switch (preferredType) {
    case Number:
      return toNumber(input);
      break;
    case String:
      return toString(input);
      break;
    default:
      return toNumber(input);
  }

  function isPrimitive(value) {
    return value !== Object(value);
  }

  function toString() {
    if (isPrimitive(input.toString())) return input.toString();
    if (isPrimitive(input.valueOf())) return input.valueOf();
    throw new TypeError();
  }

  function toNumber() {
    if (isPrimitive(input.valueOf())) return input.valueOf();
    if (isPrimitive(input.toString())) return input.toString();
    throw new TypeError();
  }
}

var obj = {
  prop: 101,
  toString() {
    return 'Prop: ' + this.prop;
  },
  valueOf() {
    return this.prop;
  },
};

console.log(String(obj)); // 'Prop: 101'
console.log(obj + ''); // '101'
console.log(+obj); //  101
console.log(obj > 100); //  true

/** Date测试 */
let d = new Date();
let str = d.toString();
let num = d.valueOf();
console.log(d == str); //true
console.log(d == num); //false