
console.log(Array.of('foo', 2, 'bar', true));
// Expected output: Array ["foo", 2, "bar", true]
 
console.log(Array.of());
// Expected output: Array []

2.Array.prototype.pop()

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


const plants = ['broccoli', 'cauliflower', 'cabbage', 'kale', 'tomato'];
 
console.log(plants.pop());
// Expected output: "tomato"
 
console.log(plants);
// Expected output: Array ["broccoli", "cauliflower", "cabbage", "kale"]
 
plants.pop();
 
console.log(plants);
// Expected output: Array ["broccoli", "cauliflower", "cabbage"]

3.Array.prototype.push()

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


const animals = ['pigs', 'goats', 'sheep'];
 
const count = animals.push('cows');
console.log(count);
// Expected output: 4
console.log(animals);
// Expected output: Array ["pigs", "goats", "sheep", "cows"]
 
animals.push('chickens', 'cats', 'dogs');
console.log(animals);
// Expected output: Array ["pigs", "goats", "sheep", "cows", "chickens", "cats", "dogs"]

4.Array.prototype.reduce()

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

第一次执行回调函数时，不存在“上一次的计算结果”。如果需要回调函数从数组索引为 0 的元素开始执行，则需要传递初始值。否则，数组索引为 0 的元素将被用作初始值，迭代器将从第二个元素开始执行（即从索引为 1 而不是 0 的位置开始）。

下面的例子能够帮助你理解 reduce() 的用处——计算数组所有元素的总和：


const array1 = [1, 2, 3, 4];
 
// 0 + 1 + 2 + 3 + 4
const initialValue = 0;
const sumWithInitial = array1.reduce(
  (accumulator, currentValue) => accumulator + currentValue,
  initialValue
);
 
console.log(sumWithInitial);
// Expected output: 10

5.Array.prototype.reduceRight()

reduceRight() 方法对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。

对于从左至右遍历的相似方法，请参阅 Array.prototype.reduce()。


const array1 = [[0, 1], [2, 3], [4, 5]];
 
const result = array1.reduceRight((accumulator, currentValue) => accumulator.concat(currentValue));
 
console.log(result);
// Expected output: Array [4, 5, 2, 3, 0, 1]

6.Array.prototype.reverse()

reverse() 方法就地反转数组中的元素，并返回同一数组的引用。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。换句话说，数组中的元素顺序将被翻转，变为与之前相反的方向。

要在不改变原始数组的情况下反转数组中的元素，使用 toReversed()。


const array1 = ['one', 'two', 'three'];
console.log('array1:', array1);
// Expected output: "array1:" Array ["one", "two", "three"]
 
const reversed = array1.reverse();
console.log('reversed:', reversed);
// Expected output: "reversed:" Array ["three", "two", "one"]
 
// Careful: reverse is destructive -- it changes the original array.
console.log('array1:', array1);
// Expected output: "array1:" Array ["three", "two", "one"]

7.Array.prototype.shift()

shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。


const array1 = [1, 2, 3];
 
const firstElement = array1.shift();
 
console.log(array1);
// Expected output: Array [2, 3]
 
console.log(firstElement);
// Expected output: 1

8.Array.prototype.slice()

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


const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
 
console.log(animals.slice(2));
// Expected output: Array ["camel", "duck", "elephant"]
 
console.log(animals.slice(2, 4));
// Expected output: Array ["camel", "duck"]
 
console.log(animals.slice(1, 5));
// Expected output: Array ["bison", "camel", "duck", "elephant"]
 
console.log(animals.slice(-2));
// Expected output: Array ["duck", "elephant"]
 
console.log(animals.slice(2, -1));
// Expected output: Array ["camel", "duck"]
 
console.log(animals.slice());
// Expected output: Array ["ant", "bison", "camel", "duck", "elephant"]

9.Array.prototype.some()

some() 方法测试数组中是否至少有一个元素通过了由提供的函数实现的测试。如果在数组中找到一个元素使得提供的函数返回 true，则返回 true；否则返回 false。它不会修改数组。


const array = [1, 2, 3, 4, 5];
 
// Checks whether an element is even
const even = (element) => element % 2 === 0;
 
console.log(array.some(even));
// Expected output: true

10.Array.prototype.sort()

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

由于它取决于具体实现，因此无法保证排序的时间和空间复杂度。

如果想要不改变原数组的排序方法，可以使用 toSorted()。


const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// Expected output: Array ["Dec", "Feb", "Jan", "March"]
 
const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);
// Expected output: Array [1, 100000, 21, 30, 4]

11.Array.prototype.splice()

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

要创建一个删除和/或替换部分内容而不改变原数组的新数组，请使用 toSpliced()。要访问数组的一部分而不修改它，参见 slice()。


const months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
// Inserts at index 1
console.log(months);
// Expected output: Array ["Jan", "Feb", "March", "April", "June"]
 
months.splice(4, 1, 'May');
// Replaces 1 element at index 4
console.log(months);
// Expected output: Array ["Jan", "Feb", "March", "April", "May"]

12.Array.prototype.toLocaleString()

toLocaleString() 方法返回一个字符串，表示数组中的所有元素。每个元素通过调用它们自己的 toLocaleString 方法转换为字符串，并且使用特定于语言环境的字符串（例如逗号“,”）分隔开。


const array1 = [1, 'a', new Date('21 Dec 1997 14:12:00 UTC')];
const localeString = array1.toLocaleString('en', { timeZone: 'UTC' });
 
console.log(localeString);
// Expected output: "1,a,12/21/1997, 2:12:00 PM",
// This assumes "en" locale and UTC timezone - your results may vary

13.Array.prototype.toReversed()

Array 实例的 toReversed() 方法是 reverse() 方法对应的复制版本。它返回一个元素顺序相反的新数组。

toReversed()

14.Array.prototype.toSorted()

Array 实例的 toSorted() 方法是 sort() 方法的复制方法版本。它返回一个新数组，其元素按升序排列。


// 不传入函数
toSorted()
 
// 传入箭头函数
toSorted((a, b) => { /* … */ })
 
// 传入比较函数
toSorted(compareFn)
 
// 內联比较函数
toSorted(function compareFn(a, b) { /* … */ })

15. Array.prototype.toSpliced()

Array 实例的 toSpliced() 方法是 splice() 方法的复制版本。它返回一个新数组，并在给定的索引处删除和/或替换了一些元素。


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

16. Array.prototype.toString()

toString() 方法返回一个字符串，表示指定的数组及其元素。


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

17.Array.prototype.unshift()

unshift() 方法将指定元素添加到数组的开头，并返回数组的新长度。


const array1 = [1, 2, 3];
 
console.log(array1.unshift(4, 5));
// Expected output: 5
 
console.log(array1);
// Expected output: Array [4, 5, 1, 2, 3]

18.Array.prototype.at()

at() 方法接收一个整数值并返回该索引对应的元素，允许正数和负数。负整数从数组中的最后一个元素开始倒数。


const array1 = [5, 12, 8, 130, 44];
 
let index = 2;
 
console.log(`Using an index of ${index} the item returned is ${array1.at(index)}`);
// Expected output: "Using an index of 2 the item returned is 8"
 
index = -2;
 
console.log(`Using an index of ${index} item returned is ${array1.at(index)}`);
// Expected output: "Using an index of -2 item returned is 130"

19.Array.prototype.concat()

concat() 方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。


const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);
 
console.log(array3);
// Expected output: Array ["a", "b", "c", "d", "e", "f"]

20.Array.prototype.copyWithin()

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


const array1 = ['a', 'b', 'c', 'd', 'e'];
 
// Copy to index 0 the element at index 3
console.log(array1.copyWithin(0, 3, 4));
// Expected output: Array ["d", "b", "c", "d", "e"]
 
// Copy to index 1 all elements from index 3 to the end
console.log(array1.copyWithin(1, 3));
// Expected output: Array ["d", "d", "e", "d", "e"]

21.Array.prototype.entries()

entries() 方法返回一个新的数组迭代器 (en-US)对象，该对象包含数组中每个索引的键/值对。


const array1 = ['a', 'b', 'c'];
 
const iterator1 = array1.entries();
 
console.log(iterator1.next().value);
// Expected output: Array [0, "a"]
 
console.log(iterator1.next().value);
// Expected output: Array [1, "b"]

22.Array.prototype.every()

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


const isBelowThreshold = (currentValue) => currentValue < 40;
 
const array1 = [1, 30, 39, 29, 10, 13];
 
console.log(array1.every(isBelowThreshold));
// Expected output: true

23.Array.prototype.fill()

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


const array1 = [1, 2, 3, 4];
 
// Fill with 0 from position 2 until position 4
console.log(array1.fill(0, 2, 4));
// Expected output: Array [1, 2, 0, 0]
 
// Fill with 5 from position 1
console.log(array1.fill(5, 1));
// Expected output: Array [1, 5, 5, 5]
 
console.log(array1.fill(6));
// Expected output: Array [6, 6, 6, 6]

24.Array.prototype.filter()

filter() 方法创建给定数组一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。


const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
 
const result = words.filter(word => word.length > 6);
 
console.log(result);
// Expected output: Array ["exuberant", "destruction", "present"]

25.Array.prototype.find()

find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。如果需要在数组中找到对应元素的索引，请使用 findIndex()。如果需要查找某个值的索引，请使用 Array.prototype.indexOf()。（它类似于 findIndex()，但只是检查每个元素是否与值相等，而不是使用测试函数。）如果需要查找数组中是否存在某个值，请使用 Array.prototype.includes()。同样，它检查每个元素是否与值相等，而不是使用测试函数。如果需要查找是否有元素满足所提供的测试函数，请使用 Array.prototype.some()。


const array1 = [5, 12, 8, 130, 44];
 
const found = array1.find(element => element > 10);
 
console.log(found);
// Expected output: 12

26.Array.prototype.findIndex()

findIndex() 方法返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1。

另请参阅 find() 方法，它返回满足测试函数的第一个元素（而不是它的索引）。


const array1 = [5, 12, 8, 130, 44];
 
const isLargeNumber = (element) => element > 13;
 
console.log(array1.findIndex(isLargeNumber));
// Expected output: 3

27.Array.prototype.findLast()

findLast() 方法反向迭代数组，并返回满足提供的测试函数的第一个元素的值。如果没有找到对应元素，则返回 undefined

如果你需要找到：

第一个匹配的元素，使用 find()。
数组中最后一个匹配元素的索引，使用 findLastIndex()。
某个值的索引，使用 indexOf()。（它类似于 findIndex()，但是会检查每个元素是否与值相等，而不是使用一个测试函数。）
该数组中是否存在一个值，使用 includes()。同样地，它检查每个元素是否和值相等，而不是使用一个测试函数。
是否有任意一个元素满足提供的测试函数，使用 some()


const array1 = [5, 12, 50, 130, 44];
 
const found = array1.findLast((element) => element > 45);
 
console.log(found);
// Expected output: 130

28.Array.prototype.findLastIndex()

findLastIndex() 方法反向迭代数组，并返回满足所提供的测试函数的第一个元素的索引。若没有找到对应元素，则返回 -1。

另请参见 findLast() 方法，该方法返回最后一个满足测试函数的元素的值（而不是它的索引）。


const array1 = [5, 12, 50, 130, 44];
 
const isLargeNumber = (element) => element > 45;
 
console.log(array1.findLastIndex(isLargeNumber));
// Expected output: 3
// Index of element with value: 130

29.Array.prototype.flat()

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


const arr1 = [0, 1, 2, [3, 4]];
 
console.log(arr1.flat());
// Expected output: Array [0, 1, 2, 3, 4]
 
const arr2 = [0, 1, 2, [[[3, 4]]]];
 
console.log(arr2.flat(2));
// Expected output: Array [0, 1, 2, Array [3, 4]]

30.Array.prototype.flatMap()

flatMap() 方法对数组中的每个元素应用给定的回调函数，然后将结果展开一级，返回一个新数组。它等价于在调用 map() 方法后再调用深度为 1 的 flat() 方法（arr.map(...args).flat()），但比分别调用这两个方法稍微更高效一些。


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

31.Array.prototype.forEach()

forEach() 方法对数组的每个元素执行一次给定的函数。


const array1 = ['a', 'b', 'c'];
 
array1.forEach(element => console.log(element));
 
// Expected output: "a"
// Expected output: "b"
// Expected output: "c"

32.Array.from()

Array.from() 静态方法从可迭代或类数组对象创建一个新的浅拷贝的数组实例。

转换异步的可迭代对象到数组，可以使用 Array.fromAsync()。


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

33.Array.prototype.indexOf()

indexOf() 方法返回数组中第一次出现给定元素的下标，如果不存在则返回 -1。


const beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];
 
console.log(beasts.indexOf('bison'));
// Expected output: 1
 
// Start from index 2
console.log(beasts.indexOf('bison', 2));
// Expected output: 4
 
console.log(beasts.indexOf('giraffe'));
// Expected output: -1

34.Array.isArray()

Array.isArray() 静态方法用于确定传递的值是否是一个 Array。


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

35.Array.prototype.join()

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.prototype.keys()

keys() 方法返回一个新的数组迭代器 (en-US)对象，其中包含数组中每个索引的键。


const array1 = ['a', 'b', 'c'];
const iterator = array1.keys();
 
for (const key of iterator) {
  console.log(key);
}
 
// Expected output: 0
// Expected output: 1
// Expected output: 2

37.Array.prototype.map()

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


const array1 = [1, 4, 9, 16];
 
// Pass a function to map
const map1 = array1.map(x => x * 2);
 
console.log(map1);
// Expected output: Array [2, 8, 18, 32]

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/477010