`Array.prototype.map()`

1.关键词：遍历

2.是否修改原数组：false

3.返回值：

newArray[]，回调函数的结果组成了新数组的每一个元素。

4.语法：

1
2
3


var new_array = arr.map((currentValue, index, array) => {
	// callback
})

currentValue：callback数组中正在处理的当前元素；
index：可选，callback数组中正在处理的当前元素的索引；
array：可选，map方法调用的数组，几乎不用

5.描述

map 方法会给原数组中的每个元素都按顺序调用一次 callback 函数。callback 每次执行后的返回值（包括undefined）组合起来形成一个新数组。 callback 函数只会在有值的索引上被调用；那些从来没被赋过值或者使用 delete 删除的索引则不会被调用。

因为map生成一个新数组，当你不打算使用返回的新数组却使用map是违背设计初衷的，请用forEach或者for-of替代。

callback 函数会被自动传入三个参数：数组元素，元素索引，原数组本身。

6.示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 求数组中每个元素的平方根
const arr = [4, 9, 16]
const newArr = arr.map(Math.sqrt)// [2, 3, 4]

// 使用map重新格式化数组中的对象
const arr = [
    { key:1, value:10 },
    { key:2, value:20 }
]
const newArr = arr.map((item) => {
    const rObj={}
    rObj[item.key] = item.value
    return rObj
})// [{ 1:10 },{ 2:20 }]

`Array.prototype.pop()`

1.关键词：删除

2.是否修改原数组：true

3.返回值：

从数组中删除的元素(当数组为空时返回undefined)

4.语法：

1

arr.pop()

5.描述：

pop 方法从一个数组中删除并返回最后一个元素。

pop 方法有意具有通用性。该方法和call()或apply() 一起使用时，可应用在类似数组的对象上。pop方法根据 length属性来确定最后一个元素的位置。如果不包含length属性或length属性不能被转成一个数值，会将length置为0，并返回undefined。

如果你在一个空数组上调用 pop()，它返回undefined。

6.示例

1
2
3
4


const arr = [1, 2, 3]
const poped = arr.pop()
// arr = [1, 2]
// poped = 3

`*Array.prototype.fill()`

1.关键词：修改、填充

2.是否修改原数组：true

3.返回值：

修改后的数组

4.语法：

1

arr.fill(value, start, end)

value：用来填充数组元素的值
start ：可选，起始索引，默认值为0
end ：可选，终止索引，默认值为 this.length

5.描述：

fill 方法接受三个参数 value, start 以及 end。 start 和end 参数是可选的, 其默认值分别为 0 和 this 对象的 length 属性值。

如果 start 是个负数, 则开始索引会被自动计算成为 length+start, 其中 length 是 this 对象的 length 属性值。如果 end 是个负数, 则结束索引会被自动计算成为 length+end。

当一个对象被传递给 fill方法的时候, 填充数组的是这个对象的引用。

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


[1, 2, 3].fill(4);               // [4, 4, 4]
[1, 2, 3].fill(4, 1);            // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
[1, 2, 3].fill(4, 3, 3);         // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
[1, 2, 3].fill(4, 3, 5);         // [1, 2, 3]
Array(3).fill(4);                // [4, 4, 4]
[].fill.call({ length: 3 }, 4);  
// {0: 4, 1: 4, 2: 4, length: 3}

// Objects by reference.
var arr = Array(3).fill({}) // [{}, {}, {}];
arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]

`*Array.prototype.find()`

1.关键词：查找

2.是否修改原数组：false

3.返回值：

数组中第一个满足所提供测试函数的元素的值，否则返回undefined

4.语法：

1
2
3


arr.find((element, index, array) => {
	// callback
})

element：当前遍历到的元素
index：可选，当前遍历到的索引
array：可选，数组本身，基本用不到

5.描述：

find方法对数组中的每一项元素执行一次 callback 函数，直至有一个 callback 返回 true。当找到了这样一个元素后，该方法会立即返回这个元素的值，否则返回undefined。注意 callback 函数会为数组中的每个索引调用即从 0 到 length - 1，而不仅仅是那些被赋值的索引，这意味着对于稀疏数组来说，该方法的效率要低于那些只遍历有值的索引的方法。

find方法不会改变数组。

6.示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


const inventory = [
    {name: 'apples', quantity: 2},
    {name: 'bananas', quantity: 0},
    {name: 'cherries', quantity: 5}
]

const result = inventory.find(fruit => {
    fruit.name === 'cherries'
})

console.log(result); 
// { name: 'cherries', quantity: 5 }

`Array.prototype.join()`

1.关键词：连接

2.是否修改原数组：false

3.返回值：

一个所有数组元素连接的字符串。如果 arr.length 为0，则返回空字符串

4.语法：

1

arr.join(分隔符)

5.描述：

所有的数组元素被转换成字符串，再用一个分隔符将这些字符串连接起来。

如果一个元素为 undefined 或 null，它会被转换为空字符串。

6.示例：

1
2
3
4
5
6
7
8
9


var a = ['Wind', 'Rain', 'Fire'];
var myVar1 = a.join();      
// "Wind,Rain,Fire"
var myVar2 = a.join(', ');  
// "Wind, Rain, Fire"
var myVar3 = a.join(' + '); 
// "Wind + Rain + Fire"
var myVar4 = a.join('');    
// "WindRainFire"

`Array.prototype.push()`

1.关键词：添加

2.是否修改原数组：true

3.返回值：

当调用该方法时，新的length属性值将被返回。

4.语法：

1

arr.push(element1, ..., elementN)

5.描述：

push方法将值追加到数组中。

唯一的原生类数组（array-like）对象是Strings，尽管如此，它们并不适用该方法，因为字符串是不可改变的。

6.示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 添加元素到数组
const sports = ["soccer", "baseball"];
// ["soccer", "baseball", "football", "swimming"]
const total = sports.push("football", "swimming");
// 4 

// 合并两个数组
const vegetables = ['parsnip', 'potato'];
const moreVegs = ['celery', 'beetroot'];

// 将第二个数组融合进第一个数组
// 相当于 vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);

console.log(vegetables); 
// ['parsnip', 'potato', 'celery', 'beetroot']

`Array.prototype.some()`

1.关键词：查找

2.是否修改原数组：false

3.返回值：

数组中有至少一个元素通过回调函数的测试就会返回**true**；所有元素都没有通过回调函数的测试返回值才会为false

4.语法：

1
2
3


arr.some((element, index, array) => {
	// callback
})

element:数组中正在处理的元素。
index :可选，数组中正在处理的元素的索引值。
array：可选，几乎不用

5.描述：

some() 为数组中的每一个元素执行一次 callback 函数，直到找到一个使得 callback 返回一个“真值”（即可转换为布尔值 true 的值）。如果找到了这样一个值，some() 将会立即返回 true。否则，some() 返回 false。callback 只会在那些”有值“的索引上被调用，不会在那些被删除或从来未被赋值的索引上调用。

callback 被调用时传入三个参数：元素的值，元素的索引，被遍历的数组。

some() 被调用时不会改变数组。

6.示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 使用箭头函数测试数组元素的值
[2, 5, 8, 1, 4].some(x => x > 10);  // false
[12, 5, 8, 1, 4].some(x => x > 10); // true

// 判断数组元素中是否存在某个值，可以用include()代替
var fruits = ['apple', 'banana', 'mango', 'guava'];

function checkAvailability(arr, val) {
  return arr.some(arrVal => val === arrVal);
}

checkAvailability(fruits, 'kela');   // false
checkAvailability(fruits, 'banana'); // true

`Array.prototype.sort()`

1.关键词：排序

2.是否修改原数组：true

3.返回值：

排序后的数组。请注意，数组已原地排序，并且不进行复制。

4.语法：

1

arr.sort([compareFunction])

compareFunction 可选

用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。

firstEl第一个用于比较的元素。
secondEl第二个用于比较的元素。

5.描述：

如果没有指明 compareFunction ，那么元素会按照转换为的字符串的诸个字符的Unicode位点进行排序。例如 “Banana” 会被排列到 “cherry” 之前。当数字按由小到大排序时，9 出现在 80 之前，但因为（没有指明 compareFunction），比较的数字会先被转换为字符串，所以在Unicode顺序上 “80” 要比 “9” 要靠前。

如果指明了 compareFunction ，那么数组会按照调用该函数的返回值排序。即 a 和 b 是两个将要被比较的元素：

如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前；
如果 compareFunction(a, b) 等于 0 ， a 和 b 的相对位置不变。备注： ECMAScript 标准并不保证这一行为，而且也不是所有浏览器都会遵守（例如 Mozilla 在 2003 年之前的版本）；
如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前。
compareFunction(a, b) 必须总是对相同的输入返回相同的比较结果，否则排序的结果将是不确定的。

6.示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// 数组升序排列
const nums = [4, 2, 5, 1, 3]
nums.sort((a, b) => a - b)
// [1, 2, 3, 4, 5]

// 对象按某个属性排序
const objs = [
    { name:'Sam', value:21 },
    { name:'Gsq', value:24 },
    { name:'Zs', value:23 },
    { name:'The', value:25 },
    { name:'Art', value:22 },
    { name:'Bob' },
]
// sort by value
objs.sort((a, b) => a.value - b.value)
// sort by name
objs.sort((a, b) => {
    const nameA = a.name.toUpperCase()
    const nameB = b.name.toUpperCase()
    if(nameA < nameB){ return -1 }
    if(nameA > nameB){ return 1 }
    return 0
})

`Array.prototype.every()`

1.关键词：测试，遍历

2.是否修改原数组：false

3.返回值：数组内全部成员都通过了测试，则返回true，否则返回false

4.语法：

1
2
3


arr.every((element, index, array) => {
	// callback
})

5.描述：

every 方法为数组中的每个元素执行一次 callback 函数，直到它找到一个会使 callback 返回falsy的元素。如果发现了一个这样的元素，every 方法将会立即返回 false。否则，callback 为每一个元素返回 true，every 就会返回 true。

若传入一个空数组，则直接返回true

6.示例：

1
2
3


// 检测所有数组元素是否都大于10
[12, 5, 6, 10].every(x => x >= 10) // false
[12, 78, 70, 10].every(x => x >= 10) // true

`Array.prototype.shift()`

1.关键词：删除

2.是否修改原数组：true

3.返回值：返回删除的元素，如果数组为空则返回undefined

4.语法：

1

arr.shift()

5.描述：

删除数组第一个元素，即索引为0的元素，并返回被移除的元素

6.示例

1
2
3


const arr = [1, 2, 3]
arr.shift()// 1
arr:[2, 3]

`Array.prototype.pop()`

1.关键词：删除

2.是否修改原数组：true

3.返回值：返回删除的元素，如果数组为空则返回undefined

4.语法：

1

arr.pop()

5.描述：

删除并返回数组最后一个元素

6.示例

1
2
3


const arr = [1, 2, 3]
arr.pop()// 3
arr:[1, 2]

`Array.prototype.slice()`

1.关键词：截取

2.是否修改原数组：false

3.返回值：一个含有被提取元素的新数组

4.语法：

1

arr.slice(begin, end)

begin可选，默认从0开始，如果是负数，表示从原数组的倒数第几个元素开始提取。如果大于原数组的长度，返回空数组；

end可选，默认到原数组末尾。返回的数组中不包括指定位置的元素，如果是负数，表示在原数组中的倒数几个元素结束抽取，如果大于数组长度，也会一直提取到数组末尾。

5.描述：

slice不会修改原数组，只会返回一个浅复制（如果改变两个数组任意一个，则另一个不会受影响）了原数组中部分元素的一个新数组。

6.示例：

1
2
3
4
5


var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
var citrus = fruits.slice(1, 3);

// fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
// citrus contains ['Orange','Lemon']

`Array.prototype.concat()`

1.关键词：合并

2.是否修改原数组：false

3.返回值：合并后的新数组

4.语法：

1

arr.concat(arr/value,...)

5.描述：

将数组或值连接成新数组。如果省略了参数，则concat会返回一个它所调用的已存在的数组的浅拷贝（只会复制对象引用）。

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


// 连接两个数组
var alpha = ['a', 'b', 'c'];
var numeric = [1, 2, 3];
alpha.concat(numeric);// ['a', 'b', 'c', 1, 2, 3]

// 连接三个数组
var num1 = [1, 2, 3],
    num2 = [4, 5, 6],
    num3 = [7, 8, 9];
var nums = num1.concat(num2, num3);// [1, 2, 3, 4, 5, 6, 7, 8, 9]

// 将值连接到数组
var alpha = ['a', 'b', 'c'];
var alphaNumeric = alpha.concat(1, [2, 3]);// ['a', 'b', 'c', 1, 2, 3]

// 合并嵌套数组
var num1 = [[1]];
var num2 = [2, [3]];
var num3=[5,[6]];

var nums = num1.concat(num2);// [[1], 2, [3]]
var nums2=num1.concat(4,num3);// [[1], 4, 5,[6]]

// 在num1数组中的数组添加新的值
num1[0].push(4);
// 也会改变合并后的数组
// 此时nums为 [[1, 4], 2, [3]]
// 此时nums2为 [[1, 4], 4, 5,[6]]

`Array.prototype.filter()`

1.关键词：测试，筛选

2.是否修改原数组：false

3.返回值：一个新的，由通过测试的元素组成的新数组，可能为空数组

4.语法：

1
2
3


arr.filter((item, index, array) => {
	// callback
})

5.描述：

filter 为数组中的每个元素调用一次 callback 函数，并利用所有使得 callback 返回true或等价于 true（即除 false、0、""、null、undefined 和 NaN 以外皆为真值）的值的元素创建一个新数组。

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 筛选大于10的元素
[5 ,11, 180, 6].fillter(i => i > 10)// [11, 180]

// 在数组中搜索
const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];

function filterItems(query) {
  return fruits.filter(i =>  el.toLowerCase().indexOf(query.toLowerCase()) > -1)
}

console.log(filterItems('ap')); // ['apple', 'grapes']
console.log(filterItems('an')); // ['banana', 'mango', 'orange']

`Array.prototype.splice()`

1.关键词：删除，替换

2.是否修改原数组：true

3.返回值：由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。

4.语法：

1

arr.splice(start, deleteCount, item1, ...)

start表示修改的开始位置（index），若大于数组长度，则从数组末尾开始添加内容；若为负值，则表示从数组末位开始的第几位（从1开始）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
deleteCount可选，表示要移除的数组元素的个数，如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）；如果 deleteCount 被省略了，或者它的值大于或者等于start之后的所有元素的数量，那么start之后数组的所有元素都会被删除；如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。
item1, item2, *...* 可选。要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。

5.描述：

如果添加进数组的元素个数不等于被删除的元素个数，数组的长度会发生相应的改变。

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


const arr = ["a", "b", "c", "d", "e"]

// 从第二位开始删除0个元素，插入”f“
arr.splice(2, 0, "f") // []
// arr = ["a", "b", "f", "c", "d", "e"]

// 从第 2 位开始删除 0 个元素，插入“g” 和 "h"
arr.splice(2, 0, "g", "h") // []
// arr = ["a", "b", "g", "h", "c", "d", "e"]

// 从第3位开始删除1个元素
arr.splice(3, 1) // ["d"]
// arr = ["a", "b", "c", "e"]

// 从倒数第2位开始删除1个元素
arr.splice(-2, 1) // ["d"]
// arr = ["a", "b", "c", "e"]

// 从第2位开始删除所有元素
arr.splice(2) // ["c", "d", "e"]
// arr = ["a", "b"]

`Array.prototype.forEach()`

1.关键词：遍历

2.是否修改原数组：depends

3.返回值：undefined

4.语法：

1
2
3


arr.forEach((currentValue, index, array) =>{
    // callback
})

5.描述：

针对每一个元素执行提供的函数。forEach适合于你并不打算改变数据，而只是想用数据做一些事情：比如存入数据库或则打印出来。

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 打印元素
['a', 'b', 'c'].forEach(i => {
    console.log(i)
})

// 复制一个对象
function copy(obj) {
  var copy = Object.create(Object.getPrototypeOf(obj));
  var propNames = Object.getOwnPropertyNames(obj);

  propNames.forEach(function(name) {
    var desc = Object.getOwnPropertyDescriptor(obj, name);
    Object.defineProperty(copy, name, desc);
  });

  return copy;
}

var obj1 = { a: 1, b: 2 };
var obj2 = copy(obj1); // obj2 looks like obj1 now

`Array.prototype.indexOf()`

1.关键词：查找

2.是否修改原数组：false

3.返回值：索引位置或-1

4.语法：

1

arr.indexOf(searchElement, fromIndex)

searchElement要查找的元素

fromIndex可选，开始查找的位置，若是负值则从末尾开始抵消

5.描述：

每个元素实际上都做===（strict equality）来判断

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 找出指定元素出现的所有位置
var indices = [];
var array = ['a', 'b', 'a', 'c', 'a', 'd'];
var element = 'a';
var idx = array.indexOf(element);
while (idx != -1) {
  indices.push(idx);
  idx = array.indexOf(element, idx + 1);
}
console.log(indices);
// [0, 2, 4]

`Array.prototype.lastIndexOf()`

1.关键词：查找

2.是否修改原数组：false

3.返回值：数组中该元素最后一次出现的索引，如未找到返回-1

4.语法：

1

arr.lastIndexOf(searchElement, fromIndex)

searchElement被查找的元素。

fromIndex 可选，从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找

5.描述：

每个元素实际上都做===（strict equality）来判断

6.示例：

`Array.prototype.reverse()`

1.关键词：反转

2.是否修改原数组：true

3.返回值：颠倒后的数组

4.语法：

1

arr.reverse()

5.描述：

reverse 方法颠倒数组中元素的位置，改变了数组，并返回该数组的引用

也可应用于类数组对象

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 反转数组
const a = [1, 2, 3];
a.reverse(); 
console.log(a); // [3, 2, 1]

// 反转类数组对象
const a = {0:1, 2:3, 4:5, length:3}
Array.prototype.reverse.call(a)
// {0:5, 2:3, 4:1, length:3}
// 对象中必须包含反应对象属性长度的属性length，否则不会发生任何改变

`Array.prototype.unshift()`

1.关键词：添加

2.是否修改原数组：true

3.返回值：该数组的新长度

4.语法：

1

arr.unshift(element1, ..., elementN)

5.描述：

unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)。

unshift 特意被设计成具有通用性；这个方法能够通过call或者apply方法作用于类数组对象上。不过对于没有 length 属性（代表从0开始的一系列连续的数字属性的最后一个）的对象，调用该方法可能没有任何意义。

6.示例：

1
2
3
4
5
6
7


// 在数组前添加元素
let arr = [4,5,6];
arr.unshift(1,2,3);
console.log(arr); // [1, 2, 3, 4, 5, 6]

arr.unshift([-4, -3]); // the new array length is 4
// arr is [[-4, -3], 4, 5, 6]

`*Array.prototype.includes()`

1.关键词：查找

2.是否修改原数组：false

3.返回值：Boolean

4.语法：

1

arr.includes(value, fromIndex)

value要查找的元素值（区分大小写）

fromIndex可选，开始索引，若为负值，则按升序从 array.length + fromIndex 的索引开始搜（即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。formIndex的不同情况见示例，默认为 0

5.描述：

用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。

对象数组不能使用，但适用于类对象数组

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

// 如果 fromIndex 大于等于数组的长度，则会返回 false，且该数组不会被搜索。
var arr = ['a', 'b', 'c'];
arr.includes('c', 3);   // false
arr.includes('c', 100); // false

// 计算出的索引小于 0
// 如果 fromIndex 为负值，计算出的索引将作为开始搜索searchElement的位置。如果计算出的索引小于 0，则整个数组都会被搜索。
var arr = ['a', 'b', 'c'];
// 3 - 100 = -97
arr.includes('a', -100); // true
arr.includes('a', -2); // false

`*Array.prototype.entries()`

1.关键词：遍历，迭代器

2.是否修改原数组：false

3.返回值：返回一个Array迭代器，包含每个索引与对应值的键值对数组

4.语法：

1

arr.entries()

5.描述：

iterator.next()返回一个对象，对于有元素的数组，是next{ value: Array(2), done: false }
next.done用于指示迭代器是否完成：在每次迭代时进行更新而且都是false，
直到迭代器结束done才是true。
next.value是一个["key","value"]的数组，是返回的迭代器中的元素值。

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


// 基本使用
let rawArray = ["a", "b", "c"]
let aEntries = rawArray.entries()
console.log(aEntries.next())
/*{value: Array(2), done: false}
          done:false
          value:(2) [0, "a"]
           __proto__: Object
*/

// 使用for..of循环
var arr = ["a", "b", "c"];
var iterator = arr.entries();
// undefined

for (let e of iterator) {
    console.log(e);
}

// [0, "a"] 
// [1, "b"] 
// [2, "c"]

// 二维数组按行排序
function sortArr(arr) {
    var goNext = true;
    var entries = arr.entries();
    while (goNext) {
        var result = entries.next();
        if (result.done !== true) {
            result.value[1].sort((a, b) => a - b);
            goNext = true;
        } else {
            goNext = false;
        }
    }
    return arr;
}

var arr = [[1,34],[456,2,3,44,234],[4567,1,4,5,6],[34,78,23,1]];
sortArr(arr);

/*(4) [Array(2), Array(5), Array(5), Array(4)]
    0:(2) [1, 34]
    1:(5) [2, 3, 44, 234, 456]
    2:(5) [1, 4, 5, 6, 4567]
    3:(4) [1, 23, 34, 78]
    length:4
    __proto__:Array(0)
*/

`*Array.prototype.keys()`

1.关键词：遍历，迭代器

2.是否修改原数组：false

3.返回值：返回数组索引的Array迭代器对象

4.语法：

1

arr.keys()

5.描述：一旦没有可迭代的值，aKeys.next()就会返回一个value属性为undefined、done属性为true的对象

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 基本使用
const aKeys = [1, 2, 3].keys()
console.log(aKeys.next())// {value: 0, done: false}
console.log(aKeys.next())// {value: 1, done: false}
console.log(aKeys.next())// {value: 2, done: false}
console.log(aKeys.next())// {value: undefined, done: true}

// 与Object.keys()区别
var arr = ["a", , "c"]
var objKeys = Object.keys(arr)// ["0", "2"]
var arrKeys = [...arr.keys()]// [0, 1, 2]
// 索引迭代器会包含那些没有对应元素的索引

`*Array.prototype.values()`

1.关键词：遍历，迭代器

2.是否修改原数组：false

3.返回值：返回数组值的Array迭代器对象

4.语法：

1

arr.values()

5.描述：

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// 基本使用
let aValues = [1, 2, 3].values()
console.log(aValues.next())// {value: 1, done: false}
console.log(aValues.next())// {value: 2, done: false}
console.log(aValues.next())// {value: 3, done: false}
console.log(aValues.next())// {value: undefined, done: true}

// 使用for...of循环
let arr = ['w', 'y', 'k', 'o', 'p'];
let eArr = arr.values();
// 您的浏览器必须支持 for..of 循环
// 以及 let —— 将变量作用域限定在 for 循环中
for (let letter of eArr) {
  console.log(letter);
}
// 如果在for...of前执行过next()方法，则不会遍历之前next()返回的值（因为已经被迭代过了，指针后移）

`*Array.from()`

1.关键词：浅拷贝

2.是否修改原数组：false

3.返回值：一个新的数组实例

4.语法：

1

Array.from(arrayLike, mapFn, thisArg)

arrayLike想要转换成数组的伪数组对象或可迭代对象。

mapFn 可选，如果指定了该参数，新数组中的每个元素会执行该回调函数。

thisArg 可选，执行回调函数 mapFn 时 this 对象。

5.描述：

Array.from() 可以通过以下方式来创建数组对象：

伪数组对象（拥有一个 length 属性和若干索引属性的任意对象）
可迭代对象（可以获取对象中的元素,如 Map和 Set 等）

Array.from() 方法有一个可选参数 mapFn，让你可以在最后生成的数组上再执行一次 map 方法后再返回。也就是说Array.from(obj, mapFn, thisArg)就相当于 Array.from(obj).map(mapFn, thisArg),

6.示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


// 从类数组对象（arguments）生成数组
function f() {
  return Array.from(arguments);
}

f(1, 2, 3);// [ 1, 2, 3 ]

// 从string生成数组
Array.from('foo'); // [ "f", "o", "o" ]

// 从set生成数组
const set = new Set(['foo', 'bar', 'baz', 'foo']);
Array.from(set);// [ "foo", "bar", "baz" ]

// 从map生成数组
const map = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(map);// [[1, 2], [2, 4], [4, 8]]

const mapper = new Map([['1', 'a'], ['2', 'b']]);
Array.from(mapper.values());// ['a', 'b'];
Array.from(mapper.keys());// ['1', '2'];

// 数组去重合并
function combine(){ 
    let arr = [].concat.apply([], arguments);  //没有去重复的新数组 
    return Array.from(new Set(arr));
} 

var m = [1, 2, 2], n = [2,3,3]; 
console.log(combine(m,n));// [1, 2, 3]

`*Array.of()`

1.关键词：创建

2.是否修改原数组：false

3.返回值：一个新的数组实例

4.语法：

1

Array.of(elements..)

elements任意个参数，将按顺序成为返回数组中的元素。

5.描述：

方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。

Array.of() 和 Array 构造函数之间的区别在于处理整数参数：

Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个长度为7的空数组（**注意：**这是指一个有7个空位(empty)的数组，而不是由7个undefined组成的数组）。

6.示例：

1
2
3
4
5


Array.of(7);       // [7] 
Array(7);          // [ , , , , , , ]

Array.of(1, 2, 3);   // [1, 2, 3]
Array.of(undefined); // [undefined]

Array常用方法整理

Contents

`Array.prototype.map()`

`Array.prototype.pop()`

`*Array.prototype.fill()`

`*Array.prototype.find()`

`Array.prototype.join()`

`Array.prototype.push()`

`Array.prototype.some()`

`Array.prototype.sort()`

`Array.prototype.every()`

`Array.prototype.shift()`

`Array.prototype.pop()`

`Array.prototype.slice()`

`Array.prototype.concat()`

`Array.prototype.filter()`

`Array.prototype.splice()`

`Array.prototype.forEach()`

`Array.prototype.indexOf()`

`Array.prototype.lastIndexOf()`

`Array.prototype.reverse()`

`Array.prototype.unshift()`

`*Array.prototype.includes()`

`*Array.prototype.entries()`

`*Array.prototype.keys()`

`*Array.prototype.values()`

`*Array.from()`

`*Array.of()`