数组方法
**1 arr.push() **
从后面添加元素，返回值为添加完后的数组的长度
let arr = [1,2,3,4,5]
console.log(arr.push(5)) // 6
console.log(arr) // [1,2,3,4,5,5]
2 arr.pop()
从后面删除元素，只能是一个，返回值是删除的元素*
let arr = [1,2,3,4,5]
console.log(arr.pop()) // 5
console.log(arr) //[1,2,3,4]
3 arr.shift()
从前面删除元素，只能删除一个 返回值是删除的元素
let arr = [1,2,3,4,5]
console.log(arr.shift()) // 1
console.log(arr) // [2,3,4,5]
4 arr.unshift()
从前面添加元素, 返回值是添加完后的数组的长度
let arr = [1,2,3,4,5]
console.log(arr.unshift(2)) // 6
console.log(arr) //[2,1,2,3,4,5]
5 arr.splice(i,n,item)
删除从i(索引值)开始之后的那个元素。返回值是删除的元素*
参数： i 索引值 n 个数 item 添加的元素
let arr = [1,2,3,4,5]
console.log(arr.splice(2,2)) //[3,4]
console.log(arr) // [1,2,5]
console.log(arr.splice(0,1,6));// [6,2,3,4,5]
6 arr.concat()
连接两个数组 返回值为连接后的新数组
let arr = [1,2,3,4,5]
console.log(arr.concat([1,2])) // [1,2,3,4,5,1,2]
console.log(arr) // [1,2,3,4,5]
**7 str.split() **
将字符串转化为数组
let str = '123456'
console.log(str.split('')) // ["1", "2", "3", "4", "5", "6"]
8 arr.sort()
将数组进行排序,返回值是排好的数组，默认是按照最左边的数字进行排序，不是按照数字大小排序的，见例子。
let arr = [2,10,6,1,4,22,3]
console.log(arr.sort()) // [1, 10, 2, 22, 3, 4, 6]
let arr1 = arr.sort((a, b) =>a - b)
console.log(arr1) // [1, 2, 3, 4, 6, 10, 22]
let arr2 = arr.sort((a, b) =>b-a)
console.log(arr2) // [22, 10, 6, 4, 3, 2, 1]
**9 arr.reverse() **
将数组反转,返回值是反转后的数组
let arr = [1,2,3,4,5]
console.log(arr.reverse()) // [5,4,3,2,1]
console.log(arr) // [5,4,3,2,1]
**10 arr.slice(start,end) **
切去索引值start到索引值end的数组，不包含end索引的值，返回值是切出来的数组
let arr = [1,2,3,4,5]
console.log(arr.slice(1,3)) // [2,3]
console.log(arr) // [1,2,3,4,5]
**11 arr.forEach(callback) **
遍历数组,无return
*注意：（伪数组转成真数组才能遍历 Array.prototype.slice.call(伪数组) ）
callback的参数： value --当前索引的值
index --索引
array --原数组
let arr = [1,2,3,4,5]
arr.forEach( (value,index,array)=>{
console.log(`value:${value} index:${index} array:${array}`)
})
// value:1 index:0 array:1,2,3,4,5
// value:2 index:1 array:1,2,3,4,5
// value:3 index:2 array:1,2,3,4,5
// value:4 index:3 array:1,2,3,4,5
// value:5 index:4 array:1,2,3,4,5
let arr = [1,2,3,4,5]
arr.forEach( (value,index,array)=>{
value = value * 2
console.log(`value:${value} index:${index} array:${array}`)
})
console.log(arr)
// value:2 index:0 array:1,2,3,4,5
// value:4 index:1 array:1,2,3,4,5
// value:6 index:2 array:1,2,3,4,5
// value:8 index:3 array:1,2,3,4,5
// value:10 index:4 array:1,2,3,4,5
// [1, 2, 3, 4, 5]
**12 arr.map(callback) **
映射数组(遍历数组),有return 返回一个新数组
callback的参数： value --当前索引的值
index --索引
array --原数组
let arr = [1,2,3,4,5]
arr.map( (value,index,array)=>{
value = value * 2
console.log(`value:${value} index:${index} array:${array}`)
})
console.log(arr)
ps: arr.forEach()和arr.map()的区别
\1. arr.forEach()是和for循环一样，是代替for。arr.map()是修改数组其中的数据，并返回新的数据。
\2. arr.forEach() 没有return arr.map() 有return
13 arr.filter(callback)
过滤数组，返回一个满足要求的数组\
例如做搜索功能
let arr = [1,2,3,4,5]
let arr1 = arr.filter( (i, v) => i < 3)
console.log(arr1) // [1, 2]
**14 arr.every(callback) **
依据判断条件，数组的元素是否每一项都满足，若满足则返回ture
let arr = [1,2,3,4,5]
let arr1 = arr.every( (i, v) => i < 3)
console.log(arr1) // false
let arr2 = arr.every( (i, v) => i < 10)
console.log(arr2) // true
**15 arr.some() **
依据判断条件，数组的元素是否有一个满足，若有一个满足则返回ture
*可以做元素在不在数组中的验证
let arr = [1,2,3,4,5]
let arr1 = arr.some( (i, v) => i < 3)
console.log(arr1) // true
let arr2 = arr.some( (i, v) => i > 10)
console.log(arr2) // false
**16 arr.reduce(callback, initialValue) **
迭代数组的所有项，累加器，数组中的每个值（从左到右）合并，最终计算为一个值
参数： callback: previousValue 必选 --上一次调用回调返回的值，或者是提供的初始值（initialValue）
currentValue 必选 --数组中当前被处理的数组项
index 可选 --当前数组项在数组中的索引值
array 可选 --原数组
initialValue: 可选 --初始值
实行方法：回调函数第一次执行时，preValue 和 curValue 可以是一个值，如果 initialValue 在调用 reduce() 时被提供，那么第一个 preValue 等于 initialValue ，并且curValue 等于数组中的第一个值；如果initialValue 未被提供，那么preValue 等于数组中的第一个值.
let arr = [0,1,2,3,4]
let arr1 = arr.reduce((preValue, curValue) =>
preValue + curValue
)
console.log(arr1) // 10
let arr2 = arr.reduce((preValue,curValue)=>preValue + curValue,5)
console.log(arr2) // 15
**17 arr.reduceRight(callback, initialValue) **
与arr.reduce()功能一样，不同的是，reduceRight()从数组的末尾向前将数组中的数组项做累加。
实行方法：reduceRight()首次调用回调函数callbackfn时，prevValue 和 curValue 可以是两个值之一。如果调用 reduceRight() 时提供了 initialValue 参数，则 prevValue 等于 initialValue，curValue 等于数组中的最后一个值。如果没有提供 initialValue 参数，则 prevValue 等于数组最后一个值， curValue 等于数组中倒数第二个值。
let arr = [0,1,2,3,4]
let arr1 = arr.reduceRight((preValue, curValue) =>preValue + curValue)
console.log(arr1) // 10
let arr2 = arr.reduceRight((preValue,curValue)=>preValue + curValue,5)
console.log(arr2) // 15
ps：(如果对这两个方法不明白，可以查看大漠老师的实例 http://www.w3cplus.com/javascript/array-part-8.html)
**18 arr.indexOf() **
查找某个元素的索引值，若有重复的，则返回第一个查到的索引值若不存在，则返回 -1,第二个参数为fromIndex
let arr = [1,2,3,4,5,2]
let arr1 = arr.indexOf(2)
console.log(arr1) // 1
let arr2 = arr.indexOf(9)
console.log(arr2) // -1
**19 arr.lastIndexOf() **
** 和arr.indexOf()的功能一样，不同的是从后往前查找******
let arr = [1,2,3,4,5,2]
let arr1 = arr.lastIndexOf(2)
console.log(arr1) // 5
let arr2 = arr.lastIndexOf(9)
console.log(arr2) // -1
20 Array.from()
静态方法,将伪数组变成数组，就是只要有length的就可以转成数组。 —es6
let str = '12345'
console.log(Array.from(str)) // ["1", "2", "3", "4", "5"]
let obj = {0:'a',1:'b',length:2}
console.log(Array.from(obj)) // ["a", "b"]
**21 Array.of() **
将一组值转换成数组，类似于声明数组 —es6
let str = '11'
console.log(Array.of(str)) // ['11']
等价于
console.log(new Array('11')) // ['11]
ps:
但是new Array()有缺点，就是参数问题引起的重载
console.log(new Array(2)) //[empty × 2] 是个空数组
console.log(Array.of(2)) // [2]
Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]
Array(7); // [ , , , , , , ]
Array(1, 2, 3); // [1, 2, 3]
**22 arr.copyWithin() **
在当前数组内部，将指定位置的数组复制到其他位置，会覆盖原数组项，返回当前数组
参数: target --必选 索引从该位置开始替换数组项
start --可选 索引从该位置开始读取数组项，默认为0.如果为负值，则从右往左读。
end --可选 索引到该位置停止读取的数组项，默认是Array.length,如果是负值，表示倒数
let arr = [1,2,3,4,5,6,7]
let arr1 = arr.copyWithin(1)
console.log(arr1) // [1, 1, 2, 3, 4, 5, 6]
let arr2 = arr.copyWithin(1,2)
console.log(arr2) // [1, 3, 4, 5, 6, 7, 7]
let arr3 = arr.copyWithin(1,2,4)
console.log(arr3) // [1, 3, 4, 4, 5, 6, 7]
23 arr.find(callback)
找到第一个符合条件的数组成员,否则返回undefined
let arr = [1,2,3,4,5,2,4]
let arr1 = arr.find((value, index, array) =>value > 2)
console.log(arr1) // 3
24 arr.findIndex(callback)
找到第一个符合条件的数组成员的索引值,没有找到返回-1
let arr = [1,2,3,4,5]
let arr1 = arr.findIndex((value, index, array) => value > 3)
console.log(arr1) // 3
25 arr.fill(target, start, end)
使用给定的值，填充一个数组,ps:填充完后会改变原数组
参数： target – 待填充的元素
start – 开始填充的位置-索引
end – 终止填充的位置-索引（不包括该位置)
let arr = [1,2,3,4,5]
let arr1 = arr.fill(5)
console.log(arr1) // [5, 5, 5, 5, 5]
console.log(arr) // [5, 5, 5, 5, 5]
let arr2 = arr.fill(5,2)
console.log(arr2) // [1,2,5,5,5]
let arr3 = arr.fill(5,1,3)
console.log(arr3) // [1,5,5,5,5]
26 arr.includes()
判断数中是否包含给定的值,返回true or false,第一个参数为要查找的元素值，第二个参数为起始的索引
let arr = [1,2,3,4,5]
let arr1 = arr.includes(2)
console.log(arr1) // ture
let arr2 = arr.includes(9)
console.log(arr2) // false
let arr3 = [1,2,3,NaN].includes(NaN)
console.log(arr3) // true
// 若fromIndex>=arr.length,则直接返回false
var arr = ['a', 'b', 'c'];
arr.includes('c', 3); // false
arr.includes('c', 100); // false
// 若fromIndex<0,则整个数组都会被搜索
var arr = ['a', 'b', 'c'];
arr.includes('a', -100); // true
arr.includes('b', -100); // true
arr.includes('c', -100); // true
arr.includes('a', -2); // false
includes 方法可以被其他类型对象调用
function() {
console.log([].includes.call(arguments, 'a')); // true
console.log([].includes.call(arguments, 'd')); // false
})('a','b','c');
ps:与indexOf()的区别：
1 indexOf()返回的是数值，而includes()返回的是布尔值
2 indexOf() 不能判断NaN，返回为-1 ，includes()则可以判断
27 arr.keys()
遍历数组的键名
let arr = [1,2,3,4]
let arr2 = arr.keys()
for (let key of arr2) {
console.log(key); // 0,1,2,3
}
28 arr.values()
遍历数组键值
let arr = [1,2,3,4]
let arr1 = arr.values()
for (let val of arr1) {
console.log(val); // 1,2,3,4
}
29 arr.entries()
遍历数组的键名和键值
let arr = [1,2,3,4]
let arr1 = arr.entries()
for (let e of arr1) {
console.log(e); // 1,2,3,4
}
30 arr.flat()
会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
flat()和flatMap()本质上就是是归纳（reduce） 与 合并（concat）的操作。
//flat()方法最基本的作用就是数组降维
var arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]
var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]
var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]
//使用 Infinity 作为深度，展开任意深度的嵌套数组
arr3.flat(Infinity);
// [1, 2, 3, 4, 5, 6]
// 扁平化与数组空项（会移除数组的空项）
var arr4 = [1, 2, , 4, 5];
arr4.flat();
// [1, 2, 4, 5]
31 arr.flatMap()
方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 和 深度值1的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些。 这里我们拿map方法与flatMap方法做一个比较。
var arr1 = [1, 2, 3, 4];
arr1.map(x => [x * 2]);
// [[2], [4], [6], [8]]
arr1.flatMap(x => [x * 2]);
// [2, 4, 6, 8]
// 只会将 flatMap 中的函数返回的数组 “压平” 一层
arr1.flatMap(x => [[x * 2]]);
// [[2], [4], [6], [8]]
31 Array.isArray()
判断传递的参数是否为一个数组
Array.isArray([1, 2, 3]); // true
Array.isArray({foo: 123}); // false
Array.isArray('foobar'); // false
Array.isArray(undefined); // false
31 array.at()
at() 方法接收一个整数值并返回该索引的项目，允许正数和负数。负整数从数组中的最后一个项目开始倒数
var arr=[1,2,3,4]
arr.at(-1) // 4
32 array.findLast()
方法返回数组中满足提供的测试函数的最后一个元素。若没有找到对应元素则返回undefined
const array1 = [5, 12, 50, 130, 44];
const found = array1.findLast((element) => element > 45);
console.log(found);
33 array.findLastIndex()
方法返回满足提供的测试功能的数组中最后一个元素的索引。如果没有元素满足测试函数，则返回 -1。
const array1 = [5, 12, 50, 130, 44];
const isLargeNumber = (element) => element > 45;
console.log(array1.findLastIndex(isLargeNumber)); // 3
34 array.group()
方法根据提供的测试函数返回的字符串值对调用数组的元素进行分组。返回的对象对每个组都有单独的属性，包含具有组中元素的数组。
const inventory = [
{ name: 'asparagus', type: 'vegetables', quantity: 5 },
{ name: 'bananas', type: 'fruit', quantity: 0 },
{ name: 'goat', type: 'meat', quantity: 23 },
{ name: 'cherries', type: 'fruit', quantity: 5 },
{ name: 'fish', type: 'meat', quantity: 22 }
];
let result = inventory.group( ({ type }) => type );
/* Result is:
{
vegetables: [
{ name: 'asparagus', type: 'vegetables', quantity: 5 },
],
fruit: [
{ name: "bananas", type: "fruit", quantity: 0 },
{ name: "cherries", type: "fruit", quantity: 5 }
],
meat: [
{ name: "goat", type: "meat", quantity: 23 },
{ name: "fish", type: "meat", quantity: 22 }
]
}
*/
35 array.groupToMap()
方法使用提供的测试函数返回的值对调用数组的元素进行分组。最终返回Map使用来自测试函数的唯一值作为键，可用于获取每个组中的元素数组。
const inventory = [
{ name: 'asparagus', type: 'vegetables', quantity: 5 },
{ name: 'bananas', type: 'fruit', quantity: 0 },
{ name: 'goat', type: 'meat', quantity: 23 },
{ name: 'cherries', type: 'fruit', quantity: 5 },
{ name: 'fish', type: 'meat', quantity: 22 }
];
const restock = { restock: true };
const sufficient = { restock: false };
const result = inventory.groupToMap( ({ quantity }) => quantity < 6 ? restock : sufficient );
console.log(result.get(restock));
// expected output: Array [Object { name: "bananas", type: "fruit", quantity: 5 }]
35 array.join()
方法将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。
const elements = ['Fire', 'Air', 'Water'];
console.log(elements.join());
// expected output: "Fire,Air,Water"
console.log(elements.join(''));
// expected output: "FireAirWater"
console.log(elements.join('-'));
// expected output: "Fire-Air-Water"
36 array.toLocaleString()
var prices = ['￥7', 500, 8123, 12];
prices.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' });
// "￥7,￥500,￥8,123,￥12"
37 array.toString()
const array1 = [1, 2, 'a', '1a'];
console.log(array1.toString());
// expected output: "1,2,a,1a"
Array 方法(表格版)
| 方法 | 描述 |
|---|---|
| concat() | 连接两个或多个数组，并返回已连接数组的副本。 |
| copyWithin() | 将数组中的数组元素复制到指定位置或从指定位置复制。 |
| entries() | 返回键/值对数组迭代对象。 |
| every() | 检查数组中的每个元素是否通过测试。 |
| fill() | 用静态值填充数组中的元素。 |
| filter() | 使用数组中通过测试的每个元素创建新数组。 |
| find() | 返回数组中第一个通过测试的元素的值。 |
| findIndex() | 返回数组中通过测试的第一个元素的索引。 |
| forEach() | 为每个数组元素调用函数。 |
| from() | 从对象创建数组。 |
| includes() | 检查数组是否包含指定的元素。 |
| indexOf() | 在数组中搜索元素并返回其位置。 |
| isArray() | 检查对象是否为数组。 |
| join() | 将数组的所有元素连接成一个字符串。 |
| keys() | 返回 Array Iteration 对象，包含原始数组的键. |
| lastIndexOf() | 在数组中搜索元素，从末尾开始，并返回其位置。 |
| map() | 使用为每个数组元素调用函数的结果创建新数组。 |
| pop() | 删除数组的最后一个元素，并返回该元素。 |
| push() | 将新元素添加到数组的末尾，并返回新的长度。 |
| reduce() | 将数组的值减为单个值（从左到右）。 |
| reduceRight() | 将数组的值减为单个值（从右到左）。 |
| reverse() | 反转数组中元素的顺序。 |
| shift() | 删除数组的第一个元素，并返回该元素。 |
| slice() | 选择数组的一部分，并返回新数组。 |
| some() | 检查数组中的任何元素是否通过测试。 |
| sort() | 对数组的元素进行排序。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的 |
| splice() | 从数组中添加/删除元素。添加时可以后面可以添加多个，不限量 |
| toString() | 将数组转换为字符串，并返回结果。 |
| unshift() | 将新元素添加到数组的开头，并返回新的长度。 |
| valueOf() | 返回数组的原始值。 |
arr实例方法（链接版）
-
Returns the array item at the given index. Accepts negative integers, which count back from the last item.
返回给定索引处的数组项. 接受负整数，从最后一项开始计数.
-
用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组
-
浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度
-
对一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例
-
返回一个新的
Array Iterator对象，该对象包含数组中每个索引的键/值对 -
创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型
-
测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值
-
用一个固定值填充一个数组中从起始索引到终止索引内的全部元素
-
创建一个新数组，其包含通过所提供函数实现的测试的所有元素
-
返回数组中满足提供的测试函数的第一个元素的值。否则返回
undefined -
返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回
-1 -
按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回
-
使用映射函数映射每个元素，然后将结果压缩成一个新数组
-
对数组的每个元素执行一次给定的函数
-
判断一个数组是否包含一个指定的值，如果包含则返回
true，否则返回false -
返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回
-1 -
将一个数组的所有元素连接成一个字符串并返回这个字符串
-
返回一个包含数组中每个索引键的
Array Iterator对象 -
返回指定元素在数组中的最后一个的索引，如果不存在则返回
-1 -
返回一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值
-
从数组中删除最后一个元素，并返回该元素的值
-
将一个或多个元素添加到数组的末尾，并返回该数组的新长度
-
对数组中的每个元素执行一个由您提供的 reducer 函数（升序执行），将其结果汇总为单个返回值
-
接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值
-
将数组中元素的位置颠倒，并返回该数组。该方法会改变原数组
-
从数组中删除第一个元素，并返回该元素的值
-
提取源数组的一部分并返回一个新数组
-
测试数组中是不是至少有一个元素通过了被提供的函数测试
-
对数组元素进行原地排序并返回此数组
-
通过删除或替换现有元素或者原地添加新的元素来修改数组，并以数组形式返回被修改的内容
-
Array.prototype.toLocaleString()返回一个字符串表示数组中的元素。数组中的元素将使用各自的
Object.prototype.toLocaleString()方法转成字符串 -
返回一个字符串表示指定的数组及其元素。数组中的元素将使用各自的
Object.prototype.toString()方法转成字符串 -
将一个或多个元素添加到数组的头部，并返回该数组的新长度
-
返回一个新的
Array Iterator 对象，该对象包含数组每个索引的值 -
返回一个新的
Array Iterator 对象，该对象包含数组每个索引的值
226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
