前端基础 Javascript

JavaScript有哪些数据类型，它们的区别？

JavaScript共有八种数据类型，分别是 Undefined、Null、Boolean、Number、String、Object、Symbol、BigInt。

其中 Symbol 和 BigInt 是ES6 中新增的数据类型：

Symbol 代表创建后独一无二且不可变的数据类型，它主要是为了解决可能出现的全局变量冲突的问题。
BigInt 是一种数字类型的数据，它可以表示任意精度格式的整数，使用 BigInt 可以安全地存储和操作大整数，即使这个数已经超出了 Number 能够表示的安全整数范围。

这些数据可以分为原始数据类型和引用数据类型：

栈：原始数据类型（undefined、null、boolean、number、string）
堆：引用数据类型（对象、数组和函数）

两种类型的区别在于存储位置的不同：

原始数据类型直接存储在栈（stack）中的简单数据段，占据空间小、大小固定，属于被频繁使用数据，所以放入栈中存储；
引用数据类型存储在堆（heap）中的对象，占据空间大、大小不固定。如果存储在栈中，将会影响程序运行的性能；引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。

堆和栈的概念存在于数据结构和操作系统内存中，在数据结构中：

在数据结构中，栈中数据的存取方式为先进后出。
堆是一个优先队列，是按优先级来进行排序的，优先级可以按照大小来规定。

在操作系统中，内存被分为栈区和堆区：

栈区内存由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
堆区内存一般由开发着分配释放，若开发者不释放，程序结束时可能由垃圾回收机制回收。

为什么会有BigInt的提案？

JavaScript中Number.MAX_SAFE_INTEGER 表示最⼤安全数字，计算结果是 9007199254740991，即在这个数范围内不会出现精度丢失（⼩数除外）。但是⼀旦超过这个范围，js就会出现计算不准确的情况，这在⼤数计算的时候不得不依靠⼀些第三⽅库进⾏解决，因此官⽅提出了BigInt来解决此问题。

数据类型检测的方式有哪些

typeof

javascript

console.log(typeof 2);               // number
console.log(typeof true);            // boolean
console.log(typeof 'str');           // string
console.log(typeof []);              // object    
console.log(typeof function(){});    // function
console.log(typeof {});              // object
console.log(typeof undefined);       // undefined
console.log(typeof null);            // object

其中数组、对象、null都会被判断为object，其他判断都正确

instanceof

instanceof 可以正确判断对象的类型，其内部运行机制是判断在其原型链中能否找到该类型的原型。

javascript

console.log(2 instanceof Number);                    // false
console.log(true instanceof Boolean);                // false 
console.log('str' instanceof String);                // false 
 
console.log([] instanceof Array);                    // true
console.log(function(){} instanceof Function);       // true
console.log({} instanceof Object);                   // true

可以看到，instanceof 只能正确判断引用数据类型，而不能判断基本数据类型。instanceof 运算符可以用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。

constructor

javascript

console.log((2).constructor === Number);                 // true
console.log((true).constructor === Boolean);             // true
console.log(('str').constructor === String);             // true
console.log(([]).constructor === Array);                 // true
console.log((function() {}).constructor === Function);   // true
console.log(({}).constructor === Object);                // true

constructor 有两个作用，一是判断数据的类型，二是对象实例通过 constrcutor 对象访问它的构造函数。需要注意，如果创建一个对象来改变它的原型，constructor就不能用来判断数据类型了

javascript

function Fn(){};
 
Fn.prototype = new Array();
 
var f = new Fn();
 
console.log(f.constructor === Fn);    // false
console.log(f.constructor === Array); // true

Object.prototype.toString.call()

Object.prototype.toString.call() 使用 Object 对象的原型方法 toString 来判断数据类型

javascript

console.log(Object.prototype.toString.call(2));             // [object Number]
console.log(Object.prototype.toString.call(true));          // [object Boolean]
console.log(Object.prototype.toString.call('str'));         // [object String]
console.log(Object.prototype.toString.call([]));            // [object Array]
console.log(Object.prototype.toString.call(function(){}));  // [object Function]
console.log(Object.prototype.toString.call({}));            // [object Object]
console.log(Object.prototype.toString.call(undefined));     // [object Undefined]
console.log(Object.prototype.toString.call(null));          // [object Null]

同样是检测对象 obj 调用 toString 方法，obj.toString() 的结果和 Object.prototype.toString.call(obj) 的结果不一样，这是为什么？

这是因为 toString 是 Object 的原型方法，而 Array、function 等类型作为 Object 的实例，都重写了 toString 方法。不同的对象类型调用toString 方法时，根据原型链的知识，调用的是对应的重写之后的 toString 方法（function类型返回内容为函数体的字符串，Array类型返回元素组成的字符串…），而不会去调用 Object 上原型 toString 方法（返回对象的具体类型），所以采用 obj.toString() 不能得到其对象类型，只能将obj 转换为字符串类型；因此，在想要得到对象的具体类型时，应该调用 Object 原型上的 toString 方法。

判断数组的方式有哪些

通过 Object.prototype.toString.call() 做判断

javascript

Object.prototype.toString.call(arr) === '[object Array]';

通过原型链做判断

javascript

arr.__proto__ === Array.prototype;

通过ES6的Array.isArray()做判断

javascript

Array.isArrray(arr);

通过 instanceof 做判断

javascript

arr instanceof Array

通过 Array.prototype.isPrototypeOf

javascript

Array.prototype.isPrototypeOf(arr)

null 和 undefined 区别

首先 undefined 和 null 都是基本数据类型，这两个基本数据类型分别都只有一个值，就是 undefined 和 null。

undefined 代表的含义是未定义，null 代表的含义是空对象。一般变量声明了但还没有定义的时候会返回 undefined，null主要用于赋值给一些可能会返回对象的变量，作为初始化。

undefined 在 JavaScript 中不是一个保留字，这意味着可以使用 undefined 来作为一个变量名，但是这样的做法是非常危险的，它会影响对 undefined 值的判断。我们可以通过一些方法获得安全的 undefined 值，比如说 void 0。

当对这两种类型使用 typeof 进行判断时，null 类型化会返回 “object”，这是一个历史遗留的问题。当使用双等号对两种类型的值进行比较时会返回 true，使用三个等号时会返回 false。

typeof null 的结果是什么，为什么？

typeof null 的结果是Object。

在 JavaScript 第一个版本中，所有值都存储在 32 位的单元中，每个单元包含一个小的 类型标签(1-3 bits) 以及当前要存储值的真实数据。类型标签存储在每个单元的低位中，共有五种数据类型：

javascript

000: object   - 当前存储的数据指向一个对象。
  1: int      - 当前存储的数据是一个 31 位的有符号整数。
010: double   - 当前存储的数据指向一个双精度的浮点数。
100: string   - 当前存储的数据指向一个字符串。
110: boolean  - 当前存储的数据是布尔值。

如果最低位是 1，则类型标签标志位的长度只有一位；如果最低位是 0，则类型标签标志位的长度占三位，为存储其他四种数据类型提供了额外两个 bit 的长度。

有两种特殊数据类型：

undefined 的值是 (-2)30(一个超出整数范围的数字)；
null 的值是机器码 NULL 指针(null 指针的值全是 0)

那也就是说 null 的类型标签也是 000，和 Object 的类型标签一样，所以会被判定为 Object。

intanceof 操作符的实现原理及实现

instanceof 运算符用于判断构造函数的 prototype 属性是否出现在对象的原型链中的任何位置。

javascript

function myInstanceof(left, right) {
  // 获取对象的原型
  let proto = Object.getPrototypeOf(left)
  // 获取构造函数的 prototype 对象
  let prototype = right.prototype; 
 
  // 判断构造函数的 prototype 对象是否在对象的原型链上
  while (true) {
    if (!proto) return false;
    if (proto === prototype) return true;
    // 如果没有找到，就继续从其原型上找，Object.getPrototypeOf方法用来获取指定对象的原型
    proto = Object.getPrototypeOf(proto);
  }
}

Map 和 Object 的区别

	Map	Object
	Map 默认情况不包含任何键，只包含显式插入的键	Object 有一个原型, 原型链上的键名有可能和自己在对象上的设置的键名产生冲突
键类型	Map的键可以是任意值，包括函数、对象或任意基本类型	Object 的键必须是 String 或是Symbol。如果使用其他类型，会被自动转换为字符串
键的顺序	Map 中的 key 是有序的。因此，当迭代的时候， Map 对象以插入的顺序返回键值	Object 的键是无序的
大小	Map 的键值对个数可以轻易地通过size 属性获取	Object 的键值对个数只能手动计算
迭代	Map 是 iterable 的，所以可以直接被迭代	迭代 Object 需要以某种方式获取它的键然后才能迭代
性能	在频繁增删键值对的场景下表现更好	在频繁添加和删除键值对的场景下未作出优化

Map 和 WeakMap 的区别

	Map	WeakMap
键类型	Map 的键可以是任何类型，包括对象、原始值（如字符串、数字等）	eakMap 的键必须是对象，不能是原始值
键的引用	Map 对键的引用是强引用，这意味着只要 Map 中存在键值对，键就不会被垃圾回收	WeakMap 对键的引用是弱引用，这意味着如果没有其他引用指向键对象，键对象可以被垃圾回收
迭代	Map 是可迭代的，可以使用 `for...of` 循环或 `forEach` 方法遍历其键值对	WeakMap 不是可迭代的
大小	Map 有一个 `size` 属性，可以直接获取其包含的键值对数量	WeakMap 没有 size 属性，也没有任何方法可以获取其包含的键值对数量

WeakMap的设计目的在于，有时想在某个对象上面存放一些数据，但是这会形成对于这个对象的引用。一旦不再需要这两个对象，就必须手动删除这个引用，否则垃圾回收机制就不会释放对象占用的内存。

JavaScript 类数组对象的定义

一个拥有 length 属性和若干索引属性的对象就可以被称为类数组对象，类数组对象和数组类似，但是不能调用数组的方法。常见的类数组对象有 arguments 和 DOM 方法的返回结果，还有一个函数也可以被看作是类数组对象，因为它含有 length 属性值，代表可接收的参数个数。

常见的类数组转换为数组的方法有这样几种：

通过 call 调用数组的 slice 方法来实现转换

javascript

Array.prototype.slice.call(arrayLike);

通过 call 调用数组的 splice 方法来实现转换

javascript

Array.prototype.splice.call(arrayLike, 0);

通过 apply 调用数组的 concat 方法来实现转换

javascript

Array.prototype.concat.apply([], arrayLike);

通过 Array.from 方法来实现转换

javascript

Array.from(arrayLike);

为什么0.1+0.2 ! == 0.3，如何让其相等

在开发过程中遇到类似这样的问题：

javascript

let n1 = 0.1
let n2 = 0.2
console.log(n1 + n2)  // 0.30000000000000004

计算机是通过二进制的方式存储数据的，所以计算机计算 0.1 + 0.2 的时候，实际上是计算的两个数的二进制的和。0.1 的二进制是 0.0001100110011001100...（1100循环），0.2的二进制是：0.00110011001100...（1100循环），这两个数的二进制都是无限循环的数。那JavaScript 是如何处理无限循环的二进制小数呢？

一般我们认为数字包括整数和小数，但是在 JavaScript 中只有一种数字类型：Number，它的实现遵循 IEEE 754 标准，使用 64位固定长度来表示，也就是标准的 double 双精度浮点数。在二进制科学表示法中，双精度浮点数的小数部分最多只能保留 52位，再加上前面的 1，其实就是保留 53位有效数字，剩余的需要舍去，遵从“0舍1入”的原则。

根据这个原则，0.1 和 0.2 的二进制数相加，再转化为十进制数就是：0.30000000000000004

下面看一下双精度数是如何保存的： IEEE 754

第一部分（蓝色）：用来存储符号位（sign），用来区分正负数，0 表示正数，占用 1位
第二部分（绿色）：用来存储指数（exponent），占用 11位
第三部分（红色）：用来存储小数（fraction），占用 52位

对于0.1，它的二进制为：

javascript

0.00011001100110011001100110011001100110011001100110011001 10011...

转为科学计数法（科学计数法的结果就是浮点数）：

javascript

1.1001100110011001100110011001100110011001100110011001*2^-4

可以看出0.1的符号位为0，指数位为-4，小数位为：

javascript

1001100110011001100110011001100110011001100110011001

那么问题又来了，指数位是负数，该如何保存呢？

IEEE标准规定了一个偏移量，对于指数部分，每次都加这个偏移量进行保存，这样即使指数是负数，那么加上这个偏移量也就是正数了。由于JavaScript的数字是双精度数，这里就以双精度数为例，它的指数部分为 11位，能表示的范围就是 0~2047，IEEE固定双精度数的偏移量为 1023。

当指数位不全是0也不全是1时(规格化的数值)，IEEE规定，阶码计算公式为 e-Bias。此时e最小值是1，则1-1023= -1022，e最大值是2046，则2046-1023=1023，可以看到，这种情况下取值范围是-1022~1013。
当指数位全部是0的时候(非规格化的数值)，IEEE规定，阶码的计算公式为1-Bias，即1-1023= -1022。
当指数位全部是1的时候(特殊值)，IEEE规定这个浮点数可用来表示3个特殊值，分别是正无穷，负无穷，NaN。具体的，小数位不为0的时候表示NaN；小数位为0时，当符号位s=0时表示正无穷，s=1时候表示负无穷。

对于上面的0.1的指数位为-4，-4+1023 = 1019 转化为二进制就是：1111111011.

所以，0.1表示为：

javascript

0 1111111011 1001100110011001100110011001100110011001100110011001

说了这么多，是时候该最开始的问题了，如何实现 0.1+0.2=0.3 呢？

对于这个问题，一个直接的解决方法就是设置一个误差范围，通常称为“机器精度”。对JavaScript来说，这个值通常为2-52，在ES6中，提供了Number.EPSILON 属性，而它的值就是2-52，只要判断0.1+0.2-0.3是否小于Number.EPSILON，如果小于，就可以判断为0.1+0.2===0.3

javascript

function numberepsilon(arg1,arg2){                   
  return Math.abs(arg1 - arg2) < Number.EPSILON;        
}        

console.log(numberepsilon(0.1 + 0.2, 0.3)); // true

typeof NaN 的结果是什么？

NaN 指 “不是一个数字”（not a number），NaN 是一个“警戒值”（sentinel value，有特殊用途的常规值），用于指出数字类型中的错误情况，即“执行数学运算没有成功，这是失败后返回的结果”。

javascript

typeof NaN; // "number"

NaN 是一个特殊值，它和自身不相等，是唯一一个非自反（自反，reflexive，即 x === x 不成立）的值。而 NaN !== NaN 为 true。

isNaN 和 Number.isNaN 函数的区别？

函数 isNaN 接收参数后，会尝试将这个参数转换为数值，任何不能被转换为数值的的值都会返回 true，因此非数字值传入也会返回 true ，会影响 NaN 的判断。
函数 Number.isNaN 会首先判断传入参数是否为数字，如果是数字再继续判断是否为 NaN ，不会进行数据类型的转换，这种方法对于 NaN 的判断更为准确。

其他值到字符串的转换规则？

Null 和 Undefined 类型，null 转换为 "null"，undefined 转换为 "undefined"，
Boolean 类型，true 转换为 "true"，false 转换为 "false"。
Number 类型的值直接转换，不过那些极小和极大的数字会使用指数形式。
Symbol 类型的值直接转换，但是只允许显式强制类型转换，使用隐式强制类型转换会产生错误。
对普通对象来说，除非自行定义 toString() 方法，否则会调用 toString()（Object.prototype.toString()）来返回内部属性 [[Class]] 的值，如"[object Object]"。如果对象有自己的 toString() 方法，字符串化时就会调用该方法并使用其返回值。

其他值到数字值的转换规则？

Undefined 类型的值转换为 NaN。
Null 类型的值转换为 0。
Boolean 类型的值，true 转换为 1，false 转换为 0。
String 类型的值转换如同使用 Number() 函数进行转换，如果包含非数字值则转换为 NaN，空字符串为 0。
Symbol 类型的值不能转换为数字，会报错。
对象（包括数组）会首先被转换为相应的基本类型值，如果返回的是非数字的基本类型值，则再遵循以上规则将其强制转换为数字。

为了将值转换为相应的基本类型值，抽象操作 ToPrimitive 会首先（通过内部操作 DefaultValue）检查该值是否有valueOf()方法。如果有并且返回基本类型值，就使用该值进行强制类型转换。如果没有就使用 toString() 的返回值（如果存在）来进行强制类型转换。

如果 valueOf() 和 toString() 均不返回基本类型值，会产生 TypeError 错误。

其他值到布尔类型的值的转换规则？

以下这些是假值：

undefined
null
false
+0、-0 和 NaN
""

假值的布尔强制类型转换结果为 false。从逻辑上说，假值列表以外的都应该是真值。

|| 和 && 操作符的返回值？

|| 和 && 首先会对第一个操作数执行条件判断，如果其不是布尔值就先强制转换为布尔类型，然后再执行条件判断。

对于 || 来说，如果条件判断结果为 true 就返回第一个操作数的值，如果为 false 就返回第二个操作数的值。
&& 则相反，如果条件判断结果为 true 就返回第二个操作数的值，如果为 false 就返回第一个操作数的值。

|| 和 && 返回它们其中一个操作数的值，而非条件判断的结果

Object.is() 与比较操作符 “===”、“==” 的区别？

使用双等号（==）进行相等判断时，如果两边的类型不一致，则会进行强制类型转化后再进行比较。
使用三等号（===）进行相等判断时，如果两边的类型不一致时，不会做强制类型准换，直接返回 false。
使用 Object.is 来进行相等判断时，一般情况下和三等号的判断相同，它处理了一些特殊的情况，比如 -0 和 +0 不再相等，两个 NaN 是相等的。

什么是 JavaScript 中的包装类型？

在 JavaScript 中，基本类型是没有属性和方法的，但是为了便于操作基本类型的值，在调用基本类型的属性或方法时 JavaScript 会在后台隐式地将基本类型的值转换为对象，如：

javascript

const a = "abc";
a.length; // 3
a.toUpperCase(); // "ABC"

在访问 'abc'.length 时，JavaScript 将 'abc' 在后台转换成 String('abc')，然后再访问其 length 属性。

JavaScript也可以使用 Object 函数显式地将基本类型转换为包装类型：

javascript

var a = 'abc'
Object(a) // String {"abc"}

也可以使用 valueOf 方法将包装类型倒转成基本类型

javascript

var a = 'abc'
var b = Object(a)
var c = b.valueOf() // 'abc'

看看如下代码会打印出什么：

javascript

var a = new Boolean( false );
if (!a) {
	console.log( "Oops" ); // never runs
}

答案是什么都不会打印，因为虽然包裹的基本类型是false，但是false被包裹成包装类型后就成了对象，所以其非值为false，所以循环体中的内容不会运行。

JavaScript 中如何进行隐式类型转换？

首先要介绍 ToPrimitive 方法，这是 JavaScript 中每个值隐含的自带的方法，用来将值（无论是基本类型值还是对象）转换为基本类型值。如果值为基本类型，则直接返回值本身；如果值为对象，其看起来大概是这样：

javascript

/**
* @obj 需要转换的对象
* @type 期望的结果类型
*/
ToPrimitive(obj, type)

type的值为 number 或者 string。

（1）当 type 为 number 时规则如下：

调用 obj 的 valueOf 方法，如果为原始值，则返回，否则下一步；
调用 obj的 toString 方法，后续同上；
抛出 TypeError 异常。

（2）当 type 为 string 时规则如下：

调用 obj 的 toString 方法，如果为原始值，则返回，否则下一步；
调用 obj 的 valueOf 方法，后续同上；
抛出 TypeError 异常。

可以看出两者的主要区别在于调用toString和valueOf的先后顺序。默认情况下：

如果对象为 Date 对象，则type默认为string；
其他情况下，type默认为number。

总结上面的规则，对于 Date 以外的对象，转换为基本类型的大概规则可以概括为一个函数：

javascript

var objToNumber = value => Number(value.valueOf().toString())
objToNumber([]) === 0
objToNumber({}) === NaN

而 JavaScript 中的隐式类型转换主要发生在 +、-、*、/ 以及 ==、>、< 这些运算符之间。而这些运算符只能操作基本类型值，所以在进行这些运算前的第一步就是将两边的值用 ToPrimitive 转换成基本类型，再进行操作。

以下是基本类型的值在不同操作符的情况下隐式转换的规则（对于对象，其会被ToPrimitive转换成基本类型，所以最终还是要应用基本类型转换规则）：

+操作符，+ 操作符的两边有至少一个 string 类型变量时，两边的变量都会被隐式转换为字符串；其他情况下两边的变量都会被转换为数字。

javascript

1 + '23' // '123'
1 + false // 1 
1 + Symbol() // Uncaught TypeError: Cannot convert a Symbol value to a number
'1' + false // '1false'
false + true // 1

-、*、\ 操作符，NaN也是一个数字

javascript

1 * '23' // 23
1 * false // 0
1 / 'aa' // NaN

== 操作符

操作符两边的值都尽量转成 number

javascript

3 == true // false, 3 转为number为3，true转为number为1
'0' == false //true, '0'转为number为0，false转为number为0
'0' == 0 // '0'转为number为0

< 和 > 比较符

如果两边都是字符串，则比较字母表顺序：

javascript

'ca' < 'bd' // false
'a' < 'b' // true

其他情况下，转换为数字再比较：

javascript

'12' < 13 // true
false > -1 // true

以上说的是基本类型的隐式转换，而对象会被 ToPrimitive 转换为基本类型再进行转换：

javascript

var a = {}
a > 2 // false

其对比过程如下：

javascript

a.valueOf() // {}, 上面提到过，ToPrimitive默认type为number，所以先valueOf，结果还是个对象，下一步
a.toString() // "[object Object]"，现在是一个字符串了
Number(a.toString()) // NaN，根据上面 < 和 > 操作符的规则，要转换成数字
NaN > 2 //false，得出比较结果

又比如：

javascript

var a = {name:'Jack'}
var b = {age: 18}
a + b // "[object Object][object Object]"

运算过程如下：

javascript

a.valueOf() // {}，上面提到过，ToPrimitive默认type为number，所以先valueOf，结果还是个对象，下一步
a.toString() // "[object Object]"
b.valueOf() // 同理
b.toString() // "[object Object]"
a + b // "[object Object][object Object]"

object.assign和扩展运算法是深拷贝还是浅拷贝

两者都是浅拷贝。

Object.assign()方法接收的第一个参数作为目标对象，后面的所有参数作为源对象。然后把所有的源对象合并到目标对象中。它会修改了一个对象，因此会触发 ES6 setter。
扩展操作符（…） 使用它时，数组或对象中的每一个值都会被拷贝到一个新的数组或对象中。它不复制继承的属性或类的属性，但是它会复制ES6的 symbols 属性。

如何判断一个对象是空对象

使用JSON自带的.stringify方法来判断

javascript

if (Json.stringify(Obj) == '{}' ) {
  console.log('空对象');
}

使用 ES6 新增的方法 Object.keys() 来判断

javascript

if (Object.keys(Obj).length < 0) {
  console.log('空对象');
}

let、const、var的区别

（1）块级作用域：块作用域由 { } 包括，let和const具有块级作用域，var不存在块级作用域。块级作用域解决了ES5中的两个问题：

内层变量可能覆盖外层变量
用来计数的循环变量泄露为全局变量

（2）变量提升：var存在变量提升，let和const不存在变量提升，即在变量只能在声明之后使用，否在会报错。

（3）给全局添加属性：浏览器的全局对象是 window，Node的全局对象是 global。var声明的变量为全局变量，并且会将该变量添加为全局对象的属性，但是let和const不会。

（4）重复声明：var声明变量时，可以重复声明变量，后声明的同名变量会覆盖之前声明的遍历。const和let不允许重复声明变量。

（5）暂时性死区：在使用let、const命令声明变量之前，该变量都是不可用的。这在语法上，称为暂时性死区。使用var声明的变量不存在暂时性死区。

（6）初始值设置：在变量声明时，var 和 let 可以不用设置初始值。而const声明变量必须设置初始值。

（7）指针指向：let 和 const 都是ES6新增的用于创建变量的语法。 let创建的变量是可以更改指针指向（可以重新赋值）。但const声明的变量是不允许改变指针的指向。

const对象的属性可以修改吗

const 保证的并不是变量的值不能改动，而是变量指向的那个内存地址不能改动。对于基本类型的数据（数值、字符串、布尔值），其值就保存在变量指向的那个内存地址，因此等同于常量。

但对于引用类型的数据（主要是对象和数组）来说，变量指向数据的内存地址，保存的只是一个指针，const只能保证这个指针是固定不变的，至于它指向的数据结构是不是可变的，就完全不能控制了。

箭头函数与普通函数的区别

（1）this 绑定

普通函数有自己的 this 值，取决于它是如何被调用的。
箭头函数没有自己的 this 值，它会捕获其所在上下文的 this 值。所以箭头函数中this的指向在它在定义时已经确定了，之后不会改变。

javascript

const id = 'GLOBAL';
const obj = {
  id: 'OBJ',
  a: function() {
    console.log(this.id);
  },
  b: () => {
    console.log(this.id);
  }
};
obj.a();    // 'OBJ'
obj.b();    // 'GLOBAL'
new obj.a()  // undefined
new obj.b()  // Uncaught TypeError: obj.b is not a constructor

对象 obj 的方法 b 是使用箭头函数定义的，这个函数中的 this 就永远指向它定义时所处的全局执行环境中的 this，即便这个函数是作为对象 obj 的方法调用，this依旧指向 Window 对象。需要注意，定义对象的大括号 {} 是无法形成一个单独的执行环境的，它依旧是处于全局执行环境中。

call()、apply()、bind()等方法不能改变箭头函数中 this 的指向

javascript

const id = 'Global';
const fun1 = () => {
  console.log(this.id)
};
fun1();                       // 'Global'
fun1.call({ id: 'Obj' });     // 'Global'
fun1.apply({ id: 'Obj' });    // 'Global'
fun1.bind({ id: 'Obj' })();   // 'Global'

（2）arguments 对象：

普通函数有 arguments 对象，包含所有传入的参数。
箭头函数没有 arguments 对象。在箭头函数中访问arguments实际上获得的是它外层函数的arguments值。

（3）箭头函数没有 prototype （4）箭头函数不能用作 Generator 函数，不能使用 yeild 关键字

new 操作符都做了什么

创建一个对象
将构造函数的作用域赋给新对象（也就是将对象的__proto__属性指向构造函数的prototype属性）
指向构造函数中的代码，构造函数中的this指向该对象（也就是为这个对象添加属性和方法）
返回新的对象

手写 new 操作符

如果 new 一个箭头函数的会怎么样

箭头函数是ES6中的提出来的，它没有prototype，也没有自己的 this指向，更不可以使用 arguments参数，所以不能 new一个箭头函数。

new 操作符的实现步骤如下：

创建一个对象
将构造函数的作用域赋给新对象（也就是将对象的__proto__属性指向构造函数的prototype属性）
指向构造函数中的代码，构造函数中的this指向该对象（也就是为这个对象添加属性和方法）
返回新的对象

所以，上面的第二、三步，箭头函数都是没有办法执行的

前端基础 Javascript ​

JavaScript有哪些数据类型，它们的区别？ ​

为什么会有BigInt的提案？ ​

数据类型检测的方式有哪些 ​

判断数组的方式有哪些 ​

null 和 undefined 区别 ​

typeof null 的结果是什么，为什么？ ​

intanceof 操作符的实现原理及实现 ​

Map 和 Object 的区别 ​

Map 和 WeakMap 的区别 ​

JavaScript 类数组对象的定义 ​

为什么0.1+0.2 ! == 0.3，如何让其相等 ​

typeof NaN 的结果是什么？ ​

isNaN 和 Number.isNaN 函数的区别？ ​

其他值到字符串的转换规则？ ​

其他值到数字值的转换规则？ ​

其他值到布尔类型的值的转换规则？ ​

|| 和 && 操作符的返回值？ ​

Object.is() 与比较操作符 “===”、“==” 的区别？ ​

什么是 JavaScript 中的包装类型？ ​

JavaScript 中如何进行隐式类型转换？ ​

object.assign和扩展运算法是深拷贝还是浅拷贝 ​

如何判断一个对象是空对象 ​

let、const、var的区别 ​

const对象的属性可以修改吗 ​

箭头函数与普通函数的区别 ​

new 操作符都做了什么 ​

如果 new 一个箭头函数的会怎么样 ​

前端基础 Javascript

JavaScript有哪些数据类型，它们的区别？

为什么会有BigInt的提案？

数据类型检测的方式有哪些

判断数组的方式有哪些

null 和 undefined 区别

typeof null 的结果是什么，为什么？

intanceof 操作符的实现原理及实现

Map 和 Object 的区别

Map 和 WeakMap 的区别

JavaScript 类数组对象的定义

为什么0.1+0.2 ! == 0.3，如何让其相等

typeof NaN 的结果是什么？

isNaN 和 Number.isNaN 函数的区别？

其他值到字符串的转换规则？

其他值到数字值的转换规则？

其他值到布尔类型的值的转换规则？

|| 和 && 操作符的返回值？

Object.is() 与比较操作符 “===”、“==” 的区别？

什么是 JavaScript 中的包装类型？

JavaScript 中如何进行隐式类型转换？

object.assign和扩展运算法是深拷贝还是浅拷贝

如何判断一个对象是空对象

let、const、var的区别

const对象的属性可以修改吗

箭头函数与普通函数的区别

new 操作符都做了什么

如果 new 一个箭头函数的会怎么样