乐趣区

关于面试:面试说聊聊JavaScript中的数据类型

jiezi

前言

请讲下 JavaScript 中的数据类型？

前端面试中，预计大家都被这么问过。

答：Javascript 中的数据类型包含原始类型和援用类型。其中原始类型包含 Null、Undefined、Boolean、String、Symbol、BigInt。援用类型指的是 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 示意 ” 没有对象 ”，即该处不应该有值。，典型的用法如下

  1. 作为函数的参数，示意该函数的参数不是对象。
  2. 作为对象原型链的起点。
Object.getPrototypeOf(Object.prototype)
// null

undefined 示意 ” 短少值 ”，就是此处应该有一个值，然而还没有定义 。典型用法是：

  1. 变量被申明了，但没有赋值时，就等于 undefined。
  2. 调用函数时，应该提供的参数没有提供，该参数等于 undefined。
  3. 对象没有赋值的属性，该属性的值为 undefined。
  4. 函数没有返回值时，默认返回 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

这有时候很容易导致一些问题，比方 

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 中，如何判断数组是数组？
退出移动版