js - 11 JS数据类型的转换

类型转换

js中的取值类型很灵活，可以参考布尔类型，当期望使用一个布尔类型的值的时候可以提供任意类型的值，会根据需要来转换。（如：一些真值转换为true，一些假值转换为false; ）

• 这是常见的类型转换

上图总结：
1.以数字表示的字符串可以直接转换为数字，允许在开始和结尾处带空格（开头和结尾处的非空格不会被当成数字直接量的一部分，导致结果为NaN）
2.原始值通过调用String([val])、Number([val])、Boolean([val])构造函数转换为各自的包装对象
3.null和undefined属于例外，当你期望他们是对象时，会造成一个类型错误(TypeError)

转换和相等性

因为js较为灵活，所以 ‘==’ 相等运算符也随相等的含义灵活多变
如：

null == undefined;
"0" == 0;               // 在比较之前，“0”会转变为0
0 == false              // false会转变为0，再比较
“0” == false            // false转变为0，“0”转变为0

注意:一个值转换为另一个值时，并不会意味着这两个值相等，比如indefined会转换为false，false并不等于undefined.

显式类型转换

js中会自动的做某些转换，但有时却需要自己手动。
常见的方法有:

Number("3")                 // => 3
String(false)               // => "false"
Boolean([])                 // => true
Object(3)                   // => new Number(3)

另：某些运算符也会做隐示类型转换
’x + “”‘ 可以等价于String(x)；
‘+ x’ 可以等价于Number(x),也可以写成 x - 0；
‘!!x’ 可以等价于Boolean(x),注意两个叹号；

js中提供了一些方法，可以使得Number to String/String to Number更简单

• toString([val])
  可以接收表示转换基数的可选参数（就是指数）

  var a = 17;
  binary_string = a.toString(2);            // => "10001"(二进制)
  octal_string = a.toString(8);             // => "021"(八进制)
  hex_string = a.toString(16);              // => "0x11"(十六进制)
  

• toFixed([val])
  根据小数点后的指定位数转换为字符串

  var a = 123456.789;
  a.toFixed(0);                 // => "1234567"
  a.toFixed(2):                 // => "123456.79"
  a.toFixed(5);                 // => "123456.78900"
  

• toExponential([val])
  使用指数计数法来转换

  var a = 123456.789;
  a.toExponential(1);           // => "1.2e+5";
  a.toExponential(3);           // => "1.235e+5";
  

• toPrecision([val])
  指定有效位莱转换

  var a = 123456.789;
  a.toPrecision(4);              // => "1.235e+5"
  a.toPrecision(7);              // => "1.23456.8"
  a.toPrecision(10);             // => "1.23456.7890"
  

• 如果通过Number()转换函数传入一个字符串，他会试图将其转换为一个整数或者浮点数直接量

• parseInt()
  全局函数，只解析整数

  parseInt("3 blind mice");         // => 3
  parseInt("3.14159");             // => 3
  parseInt("0xFF");                // => 255  
  parseInt("-0xFF");               // => -255
  parseInt(".1");                  // => NaN(整数不能以.开头)
  parseInt("11", 2)                // => 3(二进制)
  parseInt("zz", 36)               // => 1295(36进制)
  parseInt("077", 10)              // => 77(十进制)
  

• parseFloat()
  全局函数，可以解析整数和浮点数

  parseFloat("3.14159");            // => 3.14159  
  parseFloat(".1");                // => 0.1 
  parseFloat("$72.14");            // => NaN(数字不能以'$'开头)
  

对象转换为值

对象到布尔值的转换很简单：所有对象都转换为true，包装对象也是这样：new Boolean(false) => true;
对象到字符串和数字是通过调用待转换对象的一个方法来完成的。
*以下方法只适用于本地对象，而宿主对象（如web浏览器定义的对象）根据各自的算法来转换

• 所有对象都继承了两个方法：toString([val]),valueOf([val])

---

• toString([val])
  作用是返回这个对象的字符串

  ({x:1, y:2}).string()               // => "[object Object]"
  [1,2,3].toString()                  // =>"1,2,3"
  (function(x){f(x);}).toString()     // =>"function(x){f(x);}"
  /\d+/g.toString()                  // => /\\d+/g
  new Date(2019,11,3).toString()      // =>"Wed Dec 04 2019 00:00:00 GMT+0800 (中国标准时间)"
  

  ---

• valueOf([val])
  如果存在任意原始值，它就默认将对象转换为表示它的原始值；对象是复合值，而大多数对象无法真正表示为一个原始值，因此默认的valueOf()方法简单地返回对象本身，而不是返回一个原始值

  1.null和undefined
  null.valueOf()                        // => 报错
  undefined.valueOf()                   // => 报错
  
  2.布尔类型
  true.valueOf()                        // => true
  false.valueOf()                       // => false
  typeof Boolean.valueOf()              // => function
  typeof true.valueOf()                 // => Boolean
  
  3.字符串类型
  'asd'.valueOf()                       // => asd
  String.valueOf()                      // => String(){[native code]}
  
  4.数值类型
  123.valueOf()                         // => 报错
  (123).valueOf()                       // => 123
  
  5.对象类型
  {}.vlaueOf()                           // => 报错
  ({}).valueOf()                         // => Object {}
  typeof ({}).valueOf()                  // => 'object'
  ({a:123}).valueOf()                    // => Object{a:123}
  Object.valueOf()                       // => Object() { [native code] }
  typeof Object.valueOf()                // => 'function'
  function Person(){
      this.name = 'test';
  }
  var person1 = new Person();
  person1.valueOf()                     // => Person {name: "test"}
  
  6.函数
  function test(){                          functoin test(){
    alert("1")       test.vlaueOf():// =>       alert("1")
  }                                         }
  Function.valueOf()                   // => Function() { [native code] }
  
  7.数组
  [].vlaueOf()                          // => []
  
  8.时间
  var d = new Date(2019,11,4)           // => 2019年11月01日
  d.valueOf()                           // => 1575388800000
                                      （从1970，1，1以来的毫秒数）
  

• 还有一些关于符号的转换

var now = new Date()                  // => 创建一个日期对象
typeof(now + 1)                       // => "string"("+"将日期转换为字符串)
typeof(now - 1)                       // => "number"("-"使用对象到数字的转换)
now == now.toString()                 // => true(隐式的和限式的字符串转换)
now > (now - 1)                       // => true(">"将日期转换为数字)