你不知道的前端数据类型（基础+进阶篇）

类型&值

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

值类型转换

Number<->String

let a = 123;
a.toString() //‘123’
String(a) //‘123’ String() 遵循toString()规范
let c = '3.14'
Number(c) //3.14

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

---

##### * 结合ES5规范谈字符串转换 如果其中一个操作数为字符串或通过调用Topermitive抽象操作后，再调用 [[DefaultValue]]，以数字作为上下文，执行拼接操作；否则进行数字加法； 「这个地方有些绕，再查下规范」  ```javascript let a = { valueOf: () => 2; toString: (num) => '44' } a+ ' ' // '2' String(a) //'44' ``` 因此我们在定义`valueOf` 和`toString`方法时要慎重，因为会影响强制类型转换结果。 * 不建议使用封装对象直接进行判断，因为返回的值始终为 true ```javascript let a = new String("abc"); typeof a // "object" a instanceof String // true Object.prototype.toString.call(a) // "[object String]" ``` ###### Number<->Boolean

// 判断多个参数下是否唯一一个为true
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]))

symbol <-> anyType

ES6中出现的 symbol 类型不能够转换为Number String

var s2= Symbol("not cool");
s2 + ""  // TypeError
Symbol("foo") === Symbol("foo"); // false

typeof 运算符能帮助识别symbol类型

typeof Symbol() === 'Symbol'
typeof Symbol('foo') === 'Symbol'

Boolean <-> String/Others

掌握真 / 假值的重点在于理解布尔强制类型转换

• 规律总结
  以下这些是假值：
  • undefined
  • null
  • false
  • +0、-0 和 NaN
  • ""
  假值的布尔强制类型转换结果为 false
• 显式调用Boolean() 进行强制类型转换

var a = "0";
var b = [];
var c = {};
var d = "";
var e = 0;
var f = null;
var g;
Boolean( a ); // true
Boolean( b ); // true
Boolean( c ); // true
Boolean( d ); // false
Boolean( e ); // false
Boolean( f ); // false
Boolean( g ); // false

• 使用 运算符 !!显式地将值强制类型转换为布尔值, 包含一次强制Boolean类型转换，将真值反转为假值再反转回来。

数字

• 判断是否相等
  设置机器精度 Number.EPSILON = Math.pow(2,-52);
  Math.abs(n1 - n2) < Number.EPSILON;

• 判断是否为整数
  Number.isInteger()
  polyfill 版本
  return typeof num == ‘number’ && num % 1 == 0

• x的引用还是副本
  x.length = 0 x.push (4,5,6,7) 并没有创建一个新数组，而是改变了当前的数组
  通过值复制传递复合值（如数组）,就需要创建一个副本；

对象

封装
var a = new Boolean(false);
得到的不是 false，而是一个真值

类型转换

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)

&& || 操作符

|| 返回的是对应的值 不同于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 之前的强制类型转换是安全的

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

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

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

数字精度

类数组：字符串和数组都是类数组，拥有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
function isNegZero(n) {
n = Number(n);
return (n === 0) && (1/n === -Infinity)
}
ES6中出现了 Object.is(...) 判断两个值是否完全相等，能够使用== / === ，不使用 Object.is() 因为前者效率更高更通用
简书同步更新 你不知道的前端数据类型（基础+进阶篇）