JS类型值及转换总结

*本总结来自于you donnot know Javascript (Types and Gramma)

类型&值

内置类型： 7种 （null| undefined | boolean | number| string | object | symbol）

类型判断

typeof 判断除 null 之外的类型
typeof Undeclared 安全防范机制：
为某些缺失的功能写polyfill，去掉var可以防止变量提升
方法一：

if(DEBUG) {
// 如果不存在会报错
  console.log("debugging is starting");
}
if( typeof DEBUG !== "undefined") {
  console.log("debugging is starting");
}

方法二使用全局对象window判断

if(window.DEBUG) {
  // ...
}

值

类数组：字符串和数组都是类数组，拥有length和indexof(…)和concat(…)
字符串可以借用数组的方法，使用call

let dUpper = Array.prototype.map.call(a,function(v) {
  return v.toUpperCase()+ '.';
}).join("");

浮点数：设定误差范围 2^-52

ES6中定义了Number.EPSILON代表浮点数的误差范围

//polyfill
if(!Number.EPSILON)
{
  Number.EPSILON = Math.pow(2,-52);
}

数字类型包含几个特殊值： -Infinity +Infinity -0
特殊的数值 NaN
不是数字的数字 仍是数字类型
typeof NaN === “number”
NaN 为非自反的值 NaN !== NaN 使用内建函数isNaN()判断 该函数有个严重bug 判断当前数字不是NaN类型，也不是Number类型
math工具函数中 isNaN 的polyfill

if(!Number.isNaN) {
  Number.isNaN = function(n) {
    return typeof n === 'Number' && window.isNaN(n);
  }
}
区分正负0
```javascript
function isNegZero(n) {
  n = Number(n);
  return (n === 0) && (1/n === -Infinity)
}

ES6中出现了 Object.is(…) 判断两个值是否完全相等，能够使用== / === ，不使用 Object.is() 因为前者效率更高更通用

原生函数

内建函数

String()
Boolean()
Number()
Array()
Object()
Function()
RegExp()
Error() // 之前没注意过
Symbol()
注意 使用内建函数创建的是xxx函数的封装对象，并非基本类型值

let a = new String("abc");
typeof a // "object"
a instanceof String // true
Object.prototype.toString.call(a) // "[object String]"

因此不建议使用封装对象直接进行判断，因为返回的值始终为 true

类型转换

值类型转换

显式类型转换

toString()

JSON.stringify(…)

遇到undefined，function 和symbol 自动将其忽略 在数组中返回null

toJSON()

对含有非法JSON值的对象做字符串化，或者当对象中某些值无法被序列化时，定义toJSON()来返回一个安全的JSON值
toJSON() 返回的是一个可以呗字符串化的安全的JSON值 可以是任何类型，使用JSON.stringify(…)对其进行字符串化

let o = {}
let f = {
  b: 55,
  c: o,
  d: function(){}
}
// 出现循环引用
o.e = f;
let g = JSON.stringify(f)
p(`正常JSON化${g}`);
// 使用toJSON会直接改变对象
f.toJSON = function() { return {b : this.b }}
// {"b":55}

JSON.stringify(…)传递可选参数
replacer:

1. replacer是一个函数，对对象本身调用一次，对对象中的每个属性各调用一次，每次传递键值对，忽略某个键就返回undefined，否则返回指定值
2. replacer是数组，必须是字符串数组，包含序列化要处理的对象的属性名称，其他的属性将被忽略

let k = {
  b: 55,
  c: "sss",
  d: [1,2,3]
}
p(JSON.stringify(k, function(key,value) {
  if(key !== "b") return value;
}))

JSON.stringify(…) 还有一个可选参数space，用来指定输出的缩进格式

p(JSON.stringify(k,null,2))
{
  "b": 55,
  "c": "sss",
  "d": [
    1,
    2,
    3
  ]
} 

抽象操作 ToNumber(…)

Number(undefined) // NaN
Number(null) // 0

ToBealean

以下都是假值：

undefined | null | false | +0 -0 NaN | ""

类型转换

1. 日期显式转换为数字

let l = new Date(); //1563943975689
let timeStamp = new Date().getTime();
// es5 中的方法
timeStamp = Date.now();
// Date.now() 的polyfill
if(!Date.now) {
  Date.now = function () {
    return +new Date();
  }
}

2. 使用～进行 32位运算
   ~x 大致等于 -(x+1)

if(~a.indexOf('xx')) {
console.log("当前没有找到匹配")
}

~~只适用于32位的数字
Math.floor(-49.6) // -50
~~(-49.6) // -50
3. parseInt(…)
将参数强制处理为字符串再解析
parseInt(1/0, 19) // 18 1/0 处理为Infinity n为无效字符，只处理到I，按照19进制 得到18
4. Boolean(…)显式转换
4.1 最常用: !!
a = !!“0” && !!{} && !![] // true
d = !!"" && !!0 && !!null !!undefined // false
Boolean(a)

####强制/隐式类型转换

字符串与数字的隐式强制类型转换

因为数组的valueOf()无法转换为简单类型值，于是转而调用ToString()

let a = [1,2]
let b = [3,4]
a+b // "[1,23,4]"
let n = {
  valueOf: function() { return 42;},
  toString: function() { return 4;}
}
String(n); //42 4  

布尔值到数字的隐式强制类型转换

const onlyOne= (args) => {
  let sum = 0;
  for(let i = 0,len = args.length; i < len; i++) {
    sum += Number(!!args[i]);
  }
  return sum === 1;
}
a = true;
b = false;
p(onlyOne([a,b]))

&& 和 ||

|| 返回的是对应的值 不同于C语言中的 true | false
守护运算符&&

function fn() {
	console.log(a);
}
a && fn()
//  fn在条件判断通过时才会执行

其他类型和布尔类型之间的相等比较

如果Type(x)是boolean类型，结果返回 ToNumber(x) == y

let x = true;
let y = "42"
x == y; // false
// x被强制转换为1;    1 == '42'

null undefined 之前的强制类型转换是安全的

对象与非对象之间的相等比较

对象通过 Topromitive进行强制类型转换（如 toString()、 valueOf()）

ES6中出现的 symbol 类型不能够被隐式类型转换

var s2= Sumbol("not cool");
s2 + ""  // TypeError

2. 抽象关系比较
   2.1 双方都是字符串，按照字母顺序来比较
   2.2 为了保证安全，应该在关系比较中进行显示强制类型转化；

var a = { b : 2};
var b = { b : 3};
a > b //flase
a == b //false
a < b //false
a >= b // true  a<=b 被处理为 !(a>b) 小于等于其实是不大于
a <= b //true

运算符优先级

Javascript中的 && 和 || 运算符返回它们其中一个操作数的值，而非 true 或者 false