一.数组

1.重磅！超详细的 JS 数组方法整理出来了
在本节，我们仅仅围绕数组最基本的操作进行介绍，这远不是数组的全部。关于数组，还有太多太多的故事要讲——实际上，单就其重要的方法的使用：如concat、some、slice、join、sort、pop、push 等等这些，就足以说上个把钟头。

本节暂时不对数组 API 作集中讲解，因为罗列 API 没有意义——脱离场景去记忆 API 实在是一件太痛苦的事情，这会挫伤各位继续走下去的积极性。

关于数组的更多特性和技巧，会被打散到后续的章节中去。各位在真题解读的环节、包括在其它数据结构的讲解中，都会不可避免地再见到数组的身影。彼时数组的每一个方法都会和它对应的应用场景一起出现，相信你会有更深刻的记忆。

事实上，在 JavaScript 数据结构中，数组几乎是“基石”一般的存在。这一点，大家在下一节就会有所感触。

(一)数组的创建、访问、检测

数组是各位要认识的第一个数据结构。
作为最简单、最基础的数据结构，大多数的语言都天然地对数组有着原生的表达，JavaScript 亦然。这意味着我们可以对数组做到“开箱即用”，而不必自行模拟实现，非常方便。

考虑到日常开发过程中，数组的出镜率本身已经很高，相信它也是大多数同学最熟悉的数据结构。 即便如此，这里仍然需要提醒各位：要对数组格外走点心，毕竟后面需要它帮忙的地方会非常多。

1.认识数组并创建数组

性质: 数组是一种线性表数据结构，它用一组连续的内存空间，来存储一组具有相同类型的数据。
区别: 与其他编程语言不同，JavaScript 中的数组长度可以随时改变，数组中的每个槽位可以储存任意类型的数据，并且其数据在内存中也可以不连续。

（1） 使用数组字面量表示法
大家平时用的最多的创建方式想必就是直接方括号+元素内容这种形式：

var arr4 = [];   //创建一个空数组
var arr5 = [20];   // 创建一个包含1项数据为20的数组
var arr6 = ["lily","lucy","Tom"];   // 创建一个包含3个字符串的数组

（2）使用 Array 构造函数
不过在算法题中，很多时候我们初始化一个数组时，并不知道它内部元素的情况。这种场景下，要给大家推荐的是构造函数创建数组的方法：

无参构造

var arr1 = new Array();   //创建一个空数组

当我们以构造函数的形式创建数组时，若我们像楼上这样，不传任何参数，得到的就会是一个空数组。等价于：

const arr1 = [] 

带参构造
①不过咱们使用构造函数，可不是为了创建空数组这么无聊。
我们需要它的时候，往往是因为我们有“创造指定长度的空数组”这样的需求。需要多长的数组，就给它传多大的参数：

const arr = new Array(7) 

这样的写法就可以得到一个长度为7的数组：

②在一些场景中，这个需求会稍微变得有点复杂—— “创建一个长度确定、同时每一个元素的值也都确定的数组”。这时我们可以调用 fill 方法，假设需求是每个坑里都填上一个1，只需给它 fill 一个1：

const arr = (new Array(7)).fill(1) 

如此便可以得到一个长度为7，且每个元素都初始化为1的数组：

③如果传入一个非数值的参数或者参数个数大于 1，则表示创建一个包含指定元素的数组

var arr3 = new Array("lily","lucy","Tom");   // 创建一个包含3个字符串的数组
var array4 = new Array('23'); // ["23"]

（3）Array.of 方法创建数组(es6 新增)
ES6 为数组新增创建方法的目的之一，是帮助开发者在使用 Array 构造器时避开 js 语言的一个怪异点。
Array.of()方法总会创建一个包含所有传入参数的数组，而不管参数的数量与类型。

let arr = Array.of(1, 2);
console.log(arr.length);//2

let arr1 = Array.of(3);
console.log(arr1.length);//1
console.log(arr1[0]);//3

let arr2 = Array.of('2');
console.log(arr2.length);//1
console.log(arr2[0]);//'2'

（4）Array.from 方法创建数组(es6 新增)
在 js 中将非数组对象转换为真正的数组是非常麻烦的。在 ES6 中，将可迭代对象或者类数组对象作为第一个参数传入，Array.from()就能返回一个数组。

function arga(...args) {  //...args剩余参数数组,由传递给函数的实际参数提供
    let arg = Array.from(args);
    console.log(arg);
}

arga('arr1', 26, 'from'); // ['arr1',26,'from']

映射转换
如果你想实行进一步的数组转换，你可以向 Array.from()方法传递一个映射用的函数作为第二个参数。此函数会将数组对象的每一个值转换为目标形式，并将其存储在目标数组的对应位置上。

function arga(...args) {  
     return Array.from(args, value => value + 1);
}

let arr = arga('arr', 26, 'pop');
console.log(arr);//['arr1',27,'pop1']

如果映射函数需要在对象上工作，你可以手动传递第三个参数给 Array.from()方法，从而指定映射函数内部的 this 值。

const helper = {
  diff: 1,
  add(value) {
    return value + this.diff;
  }
}

function translate() {
 //arguments 是一个对应于传递给函数的参数的类数组对象
  return Array.from(arguments, helper.add, helper); 
}

let arr = translate('liu', 26, 'man');
console.log(arr); // ["liu1", 27, "man1"]

2.数组的访问

① 访问数组中的元素我们可以根据索引下标随机访问(时间复杂度为 O(1))，直接在中括号中指定其索引即可，这个索引通常来说是数字，用来计算元素之间的存储位置的偏移量。

arr[0] // 访问索引下标为0的元素 

② 上文提到，这个索引通常是数字，也就是说在 JavaScript 中，通过字符串也可以访问对应的元素：

arr['1'] // 1

其实，JavaScript 中的数组是一种比较特殊的对象，因为在 JavaScript 中，对象的属性名必须是字符串，这些数字索引就被转化成了字符串类型。

3.检测数组的六种方法

let arr = []
// 1. instanceof
arr instanceof Array 
// 2. constructor
arr.constructor === Array
// 3. Object.prototype.isPrototypeOf
Array.prototype.isPrototypeOf(arr)
// 4. getPrototypeOf
Object.getPrototypeOf(arr) === Array.prototype
// 5. Object.prototype.toString
Object.prototype.toString.call(arr) === '[object Array]'
// 6. Array.isArray ES6 新增
Array.isArray(arr)

1.Object.prototype.toString.call()

能准确的检测所有的数据类型

每一个继承Object的对象都有一个toString方法，如果toString方法没有被重写，会返回[Object type], type为对象的类型。

const arr = ["a", "b"]
arr.toString() // => "a, b"
Object.prototype.toString.call(arr) // => "[Object Array]"

2.Array.isArray()

用于判断对象是否为数组

Array.isArray()是ES5推出的，不支持IE6~8，使用时应考虑兼容

Array.isArray([1, 2, 3, 4]) // true
Array.isArray({a: 1}) // false
Array.isArray(new Array) // true
Array.isArray("string") // false
if(typeof Array.isArray != 'function') {
  Array.isArray = function(obj){
    return Object.prototype.toString.call(obj) == '[object Array]'
  }
}

3.instanceof

能检测array、function、object类型

instanceof用于检测构造函数的prototype属性是否出现在某个实例对象的原型链上，即 A 是否为 B 的实例：A instanceof B

1 instanceof Number  // false
'str' instanceof String  // false
true instanceof Boolean  // false
[1,2,3] instanceof Array   // true
function () {} instanceof Function  // true
{} instanceof Object  // true

instanceof 的缺点：是否处于原型链上的判断方法不严谨 instanceof 方法判断的是是否处于原型链上，而不是是不是处于原型链最后一位，所以会出现以下情况：

var arr = [1, 2, 3]
arr instanceof Array  // true
arr instanceof Object  // true

function fn() {}
fn instanceof Function  // true
fn instanceof Object   // true

所有原型链的尽头都是Object

instanceof， constructor，Object.prototype.isPrototypeOf，getPrototypeOf比较渣，丝毫不负责任，比如我们将 arr 的 __proto__ 指向了 Array.prototype 后：

let arr = {
    __proto__: Array.prototype
}
// 1. instanceof
arr instanceof Array // true
// 2. constructor
arr.constructor === Array // true
// 3. Object.prototype.isPrototypeOf
Array.prototype.isPrototypeOf(arr) // true
// 4. getPrototypeOf
Object.getPrototypeOf(arr) === Array.prototype // true

4.比较数组

1. 面试官：如何判断两个数组的内容是否相等？？？
2. js判断两个数组相等的5种方法实例

5.清空数组

要清除数组，请将数组的长度设置为 0：

let array = [“A”, “B”, “C”, “D”, “E”, “F”] 
array.length = 0 
console.log(array) // []

6.数组的分组

[1, 2, 3, 4, 5, 6, 7, 8, 9] => [[1, 2, 3],[4, 5, 6],[7, 8, 9]]，把一个一维数组变成三个三个的二维数组。

 function convertTo2DArray(arr, chunkSize) {
  var result = [];
  for (var i = 0; i < arr.length; i += chunkSize) {
    result.push(arr.slice(i, i + chunkSize));
  }
  return result;
}

var inputArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var outputArray = convertTo2DArray(inputArray, 3);

console.log(outputArray);

输出结果将是： [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
slice 不会修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组，不信的话自己可以编译一下。
这段代码中的convertTo2DArray函数接受两个参数：arr表示输入的一维数组，chunkSize表示每个子数组的大小。它使用slice方法来从输入数组中提取每个子数组，并使用循环来遍历整个数组并构建输出二维数组。最后，它返回生成的二维数组。

(二)二维数组

初学编程的同学基础如果比较薄弱，会对二维数组完全没有概念。这里咱们先简单介绍下：二维数组其实就是数组套数组，也就是每个元素都是数组的数组。
说起来有点绕口，咱们直接上图来看：

const arr = [1,2,3,4,5] 

这个数组在逻辑上的分布就是这样式儿的：

像图上这样，数组的元素是数字而非数组。整个数组的结构看上去宛如一条“线”，这就是一维数组。
而“每个元素都是数组的数组”，代码里看是这样：

const arr = [ 
   [1,2,3,4,5],
   [1,2,3,4,5], 
   [1,2,3,4,5], 
   [1,2,3,4,5], 
   [1,2,3,4,5] 
   ] 

直接把它的逻辑结构画出来看，是这样：

图中的每一行，就代表着一个数组元素。比如第 0 行，就代表着数组中 arr[0] 这个数组元素，其内容是 [1,2,3,4,5]。
每一行中的每一列，则代表一个确切的“坑”。比如第 0 行第 1 列，就代表着数组中 arr[0][1] 这个元素，其值为2，是一个确切的 number。

明白了二维数组的索引规律，现在我们来看一下二维数组的特点：从形状上看，相对于一维数组一条“线”一般的布局，二维数组更像是一个“面”。拿咱们这个例子来说，这里的二维数组逻辑分布图就宛如一个正方形。当然啦，如果我们稍微延长一下其中的一边，它也可以是一个矩形。

在数学中，形如这样长方阵列排列的复数或实数集合，被称为“矩阵”。因此二维数组的别名就叫“矩阵”。

讲到这里，如果有对“矩阵”的定义一脸懵逼的同学，也不用怕——不知道“矩阵”是啥，一点不打紧（所以快停下你复制粘贴到 Google 的手哈哈），但你必须要记住“矩阵”和“二维数组”之间的等价关系。 在算法题目中，见到“矩阵”时，能够立刻反射出它说的是二维数组，不被别名整懵逼，这就够了。

二维数组的初始化

fill 的局限性

有同学用 fill 方法用顺了手，就本能地想用 fill 解决所有的问题，比如初始化一个二维数组：

const arr =(new Array(7)).fill([]) 

乍一看没啥毛病，7个坑都被乖乖地填上了数组元素：

但是当你想修改某一个坑里的数组的值的时候：

arr[0][0] = 1 

你会发现一整列的元素都被设为了 1：

这是什么骚操作？？？
这就要从 fill 的工作机制讲起了。各位要清楚，当你给 fill 传递一个入参时，如果这个入参的类型是引用类型，那么 fill 在填充坑位时填充的其实就是入参的引用。 也就是说下图中虽然看似我们给7个坑位各初始化了一个数组：

其实这7个数组对应了同一个引用、指向的是同一块内存空间，它们本质上是同一个数组。因此当你修改第0行第0个元素的值时，第1-6行的第0个元素的值也都会跟着发生改变。

初始化一个二维数组

本着安全的原则，这里我推荐大家采纳的二维数组初始化方法非常简单（而且性能也不错）。直接用一个 for 循环来解决：

const len = arr.length
for(let i=0;i<len;i++) { 
      // 将数组的每一个坑位初始化为数组 
      arr[i] = [] 
} 

for 循环中，每一次迭代我们都通过“[]”来创建一个新的数组，这样便不会有引用指向问题带来的尴尬。

二维数组的访问

访问二维数组和访问一维数组差别不大，区别在于我们现在需要的是两层循环：

// 缓存外部数组的长度 
const outerLen = arr.length 
for(let i=0;i<outerLen;i++) { 
    // 缓存内部数组的长度 
    const innerLen = arr[i].length 
    for(let j=0;j<innerLen;j++) { 
    // 输出数组的值，输出数组的索引 
    console.log(arr[i][j],i,j) 
  } 
} 

一维数组用 for 循环遍历只需一层循环，二维数组是两层，三维数组就是三层。依次类推，N 维数组需要 N 层循环来完成遍历。

(三)数组方法

19个JavaScript数组常用方法总结
数组原型方法主要有以下这些
截至 ES10 规范，数组共包含 35 个标准的 API 方法和一个非标准的 API 方法。
创建数组：Array.of、Array.from

改变自身(9 种)：pop、push、shift、unshift、reverse、sort、splice、copyWithin、fill

不改变自身(12 种)：concat、join、slice、toString、toLocaleString、valueOf、indexOf、lastIndexOf、未形成标准的 toSource，以及 ES7 新增的方法 includes，以及 ES10 新增的方法 flat、flatMap

不会改变自身的遍历方法一共有(12 种)：forEach、every、some、filter、map、reduce、reduceRight，以及 ES6 新增的方法 find、findIndex、keys、values、entries

1.基本操作方法
数组基本操作可以归纳为 增、删、改、查，需要留意的是哪些方法会对原数组产生影响，哪些方法不会。

增

下面前三种是对原数组产生影响的增添方法，第四种则不会对原数组产生影响

• unshift()：向数组首位添加新元素
• push() ：向数组的末尾添加新元素
• splice()：对数组进行增删改
• concat()：用于连接两个或多个数组

删

下面三种都会影响原数组，最后一项不影响原数组：

• pop()：删除数组的最后一项
• shift()：删除数组的第一项
• splice()：对数组进行增删改
• slice()：按照条件查找出其中的部分元素

改

• splice()：对数组进行增删改

查

• indexOf()：检测当前值在数组中第一次出现的位置索引
• lastIndexOf(): 检测当前值在数组中最后一次出现的位置索引
• findIndex(): 返回匹配位置的索引
• find(): 返回匹配的值
• includes()：判断一个数组是否包含一个指定的值

2.排序方法

数组有两个方法可以用来对元素重新排序：

• reverse()：对数组进行倒序
• sort()：对数组的元素进行排序

3.转换方法

• join()：用指定的分隔符将数组每一项拼接为字符串
• toLocaleString()、toString():将数组转换为字符串

4.迭代方法

常用来迭代数组的方法（都不改变原数组）有如下：

• some()：判断数组中是否存在满足条件的项
• every()：判断数组中每一项都是否满足条件
• forEach()：ES5 及以下循环遍历数组每一项
• filter(): “过滤”功能
• map()：ES6 循环遍历数组每一项
• entries() 、keys() 、values(): 遍历数组

5.其他方法

• fill(): 方法能使用特定值填充数组中的一个或多个元素
• copyWithin():用于从数组的指定位置拷贝元素到数组的另一个指定位置中
• flat()、flatMap()：扁平化数组
• reduce() 和 reduceRight()累加

各个方法的基本功能详解

1. unshift()和shift()
unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。

var arr = ["Lily","lucy","Tom"];
var count = arr.unshift("Jack","Sean");
console.log(count);   // 5
console.log(arr);   //["Jack", "Sean", "Lily", "lucy", "Tom"]
var item = arr.shift();
console.log(item);   // Jack
console.log(arr);   // ["Sean", "Lily", "lucy", "Tom"]

2.push()和 pop()
push() 方法从数组末尾向数组添加元素，可以添加一个或多个元素。
pop() 方法用于删除数组的最后一个元素并返回删除的元素。

var arr = ["Lily","lucy","Tom"];
var count = arr.push("Jack","Sean");
console.log(count);  // 5
console.log(arr);   // ["Lily", "lucy", "Tom", "Jack", "Sean"]
var item = arr.pop();
console.log(item);   // Sean
console.log(arr);   // ["Lily", "lucy", "Tom", "Jack"]

3.splice()
splice()：很强大的数组方法，它有很多种用法，可以实现删除、插入和替换。

①删除元素,并返回删除的元素

可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。例如， splice(0,2)会删除数组中的前两项。

var arr = [1,3,5,7,9,11];
var arrRemoved = arr.splice(0,2);
console.log(arr);   //[5, 7, 9, 11]
console.log(arrRemoved);   //[1, 3]

②向指定索引处添加元素

可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。例如，splice(2,0,4,6)会从当前数组的位置 2 开始插入 4 和 6。

var array1 = [22, 3, 31, 12];
array1.splice(1, 0, 12, 35);  //[]
console.log(array1); // [22, 12, 35, 3, 31, 12]

③替换指定索引位置的元素

可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如，splice (2,1,4,6)会删除当前数组位置 2 的项，然后再从位置 2 开始插入 4 和 6。

const array1 = [22, 3, 31, 12];
array1.splice(1, 1, 8);   //[3]
console.log(array1);  // [22, 8, 31, 12]

4.concat()
concat() 方法用于连接两个或多个数组。
该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

var arr = [1,3,5,7];
var arrCopy = arr.concat(9,[11,13]);
console.log(arrCopy);   //[1, 3, 5, 7, 9, 11, 13]
console.log(arr);   // [1, 3, 5, 7](原数组未被修改)

从上面测试结果可以发现：传入的不是数组，则直接把参数添加到数组后面，如果传入的是数组，则将数组中的各个项添加到数组中。但是如果传入的是一个二维数组呢？

var arrCopy2 = arr.concat([9,[11,13]]);
console.log(arrCopy2);   //[1, 3, 5, 7, 9, Array[2]]
console.log(arrCopy2[5]);   //[11, 13]

5.slice()
slice()：返回从原数组中指定开始下标到结束下标之间的项组成的新数组。
slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。
在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。
如果有两个参数，该方法返回起始和结束位置之间的项，但不包括结束位置的项。
当出现负数时，将负数加上数组长度的值来替换该位置的数

var arr = [1,3,5,7,9,11];
var arrCopy = arr.slice(1);
var arrCopy2 = arr.slice(1,4);
var arrCopy3 = arr.slice(1,-2);//相当于arr.slice(1,4)
var arrCopy4 = arr.slice(-4,-1);//相当于arr.slice(2,5)
console.log(arr);   //[1, 3, 5, 7, 9, 11](原数组没变)
console.log(arrCopy);   //[3, 5, 7, 9, 11]
console.log(arrCopy2);   //[3, 5, 7]
console.log(arrCopy3);   //[3, 5, 7]
console.log(arrCopy4);   //[5, 7, 9]

6.includes() es7 新增
includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则 false。

参数有两个，其中第一个是（必填）需要查找的元素值，第二个是（可选）开始查找元素的位置

const array1 = [22, 3, 31, 12, 'arr'];
const includes = array1.includes(31);
console.log(includes); // true

const includes1 = array1.includes(31, 3); // 从索引3开始查找31是否存在
console.log(includes1); // false

需要注意的是：includes使用===运算符来进行值比较，仅有一个例外：NaN 被认为与自身相等。

let values = [1, NaN, 2];
console.log(values.indexOf(NaN));//-1
console.log(values.includes(NaN));//true

7. find()和 findIndex()
find()与 findIndex()方法均接受两个参数：一个回调函数，一个可选值用于指定回调函数内部的 this。

该回调函数可接受三个参数：数组的某个元素，该元素对应的索引位置，以及该数组本身。

该回调函数应当在给定的元素满足你定义的条件时返回 true，而 find()和 findIndex()方法均会在回调函数第一次返回 true 时停止查找。

二者的区别是：find()方法返回匹配的值，而 findIndex()返回匹配位置的索引。

let arr = [1, 2, 3, 'arr', 5, 1, 9];

console.log(arr.find((value, keys, arr) => {
    return value > 2;
})); // 3 返回匹配的值

console.log(arr.findIndex((value, keys, arr) => {
    return value > 2;
})); // 2 返回匹配位置的索引

8.indexOf()和 lastIndexOf()
接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。
indexOf()： 从数组的开头（位置 0）开始向后查找。
lastIndexOf： 从数组的末尾开始向前查找。
这两个方法都返回要查找的项在数组中的位置，或者在没找到的情况下返回-1。在比较第一个参数与数组中的每一项时，会使用全等操作符。

var arr = [1,3,5,7,7,5,3,1];
console.log(arr.indexOf(5));   //2
console.log(arr.lastIndexOf(5));   //5
console.log(arr.indexOf(5,2));   //2
console.log(arr.lastIndexOf(5,4));   //2
console.log(arr.indexOf("5"));   //-1

9.sort()
sort() 方法用于对数组的元素进行排序。
排序顺序可以是字母或数字，并按升序或降序。
默认排序顺序为按字母升序。

var arr1 = ["a", "d", "c", "b"];
console.log(arr1.sort());   // ["a", "b", "c", "d"]
arr2 = [13, 24, 51, 3];
console.log(arr2.sort());   // [13, 24, 3, 51]
console.log(arr2);   // [13, 24, 3, 51](元数组被改变)

为了解决上述问题，sort()方法可以接收一个比较函数作为参数，以便我们指定哪个值位于哪个值的前面。

比较函数接收两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等则返回 0，如果第一个参数应该位于第二个之后则返回一个正数。以下就是一个简单的比较函数：

function compare(value1, value2) {
    if (value1 < value2) {
     return -1;
    } else if (value1 > value2) {
     return 1;
    } else {
     return 0;
    }
}
arr2 = [13, 24, 51, 3];
console.log(arr2.sort(compare));   // [3, 13, 24, 51]

如果需要通过比较函数产生降序排序的结果，只要交换比较函数返回的值即可：

function compare(value1, value2) {
    if (value1 < value2) {
     return 1;
    } else if (value1 > value2) {
     return -1;
    } else {
     return 0;
    }
}
arr2 = [13, 24, 51, 3];
console.log(arr2.sort(compare));   // [51, 24, 13, 3]

10.reverse()
reverse() 方法用于颠倒数组中元素的顺序。

var arr = [13, 24, 51, 3];
console.log(arr.reverse());   //[3, 51, 24, 13]
console.log(arr);   //[3, 51, 24, 13](原数组改变)

11.join()
join()方法用于把数组中的所有元素转换一个字符串。
元素是通过指定的分隔符进行分隔的。默认使用逗号作为分隔符

var arr = [1,2,3];
console.log(arr.join());   // 1,2,3
console.log(arr.join("-"));   // 1-2-3
console.log(arr);   // [1, 2, 3]（原数组不变）

通过join()方法可以实现重复字符串，只需传入字符串以及重复的次数，就能返回重复后的字符串，函数如下：

function repeatString(str, n) {
//一个长度为n+1的空数组用string去拼接成字符串,就成了n个string的重复
 return new Array(n + 1).join(str);
}
console.log(repeatString("abc", 3));   // abcabcabc
console.log(repeatString("Hi", 5));   // HiHiHiHiHi

12.toLocaleString() 和 toString()
将数组转换为字符串

const array1 = [22, 3, 31, 12];
const str = array1.toLocaleString();
const str1 = array1.toString();

console.log(str); // 22,3,31,12
console.log(str1); // 22,3,31,12

13.some()
some()：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回 true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some(function(x) {
 return x < 3;
});
console.log(arr2);  //true
var arr3 = arr.some(function(x) {
 return x < 1;
});
console.log(arr3);  // false

14.every()

every()：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回 true。

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every(function(x) {
 return x < 10;
});
console.log(arr2);  //true
var arr3 = arr.every(function(x) {
 return x < 3;
});
console.log(arr3);  // false

15.forEach()
forEach()：对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。参数都是 function 类型，默认有传。
参数分别为：遍历的数组内容；第对应的数组索引，数组本身

var arr = [11, 22, 33, 44, 55];
arr.forEach(function(x, index, a){
 console.log(x + '|' + index + '|' + (a === arr));
});

输出为：

 11|0|true
 22|1|true
 33|2|true
 44|3|true
 55|4|true

16.map()
map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
map() 方法按照原始数组元素顺序依次处理元素。该方法不会改变原数组

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.map(function(item){
 return item*item;
});
console.log(arr2);  //[1, 4, 9, 16, 25]

17.filter()
filter()：“过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(function(x, index) {
 return index % 3 === 0 || x >= 8;
});
console.log(arr2);  //[1, 4, 7, 8, 9, 10]

18. entries(),keys() 和 values() 【ES6】
entries()，keys()和values() —— 用于遍历数组。它们都返回一个遍历器对象，可以用for…of循环进行遍历

区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历

for (let index of ['a', 'b'].keys()) {  
console.log(index);  
}  
// 0  
// 1  
for (let elem of ['a', 'b'].values()) {  
console.log(elem);  
}  
// 'a'  
// 'b'  
for (let [index, elem] of ['a', 'b'].entries()) {  
console.log(index, elem);  
}  
// 0 "a"  
// 1 "b" 

如果不使用for…of循环，可以手动调用遍历器对象的next方法，进行遍历。

let letter = ['a', 'b', 'c'];  
let entries = letter.entries();  
console.log(entries.next().value); // [0, 'a']  
console.log(entries.next().value); // [1, 'b']  
console.log(entries.next().value); // [2, 'c'] 

19.fill() es6 新增
fill()方法能使用特定值填充数组中的一个或多个元素。当只是用一个参数时，该方法会用该参数的值填充整个数组。

let arr = [1, 2, 3, 'cc', 5];
arr.fill(1);
console.log(arr);//[1,1,1,1,1];

如果不想改变数组中的所有元素，而只是想改变其中一部分，那么可以使用可选的起始位置参数与结束位置参数（不包括结束位置的那个元素）
3 个参数： 填充数值，起始位置参数，结束位置参数（不包括结束位置的那个元素）

let arr = [1, 2, 3, 'arr', 5];

arr.fill(1, 2);
console.log(arr);//[1,2,1,1,1]

arr.fill(0, 1, 3);
console.log(arr);//[1,0,0,1,1];

20.reduce()和 reduceRight()
①以前我没得选，现在我只想用 Array.prototype.reduce
②reduce方法高级使用
③13个JavaScript数组reduce的实例方法
这两个方法都会实现迭代数组的所有项(即累加器)，然后构建一个最终返回的值。
reduce()方法从数组的第一项开始，逐个遍历到最后。
reduceRight()则从数组的最后一项开始，向前遍历到第一项。
4 个参数：前一个值、当前值、项的索引和数组对象

var values = [1,2,3,4,5];
var sum = values.reduceRight(function(prev, cur, index, array){
return prev + cur;
},10);   //数组一开始加了一个初始值10,可以不设默认0
console.log(sum);  //25

21.copyWithin() [es6 新增]
copyWithin() 方法用于从数组的指定位置拷贝元素到数组的另一个指定位置中。
该方法会改变现有数组

//将数组的前两个元素复制到数组的最后两个位置
let arr = [1, 2, 3, 'arr', 5];

arr.copyWithin(3, 0);
console.log(arr);//[1,2,3,1,2]

默认情况下，copyWithin()方法总是会一直复制到数组末尾，不过你还可以提供一个可选参数来限制到底有多少元素会被覆盖。这第三个参数指定了复制停止的位置（不包含该位置本身）。

let arr = [1, 2, 3, 'arr', 5, 9, 17];

//从索引3的位置开始粘贴
//从索引0的位置开始复制
//遇到索引3时停止复制
arr.copyWithin(3, 0, 3);
console.log(arr);//[1,2,3,1,2,3,17]

22.flat() 和 flatMap() es6 新增
flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
该方法返回一个新数组，对原数据没有影响。
参数： 指定要提取嵌套数组的结构深度，默认值为 1。

const arr1 = [0, 1, 2, [3, 4]];

console.log(arr1.flat());
// expected output: [0, 1, 2, 3, 4]

const arr2 = [0, 1, 2, [[[3, 4]]]];

console.log(arr2.flat(2));
// expected output: [0, 1, 2, [3, 4]]

//使用 Infinity，可展开任意深度的嵌套数组
var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

// 扁平化数组空项,如果原数组有空位，flat()方法会跳过空位
var arr4 = [1, 2, , 4, 5];
arr4.flat();
// [1, 2, 4, 5]

flatMap()方法对原数组的每个成员执行一个函数，相当于执行Array.prototype.map(),然后对返回值组成的数组执行flat()方法。
该方法返回一个新数组，不改变原数组。

// 相当于 [[2, 4], [3, 6], [4, 8]].flat()
[2, 3, 4].flatMap((x) => [x, x * 2])
// [2, 4, 3, 6, 4, 8]

(四)数组去重

参考阅读：盘点JS中数组去重写法

4.1创建一个新数组(不重复的放进去)

缺点：性能不太好，因为要开辟一个新的堆内存空间
1. 使用indexOf方法
另一种常见的数组去重方法是遍历原数组，将每个元素与新数组中的元素进行比较，如果新数组中不存在该元素，则将其添加到新数组中。

let arr = [1, 2, 3, 4, 3, 2, 1];
let uniqueArr = [];
for (let i = 0; i < arr.length; i++) {
  if (uniqueArr.indexOf(arr[i]) === -1) {
    uniqueArr.push(arr[i]);
  }
}
console.log(uniqueArr); // [1, 2, 3, 4]

以上代码我们使用indexOf方法判断新数组uniqueArr中是否已经存在当前元素，如果不存在则将其添加到新数组中。

2.使用 findIndex 方法
与indexOf类似，使用findIndex函数可以在数组中查找元素的索引，如果找到重复的元素，其索引值会大于首次出现的索引值。因此，可以遍历数组，当findIndex返回的索引值大于当前索引时，说明该元素是重复的，可以过滤掉。

let array = [1, 2, 2, 3, 4, 4, 5];
let uniqueArray = [];
for (let i = 0; i < array.length; i++) {
  if (array.findIndex(value => value === array[i]) === i) {
    uniqueArray.push(array[i]);
  }
}
console.log(uniqueArray);  // 输出: [1, 2, 3, 4, 5]

3. 使用includes方法
ES7中新增了includes方法，该方法可以更方便地判断数组中是否包含某个元素。我们可以利用这个特性来实现数组去重。

let arr = [1, 2, 3, 4, 3, 2, 1];
let uniqueArr = [];
for (let i = 0; i < arr.length; i++) {
  if (!uniqueArr.includes(arr[i])) {
    uniqueArr.push(arr[i]);
  }
}
console.log(uniqueArr); // [1, 2, 3, 4]

上述代码中，我们使用includes方法判断新数组uniqueArr中是否已经存在当前元素，如果不存在则将其添加到新数组中。

4. 利用 for of 循环和 includes 方法
这种方法与上一个方法类似，但使用了 for…of 循环，可读性更强。

let arr = [1, 2, 2, 3, 4, 4, 5];
let uniqueArr = [];
for (let value of arr) {
  if (!uniqueArr.includes(value)) {
    uniqueArr.push(value);
  }
}

5.使用递归去重
removeDuplicates 函数接受一个数组作为参数。它使用一个辅助函数 recursiveCheck，该函数使用递归的方式遍历原始数组并将非重复元素添加到结果数组中。result.includes(arr[index]) 这行代码用于检查结果数组中是否已经包含当前元素，如果不包含则将其添加到结果数组中（这里也可以换做其他方法查询是否包含当前元素）。

function removeDuplicates(arr) {
  // 创建一个新数组来存储去重后的结果
  var result = [];

  // 递归函数，用于遍历原始数组并添加非重复元素到结果数组中
  function recursiveCheck(index) {
    if (index >= arr.length) {
      return; // 递归结束条件：遍历完原始数组
    }

    if (!result.includes(arr[index])) {
      result.push(arr[index]); // 将非重复元素添加到结果数组
    }

    recursiveCheck(index + 1); // 递归调用，处理下一个元素
  }

  recursiveCheck(0); // 从索引 0 开始递归检查

  return result;
}

var array = [1, 2, 3, 2, 4, 3, 5];
var uniqueArray = removeDuplicates(array);

console.log(uniqueArray); // 输出 [1, 2, 3, 4, 5]

该例子中的去重算法时间复杂度为O(n^2)，在处理大量数据时可能不够高效。如果对性能要求较高，可以考虑其他算法。

6.使用 hasOwnProperty 方法去重
使用 hasOwnProperty 方法结合一个空对象来判断数组元素是否重复，可以实现数组去重。

我们创建一个空对象 result，用于存储去重后的结果。然后，我们遍历原始数组 arr，对于每个元素，我们使用 hasOwnProperty 检查它是否已经存在于 result 对象中，如果不存在，则将其添加到 result 数组中。

function removeDuplicates(arr) {
  var result = [];

  for (var i = 0; i < arr.length; i++) {
    if (!result.hasOwnProperty(arr[i])) {
      result.push(arr[i]);
    }
  }

  return result;
}

var array = [1, 2, 3, 2, 4, 3, 5];
var uniqueArray = removeDuplicates(array);

console.log(uniqueArray); // 输出 [1, 2, 3, 4, 5]

4.2 不创建新数组法

1.使用Set数据结构
Set数据结构是ES6中新增的一种集合类型，它只会存储不重复的值。我们可以通过将数组转换为Set来实现数组去重。Set这个结构默认就可以把数组进行去重，返回来的结果是Set这个类的实例。那把再它变成数组即可，可以用…展开运算符的方式，也可用Array.from()转换成数组。

/* SET */
let ary = [12, 23, 12, 15, 25, 15, 25, 14, 16];
//new Set(ary)是Set类的实例
let arr = [...new Set(ary)];
//let arr = Array.from(new Set(ary))
console.log(arr)
// [12, 23, 15, 25, 14, 16]

2.利用 Map 数据结构
Map 数据结构也可用于去重，它允许使用任何类型作为键（键可以是重复的），并自动删除所有重复的键。在此例中我们可以将数组元素作为 Map 的键，这样重复的键会被自动删除。然后我们再通过 Array.from() 方法将 Map 对象转回数组。这种方法与第一种方法类似，但无需使用额外的 Set 数据结构。

let arr = [1, 2, 2, 3, 4, 4, 5];
let uniqueArr = Array.from(new Map(arr.map(x => [x, true]))).map(x => x[0]);

3. 使用filter方法
filter方法是数组的一个高阶函数，可以根据指定的条件筛选出符合条件的元素并返回一个新数组。我们可以利用这个方法来实现数组去重。

let arr = [1, 2, 3, 4, 3, 2, 1];
let uniqueArr = arr.filter((value, index, self) => {
  return self.indexOf(value) === index;
});
console.log(uniqueArr); // [1, 2, 3, 4]

通过filter方法遍历数组arr，并使用indexOf方法判断当前元素在数组中的第一个索引位置，如果与当前索引相等，则保留该元素。

4.splice
拿出当前项和后面的内容进行比较
①原来数组改变，这样如果i继续++，则会产生数组塌陷
②性能不好：当前项一旦删除，后面项索引都要变

let ary = [12, 23, 12, 15, 25, 15, 25, 14, 16];
for(let i=0;i<ary.length-1;i++){   //ary.length-1的原因：拿出当前项和后面的内容进行比较，最后一项没有后一项。
	let item=ary[i],
		args=ary.slice(i+1);
	if(args.indexOf(item)>-1){  //indexOf不兼容ie678，(如果有就获取当前项再当前数组第一次出现的索引，如果没有就-1)。includes就更不兼容了
		//包含：我们可以把当前项干掉  
		// splice删除
		// 1. 原来数组改变，这样如果i继续++，则会产生数组塌陷
		// 2. 性能不好：当前项一旦删除，后面项索引都要变
		   ary.splice(i,1);
		   i--;
	}
}
console.log(ary);

5.赋值为null，后续filter一次

let ary = [12, 23, 12, 15, 25, 15, 25, 14, 16];
for(let i=0;i<ary.length-1;i++){   //ary.length-1的原因：拿出当前项和后面的内容进行比较，最后一项没有后一项。
	let item=ary[i],
		args=ary.slice(i+1);
	if(args.indexOf(item)>-1){  //indexOf不兼容ie678，(如果有就获取当前项再当前数组第一次出现的索引，如果没有就-1)。includes就更不兼容了
		ary[i] = null;
	}
}
ary=ary.filter(item=>item!==null);
console.log(ary);
//[23, 12, 15, 25, 14, 16]

6.用最后一项替换
拿最后一项替换当前项，新数组还没有比过。还要把新替换的再的值再比一次，所以还要i–，

let ary = [12, 23, 12, 15, 25, 15, 25, 14, 16];
for(let i=0;i<ary.length-1;i++){   //ary.length-1的原因：拿出当前项和后面的内容进行比较，最后一项没有后一项。
	let item=ary[i],
		args=ary.slice(i+1);
	if(args.indexOf(item)>-1){  //indexOf不兼容ie678，(如果有就获取当前项再当前数组第一次出现的索引，如果没有就-1)。includes就更不兼容了
	ary[i]=ary[ary.length-1];//拿最后一项替换当前项
	ary.length--;//去掉后一项
	i--
	}
}

console.log(ary);

7.拿数组中的每项向新容器中存储，如果已经存储过了，把当前项干掉
把当前作为键值对往里面存的话，如果之前已经有相同的属性名，就把它干掉。用对象和数组都可以，创建一个空容器，拿出一项放空容器里边，但是每拿一项放的时候都看一看，之前有没有放过，说明当前项就是重复的，把当前项干掉。

let ary = [12, 23, 12, 15, 25, 15, 25, 14, 16];
let obj={};
for(let i=0;i<ary.length;i++){
	let item=ary[i];
//判断obj里有没有item，用in，object.keys
//如果当前对象没有这个属性就是undefined，如果不是underfined，说明一定有这个属性，说明就重了
	if(typeof obj[item]!=='undefined'){
	    //用最后一项来替换
		ary[i]=ary[ary.length-1];
		ary.length--;
		i--;
		continue;//不存了
	}
	obj[item]=item;
}
obj=null;//把当前用的堆销毁掉
console.log(ary);

8.相邻项的处理方案

let ary = [12, 23, 12, 15, 25, 15, 25, 14, 16];
ary.sort((a,b)=>a-b);
ary = ary.join('@')+'@';
let reg=/(\d+@)\1*/g,
	arr=[];
  ary.replace(reg,(val,group1)=>{
	arr.push(Number(group1.slice(0,group1.length-1)));
// 	arr.push(parseFloat(group1));
 });
 console.log(arr);

(四)数组扁平化

数组扁平化

let arr = [
    [1, 2, 2],
    [3, 4, 5, 5],
    [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], 10
];

1.ES6方法直接实现

let arr = [
    [1, 2, 2],
    [3, 4, 5, 5],
    [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], 10
];
arr = arr.flat(Infinity);
console.log(arr)
//[1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12, 13, 14, 10]

2.转化为字符串
(1)toString()

let arr = [
    [1, 2, 2],
    [3, 4, 5, 5],
    [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], 10
];
//arr=arr.toString()=>1,2,2,3,4,5,5,6,7,8,9,11,12,12,13,14,10
//arr=arr.toString().split(',')          =>split() 方法用于把一个字符串分割成字符串数组。join() 方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。
// ["1", "2", "2", "3", "4", "5", "5", "6", "7", "8", "9", "11", "12", "12", "13", "14", "10"]
arr=arr.toString().split(',').map(item=>parseFloat(item));
console.log(arr)
//[1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12, 13, 14, 10]

(2)JSON.sringify()

let arr = [
    [1, 2, 2],
    [3, 4, 5, 5],
    [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], 10
];
//arr=JSON.stringify(arr)  =>[[1,2,2],[3,4,5,5],[6,7,8,9,[11,12,[12,13,[14]]]],10]转换为JSON格式的字符串中括号还在
//arr=JSON.stringify(arr).replace(/(\[|\])/g,'') =>"1,2,2,3,4,5,5,6,7,8,9,11,12,12,13,14,10"
//arr=JSON.stringify(arr).replace(/(\[|\])/g,'').split(',')=> ["1", "2", "2", "3", "4", "5", "5", "6", "7", "8", "9", "11", "12", "12", "13", "14", "10"]
arr=JSON.stringify(arr).replace(/(\[|\])/g,'').split(',').map(item=>parseFloat(item))
console.log(arr)
//[1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 9, 11, 12, 12, 13, 14, 10]

3.循环验证是否为数组

(1)基于while和some

let arr = [
    [1, 2, 2],
    [3, 4, 5, 5],
    [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], 10
];
while (arr.some(item => Array.isArray(item))) {
 arr = [].concat(...arr);
 }
 console.log(arr)

(2).利用 reduce 函数迭代

function flatten(arr) {
  return arr.reduce((pre, cur) => {
    return pre.concat(Array.isArray(cur) ? flatten(cur) : cur)
  }, [])
}

let arr = [1, 2, [3, 4], [5, [6, 7]]]
console.log(flatten(arr))

(3)递归处理

(function () {
    function myFlat() {
        let result = [],
            _this = this;
        //=>循环ARR中的每一项，把不是数组的存储到新数组中
        let fn = (arr) => {
            for (let i = 0; i < arr.length; i++) {
                let item = arr[i];
                if (Array.isArray(item)) {
                    fn(item);
                    continue;
                }
                result.push(item);
            }
        };
        fn(_this);
        return result;
    }
    Array.prototype.myFlat = myFlat;
})();
arr = arr.myFlat();

(五)数组的交差并

1、includes 方法+ filter 方法实现交差并

let a = [1, 2, 3]
let b = [2, 4, 5]

// 并集
let union = a.concat(b.filter((v) => !a.includes(v)))
// [1,2,3,4,5]

// 交集
let intersection = a.filter((v) => b.includes(v))
// [2]

// 差集
let difference = a.concat(b).filter((v) => !a.includes(v) || !b.includes(v))
// [1,3,4,5]

2.ES6 的 Set 数据结构实现交叉并

let a = new Set([1, 2, 3])
let b = new Set([2, 4, 5])

// 并集
let union = new Set([...a, ...b])
// Set {1, 2, 3, 4,5}

// 交集
let intersect = new Set([...a].filter((x) => b.has(x)))
// set {2}

// a 相对于 b 的差集
let difference = new Set([...a].filter((x) => !b.has(x)))
// Set {1, 3}

3.数组合并

普通数组

const arr1 =[1, 2, 3, 4].concat([5, 6]) //[1,2,3,4,5,6]
const arr2 =[...[1, 2, 3, 4],...[4, 5]] //[1,2,3,4,5,6]
const arrA = [1, 2], arrB = [3, 4]
const arr3 =[].concat.apply(arrA, arrB)//arrA值为[1,2,3,4]

数组对象

const arr4 = [{ age: 1 }].concat([{ age: 2 }])
const arr5 = [...[{ age: 1 }],...[{ age: 2 }]]
console.log(arr4) //[ { age: 1 }, { age: 2 } ]
console.log(arr5) // [ { age: 1 }, { age: 2 } ]

(六)类数组的转化

1.Array 的 slice 方法

- Array.prototype.slice.call(arguments) || Array.prototype.slice.apply(arguments)

//从索引开始出提取数组
var test = function() {
	return Array.prototype.slice.call(arguments) ; //es5
}
let a = test(1,2,3,4)
console.log(a) // [1, 2, 3, 4]

//例二：
var test = function() {
	return Array.prototype.slice.apply(arguments) ; //es5
}
let a = test(1,2,3,4)
console.log(a) // [1, 2, 3, 4]
[].slice.call(arguments)

- [].slice.call(arguments)

var test = function() {
	return [].slice.call(arguments) ; //es5
}
let a = test(1,2,3,4)
console.log(a) // [1, 2, 3, 4]

2.ES6 的 Array.from()

var test = function(){
	return Array.from(arguments)
}
var a = test(1,2,3,4) ;
console.log(a) //[1,2,3,4]

document.querySelectAll("div") // NodeList[div, div, div, div]
Array.from(document.querySelectorAll('div')) // 转换为真数组

3.扩展运算符…

let arr = [...arguments]

伪数组不能调用真数组对象上的方法，所以得将伪数组转换为真数组，获取js元素是伪数组。

document.querySelectAll("div") // NodeList[div, div, div, div]
[...document.querySelectorAll('div')] // 转换为真数组

4.循环类数组

let utils = (function(){
function toArray(){
let args = [];
 for (let i = 0; i < arguments.length; i++) {
  	        args.push(arguments[i]);
       }
         return args
    }
    return {
        toArray
    };
})();
let ary = utils.toArray(10,20,30); 
console.log(ary)//=>[10,20,30]
let ary1 = utils.toArray('A',10,20,30);
console.log(ary1) //=>["A",10,20,30]

(七)排序

对于前端来说，排序算法在应用方面似乎始终不是什么瓶颈——JS 天生地提供了对排序能力的支持，很多时候，我们实现排序只需要这样寥寥数行的代码：

arr.sort((a,b) => { 
    return a - b 
}) 

以某一个排序算法为“引子”，顺藤摸瓜式地盘问，可以问出非常多的东西，这也是排序算法始终热门的一个重要原因——面试官可以通过这种方式在较短的时间里试探出候选人算法能力的扎实程度和知识链路的完整性。因此排序算法在面试中的权重不容小觑。

1.冒泡、快排、插入、选择四大排序

1.冒泡排序

 /*
  *冒泡排序的思想：
  *  重复的让数组中当前项和后一项进行比较，如果当前项比后一项大，则两项交换位置（让大的靠后）即可
  */ 
 
  /*
  *bubble: 实现冒泡排序
  *  @params
  *    ary [ARRAY] 需要排序的数组
  * @return
  *    排序
  * by  donglize on 2019/07/26
  */
function Bubble(ary){
  // 外层循环I控制比较的轮数
  for(i=0;i<ary.length-1;i++){
    // 里层循环控制每一轮比较的次数J
    for(j=0;j < ary.length-1-i;j++){
      // 当前项大于后一项
      if(ary[j]>ary[j+1]){
      [ary[j],ary[j+1]] = [ary[j+1],ary[j]]
       // var temp = ary[j];
       //     ary[j] = ary[j+1];
       //    ary[j+1] = temp;
      }
    }
  }
  return ary;
}
let ary = [12,8,24,16,1];
ary=Bubble(ary);
console.log(ary)

面向“最好情况”的进一步改进

很多同学反映说，在不少教材里都看到了“冒泡排序时间复杂度在最好情况下是 O(n)”这种说法，但是横看竖看，包括楼上示例在内的各种冒泡排序主流模板似乎都无法帮助我们推导出 O(n) 这个结果。
实际上，你的想法是对的，冒泡排序最常见的写法（也就是楼上的编码示例）在最好情况下对应的时间复杂度确实不是O(n)，而是O(n^2)。
那么是O(n)这个说法错了吗？其实也不错，因为冒泡排序通过进一步的改进，确实是可以做到最好情况下 O(n)复杂度的，这里我先把代码给大家写出来（注意解析在注释里）：

function betterBubbleSort(ary){
  for(i=0;i<ary.length-1;i++){
    //区别在这里，我们加了一个标志位
    let flag = false
    for(j=0;j < ary.length-1-i;j++){
      if(ary[j]>ary[j+1]){
      [ary[j],ary[j+1]] = [ary[j+1],ary[j]]
       // var temp = ary[j];
       //     ary[j] = ary[j+1];
       //    ary[j+1] = temp;
       flag = true
      }
    }
    if(flag == false)  return ary;
  }
  return ary;
}
let ary = [12,8,24,16,1];
ary = betterBubbleSort(ary);
console.log(ary)

标志位可以帮助我们在第一次冒泡的时候就定位到数组是否完全有序，进而节省掉不必要的判断逻辑，将最好情况下的时间复杂度定向优化为 O(n)。

2.快速排序

/*
    *quick: 实现快速排序
    *  @params
    *    ary [ARRAY] 需要排序的数组
    * @return
    *    排序
    * by  donglize on 2019/07/26
    */
  function quick(ary){
    // 4.结束递归  （当ARY中小于等于一项，则不用处理）
    if(ary.length<=1){
      return ary;
    }
    // 1. 找到数组中间项，在原有的数组中把它移除
    let middleIndex = Math.floor(ary.length/2);
    let middleValue = ary.splice(middleIndex,1)[0];
   
    // 2.准备左右两个数组，循环剩下数组中的每一项，比当前小的放到左边数组中，反之放到右边数组中
    let aryLeft=[],
        aryRight=[];
      for(let i=0;i<ary.length;i++){
         let item=ary[i];
         item<middleValue?aryLeft.push(item):aryRight.push(item);
      }

      //3.递归方式让左右两边的数组持续这样处理，一直到左右两边都排好序为止（最后让左边+中间+右边拼接成为最后的结果） 
      return quick(aryLeft).concat(middleValue,quick(aryRight));
  }
  let ary = [12,8,15,16,1,24];
  ary=quick(ary);
  console.log(ary)

3.插入排序

/*
  *insert: 实现插入排序
  *  @params
  *    ary [ARRAY] 需要排序的数组
  * @return
  *    排序
  * by  donglize on 2019/07/26
  */ 
function insert(ary){
  // 1.准备一个新数组，用来存储抓到手里的牌，开始先抓一张牌进来 
  let handle=[];
  handle.push(ary[0]);

// 2.从第二项开始抓牌，一直把台面上的牌抓光 
  for(let i=1;i<ary.length;i++){
    // A是新抓的牌 
    let A=ary[i];
    // 和handle手里的牌依次比较（从后向前比）
    for(let j=handle.length-1;j>=0;j--){
      // 每一次要比较手里的牌 
      let B=handle[j];
      // 如果当前新牌A要比要比较的牌大了，把A放到B的后面 
      if(A>B){
        handle.splice(j+1,0,A);
        break;
      }
      // 已经比到第一项，我们把新牌放到手中最前面即可 
      if(j===0){
          handle.unshift(A);
      }
    }
  }
   return handle;
}
let ary = [12,8,24,16,1];
ary = insert(ary);
console.log(ary)

4.选择排序

思路分析

选择排序的关键字是“最小值”：循环遍历数组，每次都找出当前范围内的最小值，把它放在当前范围的头部；然后缩小排序范围，继续重复以上操作，直至数组完全有序为止。

真实排序过程演示

下面我们尝试基于选择排序的思路，对如下数组进行排序：

[5, 3, 2, 4, 1] 

首先，索引范围为 [0, n-1] 也即 [0,4] 之间的元素进行的遍历（两个箭头分别对应当前范围的起点和终点）：

[5, 3, 2, 4, 1] 
 ↑           ↑ 

得出整个数组的最小值为 1。因此把1锁定在当前范围的头部，也就是和 5 进行交换：

[1, 3, 2, 4, 5]

交换后，数组的第一个元素值就明确了。接下来需要排序的是 [1, 4] 这个索引区间：

[1, 3, 2, 4, 5]
    ↑        ↑ 

遍历这个区间，找出区间内最小值为 2。因此区间头部的元素锁定为 2，也就是把 2 和 3 交换。相应地，将需要排序的区间范围的起点再次后移一位，此时区间为 [2, 4]：

[1, 2, 3, 4, 5] 
       ↑     ↑ 

遍历 [2,4] 区间，得到最小值为 3。3 本来就在当前区间的头部，因此不需要做额外的交换。
以此类推，4会被定位为索引区间 [3,4] 上的最小值，仍然是不需要额外交换的。

基于这个思路，我们来写代码：

编码示范

function selectSort(arr) { 
   // 缓存数组长度 
   const len = arr.length 
   // 定义 minIndex，缓存当前区间最小值的索引，注意是索引 
   let minIndex 
   // i 是当前排序区间的起点
   for(let i = 0; i < len - 1; i++) { 
   // 初始化 minIndex 为当前区间第一个元素 
   minIndex = i
    // i、j分别定义当前区间的上下界，i是左边界，j是右边界 
  for(let j = i; j < len; j++) { 
  // 若 j 处的数据项比当前最小值还要小，则更新最小值索引为 j 
  if(arr[j] < arr[minIndex]) { 
    minIndex = j 
  }
} 
// 如果 minIndex 对应元素不是目前的头部元素，则交换两者 
if(minIndex !== i) { 
[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]
    }
   } 
 return arr 
} 

编码复盘——选择排序的时间复杂度

在时间复杂度这方面，选择排序没有那么多弯弯绕绕：最好情况也好，最坏情况也罢，两者之间的区别仅仅在于元素交换的次数不同，但都是要走内层循环作比较的。因此选择排序的三个时间复杂度都对应两层循环消耗的时间量级： O(n^2)。

2.数组对象的排序

1.单个属性排序

function compare(property) {
  return function (a, b) {
    let value1 = a[property]
    let value2 = b[property]
    return value1 - value2
  }
}
let arr = [
  { name: 'zopp', age: 10 },
  { name: 'gpp', age: 18 },
  { name: 'yjj', age: 8 },
]
console.log(arr.sort(compare('age')))

2.多个属性排序

function by(name, minor) {
  return function(o, p) {
    let a, b
    if (o && p && typeof o === 'object' && typeof p === 'object') {
      a = o[name]
      b = p[name]
      if (a === b) {
        return typeof minor === 'function' ? minor(o, p) : 0
      }
      if (typeof a === typeof b) {
        return a < b ? -1 : 1
      }
      return typeof a < typeof b ? -1 : 1
    } else {
      thro('error')
    }
  }
},

(八)斐波那契数列

- 思路1

function fibonacci(n){
	if(n<=1) return 1;
	let arr=[1,1];
	//=>即将要创建多少个
	let i=n+1-2;
    while(i>0){
    	let a=arr[arr.length-2],
    		b=arr[arr.length-1];
    	arr.push(a+b);
    	i--;
    }
return arr[arr.length-1];
console.log(fibonacci(0))
console.log(fibonacci(1))
console.log(fibonacci(2))
console.log(fibonacci(3))
console.log(fibonacci(4))

思路2:递归
①递归1
用递归的方式把当前的next作为下一次递归的count,把当前项和next相加的和作为下一次fn调用的下一项，count一直减到0为止，最终会返回一个值。递归的性能也不好，与上一种思路相比，思路1是从0创建到1000，思路2是从1000减到0。

function fibonacci(count) {
  function fn(count, curr = 1, next = 1) {
    if (count == 0) {
      return curr;
    } else {
      return fn(count - 1, next, curr + next);
    }
  };
  return fn(count);
}

②递归2

function fb(n){
  if(n-2>=0){
  return fb(n-2) + fb(n-1)
}else{
  return 1
  }
}

(九)数组的遍历

几种遍历方法中for执行最快，它没有任何额外的函数调用栈和上下文。但在实际开发中我们要结合语义话、可读性和程序性能，去选择究竟使用哪种方案。下面来看for , foreach , map , for…in , for…of五种方法现场battle。
使用建议：对于纯对象的遍历，选择for…in枚举更方便；对于数组遍历，如果不需要知道索引for…of迭代更合适，因为还可以中断；如果需要知道索引，则forEach()更合适；对于其他字符串，类数组，类型数组的迭代，for…of更占上风更胜一筹。但是注意低版本浏览器的是配性。
1.for 循环
这个是最最基础的操作。我们可以通过循环数组的下标，来依次访问每个值。这里给个小建议：个人推荐如果没有特殊的需要，那么统一使用 for 循环来实现遍历。因为从性能上看，for 循环遍历起来是最快的。我是最早出现的一方遍历语句，在座的各位需称我一声爷爷。我能满足开发人员的绝大多数的需求。

  // 遍历数组
let arr = [1,2,3];
for(let i = 0;i < arr.length;i++){
    console.log(i) // 索引，数组下标
    console.log(arr[i]) // 数组下标所对应的元素
}

// 遍历对象
let profile = {name:"April",nickname:"二十七刻",country:"China"};
for(let i = 0, keys=Object.keys(profile); i < keys.length;i++){
    console.log(keys[i]) // 对象的键值
    console.log(profile[keys[i]]) // 对象的键对应的值
}

// 遍历字符串
let str = "abcdef";
for(let i = 0;i < str.length ;i++){
    console.log(i) // 索引 字符串的下标
    console.log(str[i]) // 字符串下标所对应的元素
}

// 遍历DOM 节点
let articleParagraphs = document.querySelectorAll('.article > p');
for(let i = 0;i<articleParagraphs.length;i++){
    articleParagraphs[i].classList.add("paragraph");
    // 给class名为“article”节点下的 p 标签添加一个名为“paragraph” class属性。
}

2.forEach 方法

自我介绍：我是ES5版本发布的。按升序为数组中含有效值的每一项执行一次 callback 函数，那些已删除或者未初始化的项将被跳过（例如在稀疏数组上）。我是 for 循环的加强版。
通过取 forEach 方法中传入函数的第一个入参和第二个入参，我们也可以取到数组每个元素的值及其对应索引。
如果再写for循环，我就锤自己
(1)局限及原理 ：
但是forEach也有一些局限，不能continue跳过或者break/return终止循环。
查看forEach实现原理，就会理解这个问题。

Array.prototype.forEach（callbackfn [，thisArg]{
    
}

传入的function是这里的回调函数。在回调函数里面使用break肯定是非法的，因为break只能用于跳出循环，回调函数不是循环体。
在回调函数中使用return，只是将结果返回到上级函数，也就是这个for循环中，并没有结束for循环，所以return也是无效的。

//语法
array.forEach(function(currentValue, index, arr), thisValue)

//遍历数组
arr.forEach((item, index)=> { 
// 输出数组的元素值，输出当前索引 
   console.log(item, index)
}) 

//遍历对象
let profile = {name:"April",nickname:"二十七刻",country:"China"};
let keys = Object.keys(profile);
keys.forEach(i => {
    console.log(i) // 对象的键值
    console.log(profile[i]) // 对象的键对应的值
})

[].forEach(function(value,index,array){
　　　　//do something
　　});
 等价于：
 $.each([],function(index,value,array){
　　　//do something
　})

（2）解决方案：Javascript数组的forEach方法大家都用过，也应该都知道forEach是无法退出的，及时在方法里写了return也没用。但是很多人都知道可以通过
①抛出异常②把数组长度设置为0。

let arr = [1,2,3];

arr.forEach(item => {
  console.log(item);
  if (item > 1 ) {
    return;
  }
})
//最终输出的还是：1，2，3

①有一种退出forEach的方法相信很多人都知道，就是抛出一个异常。

let arr = [1,2,3];

arr.forEach(item => {
  console.log(item);
  if (item > 1 ) {
    throw Error;
  }
})
//最终输出的还是：1，2。说明forEach被结束了。

②奇妙的退出方法，办法就是把数组的长度设为0。

let arr = [1,2,3];

arr.forEach(item => {
  console.log(item);
  if (item > 1 ) {
    arr.length = 0;
  }
}

3.map 方法
我也是ES5版本发布的, map 方法在调用形式上与 forEach 无异，区别在于 map 方法会根据你传入的函数逻辑对数组中每个元素进行处理、进而返回一个全新的数组。
(1)所以其实 map 做的事情不仅仅是遍历，而是在遍历的基础上“再加工”。当我们需要对数组内容做批量修改、同时修改的逻辑又高度一致时，就可以调用 map 来达到我们的目的：

const newArr = arr.map((item, index)=> { 
// 输出数组的元素值，输出当前索引 
console.log(item, index) 
// 在当前元素值的基础上加1 
return item+1
}) 

这段代码就通过 map 来返回了一个全新的数组，数组中每个元素的值都是在其现有元素值的基础上+1后的结果。
(2)map() 方法是可以链式调用的，这意味着它可以方便的结合其它方法一起使用。例如：reduce(), sort(), filter() 等。但是其它方法并不能做到这一点。forEach()的返回值是undefined，所以无法链式调用。

// 将元素乘以本身，再进行求和。
let arr = [1, 2, 3, 4, 5];
let res1 = arr.map(item => item * item).reduce((total, value) => total + value);

console.log(res1) // logs 55 undefined"

(3)缺点： forEach 与map 是不支持跳出循环体的，其它三种方法均支持

4.for…in枚举
我是ES5版本发布的。以任意顺序遍历一个对象的除Symbol以外的可枚举属性。
for(var item in arr|obj){} 可以用于遍历数组和对象
遍历数组时，item表示索引值， arr表示当前索引值对应的元素 arr[item]
遍历对象时，item表示key值，arr表示key值对应的value值 obj[item]
for in一般循环遍历的都是对象的属性，遍历对象本身的所有可枚举属性，以及对象从其构造函数原型中继承的属性

// 遍历对象
let profile = {name:"April",nickname:"二十七刻",country:"China"};
for(let i in profile){
    let item = profile[i];
    console.log(item) // 对象的键值
    console.log(i) // 对象的键对应的值
}
// 遍历数组
let arr = ['a','b','c'];
for(let i in arr){
    let item = arr[i];
    console.log(item) // 数组下标所对应的元素
    console.log(i) // 索引，数组下标
}
// 遍历字符串
let str = "abcd"
for(let i in str){
    let item = str[i];
    console.log(item) // 字符串下标所对应的元素
    console.log(i) // 索引 字符串的下标
}
//遍历原型上的属性
Object.prototype.objCustom = function() {};
Array.prototype.arrCustom = function() {};
var arr = ['a', 'b', 'c'];
arr.foo = 'hello
for (var i in arr) {
    console.log(i);
}
// logs
// 0
// 1
// 2
// foo
// arrCustom
// objCustom
/*然而在实际的开发中，我们并不需要原型对象上的属性。这种情况下我们可以使用hasOwnProperty() 方法，它会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。如下：*/
Object.prototype.objCustom = function() {};
Array.prototype.arrCustom = function() {};
var arr = ['a', 'b', 'c'];
arr.foo = 'hello
for (var i in arr) {
    if (arr.hasOwnProperty(i)) {
        console.log(i);
    }
}
// logs
// 0
// 1
// 2
// foo

// 可见数组本身的属性还是无法摆脱。此时建议使用 forEach

5.for of
ES6中新增加的语法 for of 语句创建一个循环来迭代可迭代的对象。在 ES6 中引入的 for of 循环，以替代 for in 和 forEach() ，并支持新的迭代协议。for of 允许你遍历 Arrays（数组）, Strings（字符串）, Maps（映射）, Sets（集合）等可迭代的数据结构等。

循环一个数组：

let arr = ['A', 'B', 'C']
for (let val of arr) {
    console.log(val)
}
// A B C

循环一个字符串：

let iterable = "abc";
for (let value of iterable) {
  console.log(value);
}
// "a"
// "b"
// "c"

循环一个Map:

let iterable = new Map([["a", 1], ["b", 2], ["c", 3]]);
for (let [key, value] of iterable) {
  console.log(value);
}
// 1
// 2
// 3

for (let entry of iterable) {
  console.log(entry);
}
// [a, 1]
// [b, 2]
// [c, 3]

循环一个 Set:

let iterable = new Set([1, 1, 2, 2, 3, 3]);
for (let value of iterable) {
  console.log(value);
}
// 1
// 2
// 3

循环一个拥有enumerable属性的对象
for of循环并不能直接使用在普通的对象上，但如果我们按对象所拥有的属性进行循环，可使用内置的Object.keys()方法：

for (var key of Object.keys(someObject)) {
  console.log(key + ": " + someObject[key]);
}

循环一个生成器(generators):

function* fibonacci() { // a generator function
  let [prev, curr] = [0, 1];
  while (true) {
    [prev, curr] = [curr, prev + curr];
    yield curr;
  }
}

for (let n of fibonacci()) {
  console.log(n);
  // truncate the sequence at 1000
  if (n >= 1000) {
    break;
  }
}

// 迭代 DOM 节点
let articleParagraphs = document.querySelectorAll('.article > p');
for (let paragraph of articleParagraphs) {
    paragraph.classList.add("paragraph");
    // 给class名为“article”节点下的 p 标签添加一个名为“paragraph” class属性。
}

// 迭代arguments类数组对象
(function() {
  for (let argument of arguments) {
    console.log(argument);
  }
})(1, 2, 3);
// logs：
// 1
// 2
// 3

性能
有兴趣的读者可以找一组数据自行测试，文章就直接给出结果了，并做相应的解释。

for > for-of > forEach > map > for-in

• for 循环当然是最简单的，因为它没有任何额外的函数调用栈和上下文；
• for…of只要具有Iterator接口的数据结构，都可以使用它迭代成员。它直接读取的是键值。
• forEach，因为它其实比我们想象得要复杂一些，它实际上是array.forEach(function(currentValue, index, arr), thisValue)它不是普通的 for 循环的语法糖，还有诸多参数和上下文需要在执行的时候考虑进来，这里可能拖慢性能；
• map() 最慢，因为它的返回值是一个等长的全新的数组，数组创建和赋值产生的性能开销很大。
• for…in需要穷举对象的所有属性，包括自定义的添加的属性也能遍历到。且for…in的key是String类型，有转换过程，开销比较大。

6.jQuery里面的$.each

$.each(arr|obj, function(k, v))
可以用来遍历数组和对象，其中k表示索引值或者key值，v表示value值


var arr = ['a','b','c']
$.each(arr, function(key, val) {
    console.log(key, val);
})
//0 a
//1 b
//2 c

7.jQuery里面的$().each()

$().each()在dom处理上面用的较多,主要是用来遍历DOMList。如果页面有多个input标签类型为checkbox，对于这时用$().each()来处理多个checkbox，例如：

$(“input[name=’checkbox’]”).each(function(i){
if($(this).attr(‘checked’)==true){
//操作代码
}

推荐在循环对象属性的时候使用for in,在遍历数组的时候的时候使用for of；
for in循环出的是key，for of循环出的是value；
for of是ES6新引入的特性。修复了ES5的for in的不足；
for of不能循环普通的对象，需要通过和Object.keys()搭配使用。
跳出循环的方式有如下几种：

• return 函数执行被终止；
• break 循环被终止；
• continue 循环被跳过。

8.map()、.reduce()、.filter()方法比较
这个三个方法的基本思路和for循环是一样的，只是在参数功能细节等方面，各自有擅长的地方。使用场景是:
(1) 如果需要一个数组，请使用.map()方法；
(2) 如果需要一个结果，请使用reduce()方法；
(3) 如果需要过滤一个结果，请使用.filter()方法。
map()方法
创建一个数组对象，这个数组对象里包含三个对象，这三个对象里包含着年龄和姓名。map方法里是接受一个匿名函数作为参数，匿名函数它又有三个参数,第一个参数是当前数组当中的第几个成员，第二个参数是当前数组在数组当中的索引，第三个参数是调用map方法的被操作的数组本身。

 var _arrObj = [{
    age: 11, name: 'aaa'
  }, {
    age: 22, name: 'bbb'
  }, {
    age: 33, name: 'ccc'
  }];
  var _age = _arrObj.map(function (_d, inx, arr) {
    console.log(_d, inx, arr);
    return _d.age;
  })
  console.log(_age)

es6重写
箭头函数只需要一行代码，代码更加简洁。也不用调用push方法拼接数组了。

 var _arrObj = [{
    age: 11, name: 'aaa'
  }, 
    age: 22, name: 'bbb'
  }, {
    age: 33, name: 'ccc'
  }];
  var _ageEs6 = _arrObj.map( _d=>_d.age); 
  console.log(_ageEs6)

reduce()
reduce也是一个循环，但它循环的是回调的方法，数组当中的每一个成员都进入回调，区别在于每次回调方法返回的值都会传入到下次回调中，就是累加。它有两个参数，第一是回调方法，第二个是累计初始的值。下面例子中，_n是承接计算的结果，初始值是0。

 var _arrObj = [{
    age: 11, name: 'aaa'
  }, 
    age: 22, name: 'bbb'
  }, {
    age: 33, name: 'ccc'
  }];
  var _ageYear = _arrObj.reduce(function (_n, _y) {
     console.log('------:' + _n + ':' + _y.age)
    return _n + _y.age
  }, 0)
  console.log(_ageYear)

ES6重写

var _arrObj = [{
    age: 11, name: 'aaa'
  }, 
    age: 22, name: 'bbb'
  }, {
    age: 33, name: 'ccc'
  }];
var _ageYearEs6 = _arrObj.reduce((_n, _y) => _n + _y.age, 0);
console.log(_ageYearEs6)

filter()

filter()用于过滤,filter()方法返回的也是一个数组。filter()方法接收的是一个匿名函数，匿名函数只有一个参数。参数就是数组对象中的每一个成员，进行比较。如下面代码中name为ccc的就被过滤出来，也就是说，只要filter方法的回调函数中的比较运算符的结果为true，那么符合条件的对象就会包在一个数组中返回，比较结果为false的就被过滤掉了。

 var _arrObj = [{
    age: 11, name: 'aaa'
  }, 
    age: 22, name: 'bbb'
  }, {
    age: 33, name: 'ccc'
  }];
  var _arrName=_arrObj.filter(function(_d){
     return _d.name === 'ccc'
   }); 
   console.log(_arrName)

ES6重写filter()

 var _arrObj = [{
    age: 11, name: 'aaa'
  }, 
    age: 22, name: 'bbb'
  }, {
    age: 33, name: 'ccc'
  }];
    var _arrNameEs6=_arrObj.filter(_d => _d.name === 'ccc'); 
  console.log(_arrNameEs6)

(十)数组是否包含值

普通数组

console.log([1, 2, 3].includes(4)) //false
console.log([1, 2, 3].indexOf(4)) //-1 如果存在换回索引
console.log([1, 2, 3].find((item) => item === 3)) //3 如果数组中无值返回undefined
console.log([1, 2, 3].findIndex((item) => item === 3)) //2 如果数组中无值返回-1

数组对象

const flag = [{age:1},{age:2}].some(v=>JSON.stringify(v)===JSON.stringify({age:2}))
console.log(flag)

(十一)javascript深浅拷贝

面试官：深拷贝浅拷贝的区别？如何实现一个深拷贝？

1.浅拷贝与深拷贝

• 浅拷贝是创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址 ，所以如果其中一个对象改变了这个地址，就会影响到另一个对象。
• 深拷贝是将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象。

var a1 = {b: {c: {}};

var a2 = shallowClone(a1); // 浅拷贝方法
a2.b.c === a1.b.c // true 新旧对象还是共享同一块内存

var a3 = deepClone(a3); // 深拷贝方法
a3.b.c === a1.b.c // false 新对象跟原对象不共享内存

借助ConardLi大佬以下两张图片，帮我们更好的理解两者的含义：

总而言之，浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。

2.赋值和深/浅拷贝的区别

这三者的区别如下，不过比较的前提都是针对引用类型：

• 当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据。也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容，因此，两个对象是联动的。

• 浅拷贝：重新在堆中创建内存，拷贝前后对象的基本数据类型互不影响，但拷贝前后对象的引用类型因共享同一块内存，会相互影响。

• 深拷贝：从堆内存中开辟一个新的区域存放新对象，对对象中的子对象进行递归拷贝,拷贝前后的两个对象互不影响。

我们先来看下面的例子，对比赋值与深/浅拷贝得到的对象修改后对原始对象的影响：

// 对象赋值
let obj1 = {
    name : '浪里行舟',
    arr : [1,[2,3],4],
};
let obj2 = obj1;
obj2.name = "阿浪";
obj2.arr[1] =[5,6,7] ;
console.log('obj1',obj1) 
// obj1 { name: '阿浪', arr: [ 1, [ 5, 6, 7 ], 4 ] }
console.log('obj2',obj2) 
// obj2 { name: '阿浪', arr: [ 1, [ 5, 6, 7 ], 4 ] }

// 浅拷贝
let obj1 = {
    name : '浪里行舟',
    arr : [1,[2,3],4],
};
let obj3=shallowClone(obj1)
obj3.name = "阿浪";
obj3.arr[1] = [5,6,7] ; // 新旧对象还是共享同一块内存
// 这是个浅拷贝的方法
function shallowClone(source) {
    var target = {};
    for(var i in source) {
        if (source.hasOwnProperty(i)) {
            target[i] = source[i];
        }
    }
    return target;
}
console.log('obj1',obj1) 
// obj1 { name: '浪里行舟', arr: [ 1, [ 5, 6, 7 ], 4 ] }
console.log('obj3',obj3) 
// obj3 { name: '阿浪', arr: [ 1, [ 5, 6, 7 ], 4 ] }