面试说：聊聊JavaScript中的数据类型
前言
请讲下
中的数据类型？JavaScript
前端面试中，估计大家都被这么问过。
答：
JavascriptnullundefinedbooleanstringsymbolbigIntnumberObject没错，我也是这么回答的，只是这通常是第一个问题，由这个问题可以引出很多很多的问题，比如
-
和Null
有什么区别？前端的判空有哪些需要注意的？Undefined -
为什么是typeof null
?object - 为什么
要提出ES6
？Symbol -
解决了什么问题？BigInt - 为什么
你如何解决这个问题？0.1 + 0.2 !== 0.3? - 如何判断一个值是数组？
- ...
弱类型语言
因为
JavaScript var foo = 42; // foo is a Number now
foo = "bar"; // foo is a String now
foo = true; // foo is a Boolean now 这一特性给我们带来便利的同时，也给我们带来了很多的类型错误。试想一下，假如
JSTypeScript对
JavaScriptnull 还是 undefinded
定义
undefinednull追本溯源: 一开始的时候，
设计者JavaScript其实只是定义了Brendan Eich，null像在null里一样，被当成一个对象。但是因为Java中有两种数据类型：原始数据类型和引用数据类型。JavaScript觉得表示"无"的值最好不是对象。Brendan Eich
所以
Javascript Number(null)
// 0
5 + null
// 5
Number(undefined)
// NaN
5 + undefined
// NaN Null 和 Undefined 的区别和应用
null表示"没有对象"，即该处不应该有值。 ，典型的用法如下
- 作为函数的参数，表示该函数的参数不是对象。
- 作为对象原型链的终点。
Object.getPrototypeOf(Object.prototype)
// null undefined表示"缺少值"，就是此处应该有一个值，但是还没有定义 。典型用法是：
- 变量被声明了，但没有赋值时，就等于
。undefined - 调用函数时，应该提供的参数没有提供，该参数等于
。undefined - 对象没有赋值的属性，该属性的值为
。undefined - 函数没有返回值时，默认返回
。undefined
var i;
i // undefined
function f(x){console.log(x)}
f() // undefined
var o = new Object();
o.p // undefined
var x = f();
x // undefined 判空应该注意什么？
javaScript这有时候很容易导致一些问题，比如
let a = 0;
console.log(a || '/'); // 本意是只要 a 为 null 或者 Undefined 的时候，输出 '/'，但实际上只要是我们以上的五种之一就输出 '/' 当然我们可以写成
let a = 0;
if (a === null || a === undefined) {
console.log('/');
} else {
console.log(a);
} 始终不是很优雅，所以 ES规范 提出了空值合并操作符（??）
空值合并操作符（??）是一个逻辑操作符，当左侧的操作数为 null 或者 undefined 时，返回其右侧操作数，否则返回左侧操作数。
上面的例子可以写成：
let a = 0;
console.log(a??'/'); // 0 typeof null——JS 犯的错
typeof null // "object"
JavaScriptJavaScript- 1：整型（int）
- 000：引用类型（object）
- 010：双精度浮点型（double）
- 100：字符串（string）
- 110：布尔型（boolean）
但有两个特殊值：
- undefined，用整数−2^30（负2的30次方，不在整型的范围内）
- null，机器码空指针（C/C++ 宏定义），低三位也是000
由于
null000），因此，null000typeof null这个算是
JavaScriptNumber——0.1+0.2 !== 0.3
现象
在
JavaScript 0.1 + 0.2
0.30000000000000004 原因
我们在对浮点数进行运算的过程中，需要将十进制转换成二进制。十进制小数转为二进制的规则如下：
对小数点以后的数乘以2，取结果的整数部分（不是1就是0），然后再用小数部分再乘以2，再取结果的整数部分……以此类推，直到小数部分为0或者位数已经够了就OK了。然后把取的整数部分按先后次序排列
根据上面的规则，最后 0.1 的表示如下：
0.000110011001100110011（0011无限循环）…… 所以说，精度丢失并不是语言的问题，而是浮点数存储本身固有的缺陷。
JavaScript64NumberIEEE754 1.100110011001100110011001100110011001100110011001101 * 2^(-4) 同理，0.2的二进制数为
1.100110011001100110011001100110011001100110011001101 * 2^(-3) 这样在进制之间的转换中精度已经损失。运算的时候如下
0.00011001100110011001100110011001100110011001100110011010
+0.00110011001100110011001100110011001100110011001100110100
------------------------------------------------------------
=0.01001100110011001100110011001100110011001100110011001110 所以导致了最后的计算结果中 0.1 + 0.2 !== 0.3
如何解决
- 将数字转成整数
function add(num1, num2) {
const num1Digits = (num1.toString().split('.')[1] || '').length;
const num2Digits = (num2.toString().split('.')[1] || '').length;
const baseNum = Math.pow(10, Math.max(num1Digits, num2Digits));
return (num1 * baseNum + num2 * baseNum) / baseNum;
} -
类库
上有许多支持NPM
和JavaScript
的数学库，比如Node.js
，math.js
,decimal.js
等等D.js -
ES6
在ES6
对象上新增了一个极小的常量——NumberNumber.EPSILON
Number.EPSILON
// 2.220446049250313e-16
Number.EPSILON.toFixed(20)
// "0.00000000000000022204" 引入一个这么小的量，目的在于为浮点数计算设置一个误差范围，如果误差能够小于
Number.EPSILON function withinErrorMargin (left, right) {
return Math.abs(left - right) < Number.EPSILON
}
withinErrorMargin(0.1+0.2, 0.3) 未来的解决方案——TC39 Decimal proposal
目前处于
Stage 1BigIntJSDecimaldecimal let zero_point_three = 0.1m + 0.2m;
assert(zero_point_three === 0.3m);
// 提案中的例子
function calculateBill(items, tax) {
let total = 0m;
for (let {price, count} of items) {
total += price * BigDecimal(count);
}
return BigDecimal.round(total * (1m + tax), {maximumFractionDigits: 2, round: "up"});
}
let items = [{price: 1.25m, count: 5}, {price: 5m, count: 1}];
let tax = .0735m;
console.log(calculateBill(items, tax)); 拓展——浮点数在内存中的存储
所以最终浮点数在内存中的存储是什么样的呢？
EEE754(-1)^S * M * 2^E
各符号的意思如下：S，是符号位，决定正负，0时为正数，1时为负数。M，是指有效位数，大于1小于2。E，是指数位。
Javascript 是 64 位的双精度浮点数，最高的 1 位是符号位S，接着的 11 位是指数E，剩下的 52 位为有效数字M。
可借助 这个可视化工具 查看浮点数在内存中的二进制表示）
BigInt——突破最大的限制
JavaScriptNumber在 JavaScript 中最大的值为
2^53
BigIntBigIntBigIntSymbol——我是独一无二最靓的仔
定义
ES6 引入了一种新的原始数据类型
Symbol let s = Symbol();
typeof s
// "symbol" 应用场景
-
定义一组常量，保证这组常量都是不相等的。消除魔法字符串
-
对象中保证不同的属性名
let mySymbol = Symbol();
// 第一种写法
let a = {};
a[mySymbol] = 'Hello!';
// 第二种写法
let a = {
[mySymbol]: 'Hello!'
};
// 第三种写法
let a = {};
Object.defineProperty(a, mySymbol, { value: 'Hello!' });
// 以上写法都得到同样结果
a[mySymbol] // "Hello!" -
中的Vue
和provide
。inject
和provide
可以允许一个祖先组件向其所有子孙后代注入一个依赖，不论组件层次有多深，并在起上下游关系成立的时间里始终生效。但这个侵入性也是非常强的，使用inject
作为Symbols
可以避免对减少对组件代码干扰，不会有相同命名等问题key
数组——对象中一个特殊的存在
请说下判断 Array 的方法？
为什么会问这个问题？
因为数组是一个特殊的存在，是我们平时接触得最多的数据结构之一，它是一个特殊的对象，它的索引就是“普通对象”的
keymap
typeofjavascripttypeoftypeofnull const a = null;
const b = {};
const c= [];
console.log(typeof(a)); //Object
console.log(typeof(b)); //Object
console.log(typeof(c)); //Object 判断数组的方法
-
。Object.prototype.toString.call()
每一个继承
的对象都有Object
方法，如果toString
方法没有重写的话，会返回toString
，其中[Object type]
为对象的类型type
const a = ['Hello','Howard'];
const b = {0:'Hello',1:'Howard'};
const c = 'Hello Howard';
Object.prototype.toString.call(a);//"[object Array]"
Object.prototype.toString.call(b);//"[object Object]"
Object.prototype.toString.call(c);//"[object String]" - Array.isArray()
const a = [];
const b = {};
Array.isArray(a);//true
Array.isArray(b);//false
Array.isArray()ES5Array.isArray()Object.prototype.toString.call() if (!Array.isArray) {
Array.isArray = function(arg) {
return Object.prototype.toString.call(arg) === '[object Array]';
};
} -
。instanceof
运算符可以用来判断某个构造函数的instanceof
属性所指向的對象是否存在于另外一个要检测对象的原型链上。因为数组的构造函数是prototype
，所以可以通过以下判断。 注意：因为数组也是对象，所以Array
也为a instanceof Objecttrue
const a = [];
const b = {};
console.log(a instanceof Array);//true
console.log(a instanceof Object);//true,在数组的原型链上也能找到Object构造函数
console.log(b instanceof Array);//false -
。通过构造函数实例化的实例，拥有一个constructor
属性。constructor
function B() {};
let b = new B();
console.log(b.constructor === B) // true 而数组是由一个叫
Array let c = [];
console.log(c.constructor === Array) // true 注意：constructor 是会被改变的。所以不推荐这样判断
let c = [];
c.constructor = Object;
console.log(c.constructor === Array); // false 结论
根据上面的描述，个人推荐的判断方法有如下的优先级
isArrayObject.prototype.toString.call()instanceofconstructor总结
本文针对于
JavaScript最后，欢迎大家关注我的公众号——前端杂货铺，技术问题多讨论~
参考
- undefined与null的区别
- The history of “typeof null”
- 0.1 + 0.2不等于0.3？为什么JavaScript有这种“骚”操作？
- 深入理解JavaScript中的精度丢失
- JavaScript著名面试题: 0.1 + 0.2 !== 0.3，即将成为过去
- [译]BigInt：JavaScript 中的任意精度整型
- ECMAScript 6 入门
- 在JavaScript中，如何判断数组是数组？