目录
数组概念：
数组是一种数据结构，用于存储多个值的有序集合。数组可以包含不同类型的元素，如数字、字符串、对象，甚至其他数组（即多维数组）。
数组创建：
方式一：构造函数创建
let 数组名 = new Array([参数列表])
[参数列表]:代表可选的参数列表,可以不传入参数,也可以传一个或多个参数
-
如果不传入参数,则创建一个空数组
-
如果传入一个参数，则参数规定数组的长度
-
如果传入多个参数，则参数成为数组的元素
//创建一个空数组
let arr1 = new Array()
//创建一个长度为5的空数组
let arr2 = new Array(5)
//创建一个数组,包含元素[1,2,3,4,5]
let arr3 = new Array(1,2,3,4,5)数组没有内容只有长度的时候，数组内容用empty填充。
方式二：字面量创建
let 数组名 = []-
数组的字面量是方括号 [ ]
-
声明数组并赋值称为数组的初始化
//创建一个空数组
let arr1 = []
//创建一个数组,包含元素[1,2,3,4,5]
let arr2 = [1,2,3,4,5]数组操作:
数组可以通过索引来访问、设置、修改对应的数组元素，可以通过“数组名[索引]”的形式来操作数组中的元素。
数组元素获取:
获取数组中的单一元素
索引 (下标) ：用来访问数组元素的序号（数组下标从 0 开始）。
let arr = [1,2,3,4,5]
arr[2] // 3如果访问时数组没有和索引值对应的元素，则得到的值是undefined。
数组遍历:
逐个访问数组中的每个元素的过程
-
for循环
传统的 for 循环是最基本的数组遍历方式。
let array = [1, 2, 3, 4, 5];
for (let i = 0; i < array.length; i++) {
console.log(array[i]);
}
array.length(数组的长度)：默认情况下表示数组中元素的个数
-
for...of循环（ES6+）
for...of 循环是 ES6 引入的新语法，它可以直接遍历数组中的元素。
let array = [1, 2, 3, 4, 5];
for (let item of array) {
console.log(item);
}数组新增:
向数组中新增元素
let arr = [1, 2, 3];
//在数组最后新增一个元素
arr[arr.length] = 5;
arr[3]; //5
//等同于
arr[arr.length - 1]; //5数组修改:
修改数组中某一元素的值
let arr = [1, 2, 3];
//修改前
arr[1]; //2
//修改
arr[1] = 20;
//修改后
arr[1]; //20数组删除:
删除数组中的元素
let arr = [1, 2, 3];
//删除数组最后一个元素
arr.length -= 1;
//等同于
arr.length = arr.length - 1数组静态方法
数组静态方法是直接作用于 Array 构造函数本身，而不是作用于数组实例。这些方法用于创建、操作或检查数组，但它们不需要创建数组实例。
数组方法参数说明:
[ ]:可选的参数。
arrayLike:想要转换成数组的类数组或可迭代对象。
mapFn:调用数组每个元素的函数。
thisArg:执行mapFn时用作this的值。
value:数组和/或值。
element:添加到数组的元素。
Array.from(arrayLike, [mapFn], [thisArg])静态方法从可迭代或类数组对象创建一个新的浅拷贝的数组实例。
console.log(Array.from('foo'));// ["f", "o", "o"]
console.log(Array.from([1, 2, 3], (x) => x + x));// [2, 4, 6]
Array.fromAsync(arrayLike, [mapFn], [thisArg])静态方法可以由一个可迭代对象或类数组对象创建一个新的、浅拷贝的Array实例。
Array.fromAsync(
new Map([
[1, 2],
[3, 4],
]),
).then((array) => console.log(array));
// [[1, 2], [3, 4]]
Array.isArray(value)静态方法用于确定传递的值是否是一个数组。
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
Array.of(element1, ...)静态方法通过可变数量的参数创建一个新的Array实例，而不考虑参数的数量或类型。
console.log(Array.of('foo', 2, 'bar', true));// ["foo", 2, "bar", true]
console.log(Array.of());// []数组实例方法
数组实例方法是作用于数组实例的，即它们被用来操作数组对象本身。你需要先创建一个数组实例，然后调用这些方法。
下面将JS 中的数组方法按照功能模糊分类成以下几种来帮助理解和使用
修改
数组方法参数说明:
[ ]:可选的参数。
element:添加到数组的元素。
start:一个整数，表示要开始改变的数组的位置。
deleteCount:一个整数，表示数组中要从start开始删除的元素数量。
item:从start开始要加入到数组中的元素。
index:要修改的数组索引（从 0 开始），且将被转换为整数。
value:数组和/或值。
push(element1, ...):将指定的元素添加到数组的末尾，并返回数组的新长度。
let arr = ['一', '二', '三'];
let len = arr.push('四');
console.log(len); // 4
console.log(arr); // ['一', '二', '三', '四']
let len = arr.push('五','六','七');
console.log(arr); // ['一', '二', '三', '四', '五', '六', '七']
pop():从数组中删除最后一个元素，并返回该元素的值，当数组为空时返回undefined。
let arr = ['一', '二', '三', '四', '五'];
console.log(arr.pop()); // '五'
console.log(arr); // ['一', '二', '三', '四']
arr.pop();
console.log(arr); // ['一', '二', '三']
unshift(element1, ...):将指定元素添加到数组的开头，并返回数组的新长度。
let arr = [1, 2, 3];
console.log(arr.unshift(4, 5)); // 5
console.log(arr); // [4, 5, 1, 2, 3]
shift():从数组中删除第一个元素，并返回该元素的值，当数组为空时返回undefined。
let arr = [1, 2, 3];
let firstEl = arr.shift();
console.log(arr); // [2, 3]
console.log(firstEl); // 1
with(index, value):是使用方括号表示法修改指定索引值的复制方法版本。它会返回一个新数组，其指定索引处的值会被新值替换。
const arr = [1, 2, 3, 4, 5];
// 修改下标为 2 处的元素为 6
console.log(arr.with(2, 6)); // [1, 2, 6, 4, 5]
console.log(arr); // [1, 2, 3, 4, 5]
splice(start, [deleteCount], [item1, ...]):在给定的索引处移除或者替换已存在的元素和/或添加新的元素。
let arr = ['a', 'b', 'c', 'd'];
arr.splice(1, 0, 'e'); //在索引 1 处移除 0 个元素，并插入“e”
console.log(arr); // ['a', 'e', 'b', 'c', 'd']
arr.splice(4, 1, 'f'); //在索引 4 处移除 1 个元素，并插入“f”
console.log(arr); // ['a', 'e', 'b', 'c', 'f']
toSpliced(start, [deleteCount], [item1, ...]):splice()方法的复制版本。返回一个新数组，并在给定的索引处删除和/或替换了一些元素。
let arr =['a', 'b', 'c', 'd'];
// 在索引 1 处添加一个元素
let arr2 = arr.toSpliced(1, 0, "e");
console.log(arr2); // ['a', 'e', 'b', 'c', 'd']
// 从第 2 个索引开始删除两个元素
let arr3 = arr2.toSpliced(2, 2);
console.log(arr3); // ['a', 'e', 'd']
// 在索引 1 处用两个新元素替换一个元素
let arr4 = arr3.toSpliced(1, 1, "f", "g");
console.log(arr4); // ['a', 'f', 'g', 'd']
// 原数组不会被修改
console.log(arr); // ['a', 'b', 'c', 'd']查找
数组方法参数说明:
[ ]:可选的参数。
index:数组的索引
searchElement：数组中要查找的元素。
fromIndex：开始搜索的索引（默认从零开始），会转换为整数。
callbackFn:为数组中的每个元素执行的函数。
thisArg:执行callbackFn时用作this的值。
at(index):接收一个整数值并返回该索引对应的元素，允许正数和负数。负整数从数组中的最后一个元素开始倒数。
let arr = [5, 12, 8, 130, 44];
let index = 2;
console.log(`An index of ${index} returns ${arr.at(index)}`);// "An index of 2 returns 8"
index = -2;
console.log(`An index of ${index} returns ${arr.at(index)}`);// "An index of -2 returns 130"
includes(searchElement, [fromIndex]):用来判断一个数组是否包含一个指定的值，如果包含则返回true，否则返回false。
let arr = [1, 2, 3];
console.log(arr.includes(2));// true
let pets = ['cat', 'dog', 'bat'];
console.log(pets.includes('cat')); // true
console.log(pets.includes('at')); // false
indexOf(searchElement, [fromIndex]):返回数组中第一次出现给定元素的下标，如果不存在则返回 -1。
let arr = ['a', 'b', 'c', 'd', 'b'];
console.log(arr.indexOf('b'));// 1
// 从索引为2处开始查找
console.log(arr.indexOf('b', 2));// 4
console.log(arr.indexOf('e'));// -1
lastIndexOf(searchElement, [fromIndex]):返回数组中给定元素最后一次出现的索引，不存在则返回 -1。该方法从fromIndex开始向前搜索数组。
let animals = ['Dodo', 'Tiger', 'Penguin', 'Dodo'];
console.log(animals.lastIndexOf('Dodo')); // 3
console.log(animals.lastIndexOf('Tiger')); // 1
find(callbackFn, [thisArg]):返回数组中满足提供的测试函数的第一个元素的值。否则返回undefined。
let arr = [5, 12, 8, 130, 44];
// 在数组中找到第一个 > 10 的元素
let found = arr.find((element) => element > 10);
console.log(found);// 12
findIndex(callbackFn, [thisArg]):返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回 -1。
let arr = [5, 12, 8, 130, 44];
// 在数组中找到第一个 > 12 的元素的索引
let isLargeNumber = (element) => element > 13;
console.log(arr.findIndex(isLargeNumber)); // 3
findLast(callbackFn, [thisArg]):反向迭代数组，并返回满足提供的测试函数的第一个元素的值。如果没有找到对应元素，则返回undefined。
let arr = [5, 12, 50, 130, 44];
// 在数组中找到第一个 > 45 的元素,从后往前找
let found = arr.findLast((element) => element > 45);
console.log(found); // 130
findLastIndex(callbackFn, [thisArg]):反向迭代数组，并返回满足所提供的测试函数的第一个元素的索引。若没有找到对应元素，则返回 -1。
let arr = [5, 12, 50, 130, 44];
// 在数组中找到第一个 > 45 的元素的索引,从后往前找
let isLargeNumber = (element) => element > 45;
console.log(arr.findLastIndex(isLargeNumber)); // 3遍历
数组方法参数说明:
[ ]:可选的参数。
callbackFn:为数组中的每个元素执行的函数。
thisArg:执行callbackFn时用作this的值。
forEach(callbackFn, [thisArg]):对数组的每个元素执行一次给定的函数。
const arr = ['a', 'b', 'c'];
// 打印数组每一项
arr.forEach((element) => console.log(element)); // 'a' // 'b' // 'c'
map(callbackFn, [thisArg]):创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成。
const arr = [1, 4, 9, 16];
// 将元素组中的每个元素 * 2,并保存到新数组中
const map = arr.map((x) => x * 2);
console.log(map);// [2, 8, 18, 32]
every(callbackFn, [thisArg]):测试一个数组内的所有元素是否都能通过指定函数的测试。返回一个布尔值。
// 测试数组中的每一个元素是否都 < 40
const isBelowThreshold = (currentValue) => currentValue < 40;
const arr = [1, 30, 39, 29, 10, 13];
console.log(arr.every(isBelowThreshold)); // true
some(callbackFn, [thisArg]):测试数组中是否至少有一个元素通过了由提供的函数实现的测试。如果在数组中找到一个元素使得提供的函数返回
true，则返回true；否则返回false。
const arr = [1, 2, 3, 4, 5];
// 测试数组中是否存在对 2 取余为 0 的元素
const even = (element) => element % 2 === 0;
console.log(arr.some(even)); // true
filter(callbackFn, [thisArg]):创建给定数组一部分的浅拷贝，其包含通过所提供函数实现的测试的所有元素。
const words = ['spray', 'elite', 'exuberant', 'destruction', 'present'];
// 在数组中过滤处长度 > 6 的单词
const result = words.filter((word) => word.length > 6);
console.log(result);// ["exuberant", "destruction", "present"]
entries():返回一个新的数组迭代器对象，该对象包含数组中每个索引的键/值对。
const arr = ['a', 'b', 'c'];
// 迭代数组的索引和元素
const iterator = arr.entries();
console.log(iterator.next().value);// [0, "a"]
console.log(iterator.next().value);// [1, "b"]
keys():返回一个新的数组迭代器对象，其中包含数组中每个索引的键。
const arr = ['a', 'b', 'c'];
const iterator = arr.keys();
for (const key of iterator) {
// 遍历数组的索引
console.log(key); // 0 // 1 // 2
}
values():返回一个新的数组迭代器对象，该对象迭代数组中每个元素的值。
const arr = ['a', 'b', 'c'];
const iterator = arr.values();
for (const value of iterator) {
// 遍历数组的元素
console.log(value); // 'a' // 'b' // 'c'
}转换
数组方法参数说明:
[ ]:可选的参数。
separator:指定一个字符串来分隔数组的每个元素。
callbackFn:为数组中的每个元素执行的函数。
thisArg:执行callbackFn时用作this的值。
locales:带有BCP 47语言标签的字符串，或者此类字符串的数组。
options:一个具有配置属性的对象。
depth:指定要提取嵌套数组的结构深度，默认值为 1。
join([separator]):将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串，用逗号或指定的分隔符字符串分隔。如果数组只有一个元素，那么将返回该元素而不使用分隔符。
const elements = ['Fire', 'Air', 'Water'];
// 不传参数,默认使用 逗号
console.log(elements.join()); // "Fire,Air,Water"
// 传入 空字符串
console.log(elements.join('')); // "FireAirWater"
// 传入 -
console.log(elements.join('-'));// "Fire-Air-Water"
toString():返回一个字符串，表示指定的数组及其元素。
const array = [1, 2, 'a', '1a'];
console.log(array.toString()); // "1,2,a,1a"
toLocaleString([locales], [options]):返回一个字符串，表示数组中的所有元素。每个元素通过调用它们自己的
toLocaleString方法转换为字符串，并且使用特定于语言环境的字符串分隔开。
const array = [1, 'a', new Date('21 Dec 1997 14:12:00 UTC')];
const localeString = array.toLocaleString('en', { timeZone: 'UTC' });
console.log(localeString); // "1,a,12/21/1997, 2:12:00 PM",
flat([depth]):创建一个新的数组，并根据指定深度递归地将所有子数组元素拼接到新的数组中。
const arr1 = [0, 1, 2, [3, 4]];
console.log(arr1.flat()); // [0, 1, 2, 3, 4]
// 四维数组
const arr2 = [0, 1, [2, [3, [4, 5]]]];
// 三维数组
console.log(arr2.flat()); // [0, 1, 2, Array [3, Array [4, 5]]]
// 二维数组
console.log(arr2.flat(2)); // [0, 1, 2, 3, Array [4, 5]]
// 一维数组(普通数组)
console.log(arr2.flat(Infinity)); // [0, 1, 2, 3, 4, 5]
flatMap(callbackFn, [thisArg]):对数组中的每个元素应用给定的回调函数，然后将结果展开一级，返回一个新数组。它等价于在调用
map()方法后再调用深度为 1 的flat()方法（arr.map(...args).flat()），但比分别调用这两个方法稍微更高效一些。
const arr = [1, 2, 1];
const result = arr.flatMap((num) => (num === 2 ? [2, 2] : 1));
console.log(result); // [1, 2, 2, 1]排序
** 数组方法参数说明:**
[ ]:可选的参数。
compareFn:指定一个定义排序顺序的函数。如果省略，则将数组元素转换为字符串，然后根据每个字符的 Unicode 码位值进行排序。
sort([compareFn]):就地对数组的元素进行排序，并返回对相同数组的引用。默认排序是将元素转换为字符串，然后按照它们的UTF-16码元值升序排序。
// 默认排序
const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);// ["Dec", "Feb", "Jan", "March"]
const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);// [1, 100000, 21, 30, 4]
toSorted([compareFn]):sort()方法的复制方法版本。返回一个新数组，其元素按升序排列。
const months = ["Mar", "Jan", "Feb", "Dec"];
const sortedMonths = months.toSorted();
console.log(sortedMonths); // ['Dec', 'Feb', 'Jan', 'Mar']
console.log(months); // ['Mar', 'Jan', 'Feb', 'Dec']
const values = [1, 10, 21, 2];
const sortedValues = values.toSorted((a, b) => a - b);
console.log(sortedValues); // [1, 2, 10, 21]
console.log(values); // [1, 10, 21, 2]
reverse():就地反转数组中的元素，并返回同一数组的引用。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。改变原数组
const array1 = ['one', 'two', 'three'];
console.log('array1:', array1);// ["one", "two", "three"]
// 反转数组
const reversed = array1.reverse();
console.log('reversed:', reversed);// ["three", "two", "one"]
// 会修改原数组
console.log('array1:', array1);// ["three", "two", "one"]
toReversed():reverse()方法对应的复制版本。它返回一个元素顺序相反的新数组
const items = [1, 2, 3];
console.log(items); // [1, 2, 3]
// 反转数组,返回一个新数组
const reversedItems = items.toReversed();
console.log(reversedItems); // [3, 2, 1]
// 不会修改原数组
console.log(items); // [1, 2, 3]其他
数组方法参数说明:
[ ]:可选的参数。
separator:指定一个字符串来分隔数组的每个元素。
callbackFn:为数组中的每个元素执行的函数。
thisArg:执行callbackFn时用作this的值。
value:数组和/或值。
target:序列开始的目标位置，以 0 为起始的下标表示，且将被转换为整数。
start:元素序列的起始位置，以 0 为起始的下标表示，且将被转换为整数。
end:元素序列的结束位置，以 0 为起始的下标表示，且将被转换为整数。不包括end。
reduce(callbackFn, [initialValue]):对数组中的每个元素按序执行一个提供的reducer函数，每一次运行reducer会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。
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);// 10
reduceRight(callbackFn, [initialValue]):对累加器（accumulator）和数组的每个值（按从右到左的顺序）应用一个函数，并使其成为单个值。
const array1 = [
[0, 1],
[2, 3],
[4, 5],
];
const result = array1.reduceRight((accumulator, currentValue) =>
accumulator.concat(currentValue),
);
console.log(result);// [4, 5, 2, 3, 0, 1]
fill(value, [start], [end]):用一个固定值填充一个数组中从起始索引（默认为 0）到终止索引（默认为array.length）内的全部元素。它返回修改后的数组。
const array1 = [1, 2, 3, 4];
// 以 0 填充下标从 2 开始,到 4 结束的位置的元素,不包括下标为 4 的元素
console.log(array1.fill(0, 2, 4));// [1, 2, 0, 0]
// 以 5 填充下标从 1 开始的元素
console.log(array1.fill(5, 1));// [1, 5, 5, 5]
// 以 6 填充数组元素
console.log(array1.fill(6));// [6, 6, 6, 6]
slice([start], [end]):返回一个新的数组对象，这一对象是一个由 start 和 end 决定的原数组的浅拷贝。原始数组不会被改变。
const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
// 浅拷贝下标从 2 开始的数组元素
console.log(animals.slice(2));// ["camel", "duck", "elephant"]
// 浅拷贝下标从 2 开始,到 4 结束的数组元素,不包括下标为 4 的元素
console.log(animals.slice(2, 4));// ["camel", "duck"]
// 浅拷贝数组后两个元素
console.log(animals.slice(-2));// ["duck", "elephant"]
// 浅拷贝下标从 2 开始,到 array.length-1 结束的数组元素,不包括结束位置的元素
console.log(animals.slice(2, -1));// ["camel", "duck"]
// 浅拷贝整个数组
console.log(animals.slice());// ["ant", "bison", "camel", "duck", "elephant"]
concat([value]):用于合并两个或多个数组。不会更改现有数组，返回一个新数组。
const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);
// 拼接后的数组
console.log(array3);// ["a", "b", "c", "d", "e", "f"]
copyWithin(target, [start], [end]):浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。
const array1 = ['a', 'b', 'c', 'd', 'e'];
// 浅拷贝下标从 3 开始,到 4 结束的元素,不包括下标为 4 的元素,从下标为 0 的位置开始替换元素,替换元素数量为拷贝元素数量
console.log(array1.copyWithin(0, 3, 4));// ["d", "b", "c", "d", "e"]
// 浅拷贝标从 3 开始的元素,从下标为 1 的位置开始替换元素,替换元素数量为拷贝元素数量
console.log(array1.copyWithin(1, 3));// ["d", "d", "e", "d", "e"]非数组对象使用数组方法
arrayLike: 类数组对象，如string,object,map,NodeList,arguments,HTMLCollection等
方式：Array/[].prototype.数组实例方法.call(arrayLike, [mapFn / callbackFn], [thisArg])
在非数组对象上调用数组方法,同样会返回一个数组对象,不会改变原对象
示例：indexOf()
Array.prototype.indexOf.call();
const arrayLike = {
length: 3,
0: 2,
1: 3,
2: 4,
};
console.log(Array.prototype.indexOf.call(arrayLike, 2)); // 0示例：map()
const arrayLike = {
length: 3,
0: 2,
1: 3,
2: 4,
};
console.log(Array.prototype.map.call(arrayLike, (x) => x ** 2)); // [ 4, 9, 16 ]示例：some()
const arrayLike = {
length: 3,
0: "a",
1: "b",
2: "c",
};
//判断是否有元素是number类型
console.log(Array.prototype.some.call(arrayLike, (x) => typeof x === "number"));示例：find()
const arrayLike = {
length: 3,
0: 2,
1: 7.3,
2: 4,
};
// 7.3 找出不是整数类型的元素
console.log(Array.prototype.find.call(arrayLike, (x) => !Number.isInteger(x)));数组方法简单实现
实现findIndex()
//填充数组
let arr = Array(10).fill().map((item, index) => index + 1);
Array.prototype.myFindIndex = function (fn) {
for (let i = 0; i < this.length; i++) {
if (fn(this[i], i, this)) return i;
}
return -1;
}
console.log(arr.myFindIndex((item, index, array) => {
return item >= 9;
}));实现push()
let arr = Array(10).fill().map((item, index) => index + 1);
Array.prototype.myPush = function (...elements) {
let len = this.length;
for (let i = 0; i < elements.length; i++) {
this[len + i] = elements[i];
}
return this.length;
}
console.log(arr.myPush(11, 22, 33, 44, 55));实现unshift()
let arr = Array(10).fill().map((item, index) => index + 1);
Array.prototype.myUnshift = function (...elements) {
let len = this.length
for (let i = 0; i < len; i++) {
this[i + elements.length] = this[i];
}
for (let i = 0; i < elements.length; i++) {
this[i] = elements[i];
}
return this.length;
}
console.log(arr.myUnshift(11, 22, 33, 44, 55));实现pop()
Array.prototype.myPop = function () {
let last;
last = this[this.length - 1]
this.length -= 1;
return last;
}
let arr = [11, 22, 33]
//删除数组最后一个元素
console.log(arr.myPop()); // 33实现shift()
let arr = Array(10).fill().map((item, index) => index + 1);
Array.prototype.myShift = function () {
if (this.length === 0)return undefined;
let firstEl;
firstEl = this[0];
//将数组的后一个元素赋值给前一个元素,再删除最后一个多出的元素
for (let i = 0; i < this.length; i++) {
if (i > 0) this[i - 1] = this[i];
}
this.length -= 1;
return firstEl;
}
console.log(arr.myShift());实现every()
Array.prototype.myEvery = function (fn) {
let flag = true;
for (let i = 0; i < this.length; i++) {
if (!fn(this[i], i, this)) {
flag = false;
return flag;
}
}
return flag;
}
let arr = [11, 22, 33]
console.log(arr.myEvery(function (item, index, array) {
return item > 10
})); // true
console.log(arr.myEvery(function (item, index, array) {
return item > 11
})); // false更多详细数组用法请查阅 MDN
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
