共计 6909 个字符,预计需要花费 18 分钟才能阅读完成。
前言
请讲下
JavaScript
中的数据类型?
前端面试中,预计大家都被这么问过。
答:Javascript
中的数据类型包含原始类型和援用类型。其中原始类型包含 null
、undefined
、boolean
、string
、symbol
、bigInt
、number
。援用类型指的是 Object
。
没错,我也是这么答复的,只是这通常是第一个问题,由这个问题能够引出很多很多的问题,比方
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
这一个性给咱们带来便当的同时,也给咱们带来了很多的类型谬误。试想一下,如果 JS
说是强类型语言,那么各个类型之间没法转换,也就有了一层隔膜或者说一层爱护,会不会更加好保护呢?——这或者就是 TypeScript
诞生的起因。
对 JavaScript
的数据类型把握,是一个前端最根本的知识点
null 还是 undefinded
定义
undefined
示意未定义的变量。null
值示意一个空对象指针。
寻根究底: 一开始的时候,
JavaScript
设计者Brendan Eich
其实只是定义了null
,null
像在Java
里一样,被当成一个对象。然而因为JavaScript
中有两种数据类型:原始数据类型和援用数据类型。Brendan Eich
感觉示意 ” 无 ” 的值最好不是对象。
所以 Javascript
的设计是 null 是一个示意 ” 无 ” 的对象,转为数值时为 0;undefined 是一个示意 ” 无 ” 的原始值,转为数值时为 NaN。
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
五种空值和假值,别离为 undefined,null,false,””,0,NAN
这有时候很容易导致一些问题,比方
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"
JavaScript
中的值是由一个示意类型的标签和理论数据值示意的。第一版的 JavaScript
是用 32 位比特来存储值的,且是通过值的低 1 位或 3 位来辨认类型的,对象的类型标签是 000。如下
- 1:整型(int)
- 000:援用类型(object)
- 010:双精度浮点型(double)
- 100:字符串(string)
- 110:布尔型(boolean)
但有两个非凡值:
- undefined,用整数−2^30(负 2 的 30 次方,不在整型的范畴内)
- null,机器码空指针(C/C++ 宏定义),低三位也是 000
因为 null
代表的是空指针(低三位也是 000
),因而,null
的类型标签是 000
,typeof null
也因而返回 “object”。
这个算是 JavaScript
设计的一个谬误,然而也没法批改,毕竟批改的话,会影响目前现有的代码
Number——0.1+0.2 !== 0.3
景象
在 JavaScript
会存在相似如下的景象
0.1 + 0.2
0.30000000000000004
起因
咱们在对浮点数进行运算的过程中,须要将十进制转换成二进制。十进制小数转为二进制的规定如下:
对小数点当前的数乘以 2,取后果的整数局部(不是 1 就是 0),而后再用小数局部再乘以 2,再取后果的整数局部……以此类推,直到小数局部为 0 或者位数曾经够了就 OK 了。而后把取的整数局部按先后秩序排列
依据下面的规定,最初 0.1 的示意如下:
0.000110011001100110011(0011 有限循环)……
所以说,精度失落并不是语言的问题,而是浮点数存储自身固有的缺点。
JavaScript
是以 64
位双精度浮点数存储所有 Number
类型值,依照 IEEE754
标准,0.1 的二进制数只保留 52 位有效数字,即
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
在Number
对象上新增了一个极小的常量——Number.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 1
的提案。后文提到的 BigInt
扩大的是 JS
的负数边界,超过 2^53 平安整数问题。Decimal
则是解决 JS 的小数问题 -2^53。这个议案在 JS 中引入新的原生类型:decimal
(后缀 m),申明这个数字是十进制运算。
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——冲破最大的限度
JavaScript
的 Number
类型为 双精度 IEEE 754 64 位浮点类型。
在 JavaScript 中最大的值为 2^53
。
BigInt
任意精度数字类型,曾经进入 stage3 标准。BigInt
能够示意任意大的整数。要创立一个 BigInt
,咱们只须要在任意整型的字面量上加上一个 n 后缀即可。例如,把 123 写成 123n。这个全局的 BigInt(number) 能够用来将一个 Number 转换为一个 BigInt,话中有话就是说,BigInt(123) === 123n。当初让我来利用这两点来解决后面咱们提到问题:
Symbol——我是举世无双最靓的仔
定义
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 的办法?
为什么会问这个问题?
因为数组是一个非凡的存在,是咱们平时接触得最多的数据结构之一,它是一个非凡的对象,它的索引就是“一般对象”的 key
值。但它又领有一些“一般对象”没有的办法,比方 map
等
typeof
是 javascript
原生提供的判断数据类型的运算符,它会返回一个示意参数的数据类型的字符串。但咱们不能通过 typeof
判断是否为数组。因为 typeof
数组和一般对象以及 null
,都是返回 “object”
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()
是ES5
新增的办法,当不存在Array.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 Object
也为true
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
论断
依据下面的形容,集体举荐的判断办法有如下的优先级
isArray
> Object.prototype.toString.call()
> instanceof
> constructor
总结
本文针对于 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 中的任意精度整型 ](https://juejin.cn/post/684490…)
- ECMAScript 6 入门
- 在 JavaScript 中,如何判断数组是数组?