JS Array的方法

1、concat()：数组拼接

2、copyWithin(target, start, end)：浅复制

 复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。

target：复制到的地方

start：复制开始 从0开始

end：复制结束 到end 指向的下标的前一个

3、entries()：迭代数组：返回下标和值

4、some()：测试一个数组内的所有元素是否有一个能通过指定函数的测试。它返回一个布尔值

let arr2 = [1, 8, 4, 2]
const re = arr2.some(it => it > 7)
console.log(re) //true

5、every()：测试一个数组内的所有元素是否都能通过指定函数的测试。它返回一个布尔值

let arr3 = [1, 8, 4, 2]
const re1 = arr3.every(it => it > 7)
console.log(re1) //false

 6、fill(value,start,end)：用一个固定值填充一个数组中从起始索引（默认为 0）到终止索引（默认为 array.length）内的全部元素。它返回修改后的数组。

7、filter()：过滤数组 过滤过滤条件相反的

8、find() ：寻找数字

let arr2 = [1, 8, 4, 2]
const re2 = arr2.find(it => it > 3)
console.log(re2); //8

1. findIndex() ：

let arr2 = [1, 8, 4, 2]
const re2 = arr2.findIndex(it => it > 3)
console.log(re2); //1

2. findLast() ：

let arr2 = [1, 8, 4, 2]        
const re2 = arr2.findLast(it => it > 3)
console.log(re2); //4

3. findLastIndex()

let arr2 = [1, 8, 4, 2]        
const re2 = arr2.findLastIndex(it => it > 3)
console.log(re2); //2

9、flat()：创建一个新的数组，并根据指定深度递归地将所有子数组元素拼接到新的数组中。

let arr1 = [0, 1, 2, [3, 4]];
console.log(arr1.flat()); //[0, 1, 2, 3, 4]

10、flatMap()：对数组中的每个元素应用给定的回调函数，然后将结果展开一级，返回一个新数组

const arr1 = [1, 2, 1];
const result = arr1.flatMap((num) => (num === 2 ? [2, 2] : 1));
console.log(result); // [1, 2, 2, 1]

11、from()：从可迭代或类数组对象创建一个新的浅拷贝的数组实例，map()：创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成

console.log(Array.from('foo')); //["f", "o", "o"]
console.log(Array.from([1, 2, 3], (x) => x + x)); //[2, 4, 6]

//-------------------------------------------------------------------

const array1 = [1, 4, 9, 16];
const map1 = array1.map((x) => x * 2);
console.log(map1); //[2, 8, 18, 32]

12、includes()：断一个数组是否包含一个指定的值

const array1 = [1, 2, 3];
console.log(array1.includes(2)); //true

13、indexOf() / lastIndexOf()：返回数组中第一次 / 最后一次出现给定元素的下标，如果不存在则返回 -1

const beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];
console.log(beasts.indexOf('bison')); //1
//---------------------------------------------------------
console.log(beasts.lastindexOf('bison')) //1

14、isArray()：确定传递的值是否是一个Array

console.log(Array.isArray([1, 3, 5])); //true
console.log(Array.isArray('[]')); //false
console.log(Array.isArray(new Array(5))); //true
console.log(Array.isArray(new Int16Array([15, 33]))); //false

15、join()：返回连接后的数组

const elements = ['a', 'b', 'c'];
console.log(elements.join()); //a,b,c
console.log(elements.join('')); //abc
console.log(elements.join('-')); //a-b-c

16、keys()：把数组索引用数组形式返回

const array1 = ['a', 'b', 'c'];
const iterator = array1.keys();

for (const key of iterator) {
  console.log(key); //0 1 2
}

17、map()： 创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成

let arr = [
    {
        name: "数学",
        score: 99,
    },
    {
        name: "英语",
        score: 97,
    },
    {
        name: "语文",
        score: 96,
    },
    {
        name: "历史",
        score: 50,
    },
    {
        name: "地理",
        score: 36,
    },
];

//   1. 把及格的分数的科目名称拼接成字符串  格式 数学、英语、语文
const re = arr.filter(it => it.score >= 60).map(it => it.name).join("、")
console.log(re);
//   2. 在每一个对象中 加上一个索引的字段 格式 ：[ {   name: "数学",  score: 99, idx:0  },{   name: "语文",  score: 96, idx:1  }]
let arr1 = arr
let newarr = []
const re1 = arr.map((item, index) => ({ name: item.name, score: item.score, str: index }))
console.log(re1);
//   3. 在每一个对象中 加上一个拼接的字段  格式 ：[ {   name: "数学",  score: 99, str:'数学-99'  },{   name: "语文",  score: 99, str:'语文-96'}]
const re2 = arr.map((item, index) => ({ name: item.name, score: item.score, str: item.name + "-" + item.score }))
console.log(re2);

map(item, index) ：元素，索引

18、pop()：从数组中删除最后一个元素，并返回该元素的值。此方法会更改数组的长度。

let arr3 = [1, 3, 5]
const re3 = arr3.pop()
console.log(re3); // 5

19、push()：方法将指定的元素添加到数组的末尾，并返回新的数组长度。

let arr4 = [1, 3, 5]
const re4 = arr4.push(6)
console.log(re4, arr4); // 4 [1, 3, 5, 6]

20、reduce()：对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。

let arr = [
    {
        name: "数学",
        score: 99,
    },
    {
        name: "英语",
        score: 97,
    },
    {
        name: "语文",
        score: 96,
    },
];

// 1. 计算出最高分
const max = arr.reduce((acc, it) => acc > it.score ? acc : it.score, 0)
console.log("最高分:", max); //最高分: 99
// 2. 计算出最低分
const min = arr.reduce((acc, it) => acc < it.score ? acc : it.score)
console.log("最低分:",min); //"最低分: 96
// 3. 计算出总成绩
const sum = arr.reduce((acc, it) => acc + it.score, 0)
console.log("总成绩：", sum); //总成绩： 292

21、reverse()：反转数组中的元素，并返回同一数组的引用，toReversed()：返回一个元素顺序相反的新数组

let arr5 = ["1", "8", "4", "2"]
arr5.reverse()
console.log(arr5); //['2', '4', '8', '1']

22、shift()：从数组中删除第一个元素，并返回该元素的值

let arr6 = [1, 3, 5]
const re6 = arr6.shift()
console.log(arr6); // [3, 5]

23、slice()：返回一个新的数组对象，这一对象是一个由 start 和 end 决定的原数组的浅拷贝（包括 start，不包括 end），其中 start 和 end 代表了数组元素的索引。原始数组不会被改变

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
console.log(animals.slice(2)); //["camel", "duck", "elephant"]
console.log(animals.slice(2，4)); //["camel", "duck"]

24、sort()： 方法就地对数组的元素进行排序，并返回对相同数组的引用。默认排序是将元素转换为字符串，然后按照它们的 UTF-16 码元值升序排序，

toSorted()：返回一个新数组，其元素按升序排列

let arr7 = [7, 3, 0, 3, 6]
arr7.sort((a, b) => a - b) 
console.log(arr7); //[0, 3, 3, 6, 7]

25、splice()：通过移除或者替换已存在的元素和/或添加新元素就地改变一个数组的内容 ，

toSpliced()：返回一个新数组，并在给定的索引处删除和/或替换了一些元素

splice(start)
splice(start, deleteCount)
splice(start, deleteCount, item1)
splice(start, deleteCount, item1, item2, itemN)

const months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
console.log(months); //["Jan", "Feb", "March", "April", "June"]
months.splice(4, 1, 'May');
console.log(months); //["Jan", "Feb", "March", "April", "May"]

26、toString()：返回一个字符串，表示指定的数组及其元素

const array1 = [1, 2, 'a', '1a'];
console.log(array1.toString()); //"1,2,a,1a"

27、unshift()：将指定元素添加到数组的开头，并返回数组的新长度

let arr8 = [1, 3, 5]
const re8 = arr8.unshift(6)
console.log(re8, arr8); // 4 [6, 1, 3, 5]

28、values()：返回一个新的数组迭代器对象，该对象迭代数组中每个元素的值

const array1 = ['a', 'b', 'c'];
const iterator = array1.values();
for (const value of iterator) {
  console.log(value);
}
/**
a
b
c
*/

29、with()：使用方括号表示法修改指定索引值的复制方法版本。它会返回一个新数组，其指定索引处的值会被新值替换。

array.with(index, value)

let arr9 = [7, 3, 0, 3, 6]
const re9 = arr9.with(1, 1)
console.log(re9); //[7, 1, 0, 3, 6]