数组常用方法

1.会修改原数组

1.arr.push() 向数组末尾追加元素，返回值是修改后的length值，可以追加多个元素

2.arr.unshift()向数组开头添加元素，返回值也是修改后的length值，可以追加多个

3.arr.pop() 删除末尾的元素，返回值是被删除的元素，只能删除一个

4.arr.shift() 开头删除一个元素，返回值是被删除的元素，只能删除一个

5.arr.splice(位置，删除元素的个数，要追加的元素) ，任意位置添加删除，需要添加元素时，删除元素的个数写0；可以同时删除和添加，先删除后添加 ，可以添加多个元素，删除和添加的时候，包含当前下标。返回值是当前删除后的元素组成的数组，如果没有删除，就是一个空数组。

6.arr.sort() 数组的排序；没有参数，按照字符的编码开始按顺序排序，如果有参数，参数必须是一个回调函数，回调函数有两个参数，分别是a，b；返回值是排序后的数组；a-b是正序，b-a是倒序

ASCII值：常见的0-9：48-57； A-Z：65-90；a-z：97-122

7.arr.reverse() 数组倒序；返回修改后的数组；

var arr=[1,5,8,6,9,4,2,3];
console.log(arr.reverse());     // (8) [3, 2, 4, 9, 6, 8, 5, 1]
console.log(arr);               // (8) [3, 2, 4, 9, 6, 8, 5, 1]

2.不会修改原数组

1.arr.join("分隔符") 使用分隔符将数组数据隔开变为字符串；返回值是分隔好的字符串；当直接写为arr.join("")时，就会将数组变为字符串，分隔符是啥中间就是啥，啥也不写就是连接起来，如果括号里的引号也不写结果是：例如var arr=[1,2,3,4]; arr.join() 返回值是"1,2,3,4",如果为arr.join("") 结果为"1234";

2.arr.slice(截取的起始下标，结束下标) 数组的截取； 截取数据的时候，包含起始下标，不包含结束下标；返回值为截取到的数组，参数可以是负数，表示倒数，只传一个参数表示从起始下标截取到最后；

3.arr.concat() 多个数组的连接；返回值是连接后的新数组；

var arr1=[1,2,3];
var arr2=[4,5,6];
console.log(arr1.concat(arr2,[7,8,9]));
//[1,2,3,4,5,6,7,8,9]

4.arr.filter() 过滤，根据条件筛选数组元素；根据回调函数的返回值进行元素筛选，返回值为true，该元素会保留，返回值是false，该元素跳过；返回值就是筛选后的数组，接受一个回调函数，第一个参数是数组值，第二个参数是索引下标；

5.arr.map() 映射 将数组中的所有数据按照条件改变，形成新数组；接受一个回调函数，第一个参数是数组值，第二个参数是索引下标；返回值是映射改编后的数组。

3.其他一些方法

1.arr.indexOf(值)；查找某个值在数组中第一次出现的下标；

返回值是数据的下标，没有找到返回-1；可以有第二个参数，表示从某个 下标开始查找

2.arr.lastIndexOf(值)；倒叙查找某个值在数组中第一次出现的位置，找到返回下标，没有找到返回-1

3.arr.forEach() 遍历数组，接受一个回调函数，回调函数第一个参数是数组值，第二个是索引下标

4.arr.some() 判断 ，根据回调函数的判断条件来选择真假(可以与every比较记忆)；只要有一个回调函数返回值为true，最终some结果就是true；第一个参数是数组值，第二个是索引下标

5.arr.every() 判断，根据回调函数的判断条件来选择真假；只要有一个回调函数返回值是false，最终every的结果就是false；第一个参数是数组值，第二个是索引下标

6.Array.from() 该方法用于将两类对象转为真正的数组；类似数组的对象和可遍历的对象（包括 ES6 新增的数据结构 Set 和 Map）

7.Array.of() 将一组值转换为数组；总是返回参数值组成的数组。如果没有参数，就返回一个空数组

8.arr.includes() 用于检查数组是否包含某元素，包含返回true，否则返回false ，无法检测对象是否存在；假如只想知道某个值是否在数组中而并不关心它的索引位置，建议使用includes()。如果想获取一个值在数组中的位置，那么你只能使用indexOf方法。并且includes()可以识别NaN

var arr = [1,2,{name:"张三"}]
arr.includes(2)     // true
arr.includes(4)     // false
arr.includes({name:"张三"})     // false

可接受两个参数：要搜索的值，搜索开始的索引

['a', 'b', 'c', 'd'].includes('b')         // true
['a', 'b', 'c', 'd'].includes('b', 1)      // true
['a', 'b', 'c', 'd'].includes('b', 2)      // false

ES6中数组操作keys()、values()、entries()的使用与区别

1、Object.keys(Array )：对键名的遍历。

2、Object.values( Array)：对键值的遍历。

3、Object.entries( Array)：对键值对的遍历。

//对象 let data = {aa:2,bb:4,cc:7} 
console.log(Object.keys(data)); //['aa', 'bb', 'cc']
 console.log(Object.values(data)); // [2, 4, 7] 
console.log(Object.entries(data)); //[['aa', 2],['bb', 4],['cc', 7]] 

//数组 let data = [1,2,3,6] 
console.log(Object.keys(data)); //['0', '1', '2', '3'] 
console.log(Object.values(data)); // [1, 2, 3, 6,] 
console.log(Object.entries(data)); //[['0', 1], ['1', 2], ['2', 3],['3', 6]]

扩展运算符

实例方法：find()，findIndex()，findLast()，findLastIndex()

数组实例的find()方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。

[1, 5, 10, 15].find(function(value, index, arr) {
  return value > 9;
}) // 10

find()方法的回调函数可以接受三个参数，依次为当前的值、当前的位置和原数组。

数组实例的findIndex()方法的用法与find()方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。

另外，这两个方法都可以发现NaN，弥补了数组的indexOf()方法的不足。

[NaN].indexOf(NaN)
// -1
​
[NaN].findIndex(y => Object.is(NaN, y))
// 0

上面代码中，indexOf()方法无法识别数组的NaN成员，但是findIndex()方法可以借助Object.is()方法做到。

find()和findIndex()都是从数组的0号位，依次向后检查。ES2022 新增了两个方法findLast()和findLastIndex()，从数组的最后一个成员开始，依次向前检查，其他都保持不变。

const array = [
  { value: 1 },
  { value: 2 },
  { value: 3 },
  { value: 4 }
];
​
array.findLast(n => n.value % 2 === 1); // { value: 3 }
array.findLastIndex(n => n.value % 2 === 1); // 2

fill() 使用给定值，填充一个数组

['a', 'b', 'c'].fill(7)
// [7, 7, 7]
​
new Array(3).fill(7)
// [7, 7, 7]

上面代码表明，fill方法用于空数组的初始化非常方便。数组中已有的元素，会被全部抹去。

fill方法还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置。

['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']

注意，如果填充的类型为对象，那么被赋值的是同一个内存地址的对象，而不是深拷贝对象。

flat() flatMap()

flat()方法用于将嵌套的数组拉平，变为一维的数组，返回一个新数组，对原数据没有影响

[1, 2, [3, 4]].flat()
// [1, 2, 3, 4]

flat()默认只会“拉平”一层，如果想要“拉平”多层的嵌套数组，可以将flat()方法的参数写成一个整数，表示想要拉平的层数，默认为1。

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]

at()；JavaScript 不支持数组的负索引，如果要引用数组的最后一个成员，不能写成arr[-1]，只能使用arr[arr.length - 1]。

接受一个整数作为参数，返回对应位置的成员，并支持负索引。这个方法不仅可用于数组，也可用于字符串和类型数组。

const arr = [5, 12, 8, 130, 44];
arr.at(2) // 8
arr.at(-2) // 130

如果参数位置超出了数组范围，at()返回undefined。

const sentence = 'This is a sample sentence';
​
sentence.at(0); // 'T'
sentence.at(-1); // 'e'
​
sentence.at(-100) // undefined
sentence.at(100) // undefined

实例方法：toReversed()，toSorted()，toSpliced()，with()

它们分别对应数组的原有方法。

• toReversed()对应reverse()，用来颠倒数组成员的位置。

• toSorted()对应sort()，用来对数组成员排序。

• toSpliced()对应splice()，用来在指定位置，删除指定数量的成员，并插入新成员。

• with(index, value)对应splice(index, 1, value)，用来将指定位置的成员替换为新的值。

上面是这四个新方法对应的原有方法，含义和用法完全一样，唯一不同的是不会改变原数组，而是返回原数组操作后的拷贝。

数组的reduce方法和reduceRight方法：

reduce方法：方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

var arr = [1, 2, 3, 4, 5];

var res = arr.reduceRight(function (a, b) {

// console.log(a, b);

/*5 4 
9 3 
12 2 
14 1 */

return a + b;

})

console.log(res); //15

reduceRight 是从后往前，reduce是从前往后，最后结果相等，可以有第二个参数，

var objarr = [{ budget: 100 }, { budget: 200 }, { budget: 300 }];

var res2 = objarr.reduce(function (a, b) {

console.log(a, b);

return { budget: a.budget + b.budget }

}, { budget: 1000 });

console.log(res2);

第二个参数就是a，然后数组中的依次为参数b，下一次a还是第一次a和b的和，所以结果为1600

我们还可以用该方法和concat方法共同使用去将二维数组变为一维数组，此时reduce就是从前往后依次连接数组，而reduceRight就是从后面的数组开始连接，