<script>
// concat(): 连接多个数组，并返回新的数组。
var arr1 = [ 1, 2, 3 ];
var arr2 = [ 4, 5, 6 ];
var newArr = arr1.concat( arr2 ); // 使用concat方法将两个数组连接起来
console.log( newArr ); // [1, 2, 3, 4, 5, 6]
// copyWithin(): 将一个数组内的元素从指定位置开始复制，然后将它们粘贴到数组内的另一个位置，覆盖原有元素，并返回该数组。
var arr = [ 1, 2, 3, 4, 5 ];
arr.copyWithin( 0, 3, 4 ); // 将数组中索引为3的元素（也就是数字4）复制到索引为0的位置，覆盖原来的元素
console.log( arr ); // [4, 2, 3, 4, 5]，现在数组的首位元素是4
// entries(): 返回一个包含数组中每个元素键值对的可迭代对象。
var arr = [ 'a', 'b', 'c' ];
var iterator = arr.entries();
console.log( iterator.next().value ); // [0, 'a']，数组的第一个元素（索引为0）的键值对
console.log( iterator.next().value ); // [1, 'b']，数组的第二个元素（索引为1）的键值对
console.log( iterator.next().value ); // [2, 'c']，数组的第三个元素（索引为2）的键值对
// every(): 测试数组的每个元素是否都能通过指定函数的测试，并返回布尔值。
var arr = [ 1, 2, 3 ];
var isAllEven = arr.every( ( num ) => num % 2 === 0 ); // 检查数组中的每个元素是否都是偶数
console.log( isAllEven ); // false，因为数组中有奇数（1和3）
// fill(): 将一个数组中的所有元素替换为指定的值，并返回该数组。
var arr = [ 1, 2, 3, 4, 5 ];
arr.fill( 0, 2, 4 ); // 从索引为2的位置开始，将后面的所有元素都填充为0
console.log( arr ); // [1, 2, 0, 0, 5]，现在数组中索引为2和3的位置都填充了0
// filter(): 创建一个新数组，其中包含所有通过指定函数的测试的元素。
var arr = [ 1, 2, 3, 4, 5 ];
var evenNums = arr.filter( ( num ) => num % 2 === 0 ); // 从数组中筛选出所有的偶数，创建一个新的数组
console.log( evenNums ); // [2, 4]，只有2和4是偶数
// find(): 返回数组中通过指定函数的测试的第一个元素的值。如果没有元素通过测试，则返回undefined。
var arr = [ 1, 2, 3, 4, 5 ];
var evenNum = arr.find( ( num ) => num % 2 === 0 ); // 从数组中找到第一个偶数（索引为1的元素2）
console.log( evenNum ); // 2，输出第一个偶数
// findIndex(): 返回数组中通过指定函数的测试的第一个元素的索引。如果没有元素通过测试，则返回-1。
var arr = [ 1, 2, 3, 4, 5 ];
var evenIndex = arr.findIndex( ( num ) => num % 2 === 0 ); // 从数组中找到第一个偶数的索引（索引为1的元素2）
console.log( evenIndex ); // 1，输出第一个偶数的索引
// flat(): 将一个嵌套多层数组转换为一个单层数组，并返回该数组。
var arr = [ 1, [ 2, [ 3, [ 4 ] ], 5 ] ];
var flattenedArr = arr.flat( Infinity );
console.log( flattenedArr ); // [1, 2, 3, 4, 5]
// flatMap(): 对数组内的每个元素运行指定函数，并使用生成的值和现有元素创建新数组。最后，将所有数组连接在一起并返回。
var arr = [ 1, 2, 3 ];
var doubledEvenNums = arr.flatMap( ( num ) =>
{
if ( num % 2 === 0 )
{
return [ num, num * 2 ]; // 这是正确的，但注释解释不正确
} else
{
return []; // 这是正确的，但注释解释不正确
}
} );
console.log( doubledEvenNums ); // [2, 4]? 这个注释不正确，输出应该是 [2, 4, 6]
// forEach(): 遍历数组的每个元素，并执行指定函数。
var arr = [ 1, 2, 3 ];
arr.forEach( ( num ) =>
{
console.log( num );
} );
// 1
// 2
// 3
// 这个注释是正确的。
// includes(): 判断数组是否包含指定的元素，并返回布尔值。
var arr = [ 1, 2, 3 ];
var isIncluded = arr.includes( 2 );
console.log( isIncluded ); // true
// 这个注释是正确的。
// indexOf(): 返回指定元素在数组中第一次出现的位置。如果没有找到该元素，则返回-1。
var arr = [ 1, 2, 3 ];
var index = arr.indexOf( 2 );
console.log( index ); // 1
// 这个注释是正确的。
// isArray(): 判断指定值是否为数组，并返回布尔值。
var arr = [ 1, 2, 3 ];
console.log( Array.isArray( arr ) ); // true
// 这个注释是正确的。
// join(): 将数组中的所有元素转换为一个字符串，并使用指定分隔符将它们连接在一起。
var arr = [ 'a', 'b', 'c' ];
var str = arr.join( '-' );
console.log( str ); // 'a-b-c'
// 这个注释是正确的。
// keys(): 返回一个数组迭代器，包含数组中的每个索引。
var arr = [ 'a', 'b', 'c' ];
var iterator = arr.keys();
console.log( iterator.next().value ); // 0 // 这个注释是正确的。
console.log( iterator.next().value ); // 1 // 这个注释是正确的。
console.log( iterator.next().value ); // 2 // 这个注释是正确的。
// lastIndexOf(): 返回指定元素在数组中最后一次出现的位置。如果没有找到该元素，则返回-1。
var arr = [ 1, 2, 3, 2 ];
var lastIndex = arr.lastIndexOf( 2 );
console.log( lastIndex ); // 4，而不是3，因为2在数组的最后一个位置。
// map(): 遍历数组的每个元素，并使用指定函数生成新的值。最后，将所有生成的值组成一个新的数组并返回。
var arr = [ 1, 2, 3 ];
var doubledArr = arr.map( ( num ) => num * 2 );
console.log( doubledArr ); // [2, 4, 6]，正确。
// pop(): 移除数组中的最后一个元素，并返回该元素。
var arr = [ 1, 2, 3 ];
var poppedNum = arr.pop();
console.log( arr ); // [1, 2]，正确。注意，pop()操作后，原数组arr的内容已经改变。
console.log( poppedNum ); // 3，正确。
// push(): 向数组末尾添加一个或多个元素，并返回新的长度。
var arr = [ 1, 2, 3 ];
var newLength = arr.push( 4, 5 );
console.log( arr ); // [1, 2, 3, 4, 5]，正确。注意，push()操作后，原数组arr的内容已经改变。
console.log( newLength ); // 5，正确。
// reduce(): 将数组的所有元素累加到一个值中，并返回该值。
// 注意：reduce()的回调函数中的参数名是正确的，第一个参数是累加器(accumulator)，第二个参数是当前值(value)。
var arr = [ 1, 2, 3 ];
var sum = arr.reduce( ( accum, value ) => accum + value, 0 );
console.log( sum ); // 6，正确。
// reduceRight(): 将数组的所有元素（从右到左）累加到一个值中，并返回该值。这个函数在JavaScript数组中并不存在，你可能想使用reduce()函数，然后通过reverse()函数来达到从右到左累加的效果。
// 注意：reduce()函数默认就是从左到右累加的，如果需要进行从右到左的累加，可以先使用reverse()函数将数组反转，然后再进行累加。
var arr = [ 1, 2, 3 ];
var reversedArr = [ ...arr ].reverse(); // 使用扩展运算符创建新数组并反转元素顺序
var sum = reversedArr.reduce( ( accum, value ) => accum + value, 0 );
console.log( sum ); // 6，正确。
// reverse(): 反转数组中元素的顺序。这个注释是正确的。
var arr = [ 1, 2, 3 ];
arr.reverse();
console.log( arr ); // [3, 2, 1]，正确。注意，reverse()操作后，原数组arr的内容已经改变。
// shift(): 移除数组中的第一个元素，并返回该元素。这个注释是正确的。
var arr = [ 1, 2, 3 ];
var shiftedNum = arr.shift();
console.log( arr ); // [2, 3]，正确。注意，shift()操作后，原数组arr的内容已经改变。
console.log( shiftedNum ); // 1，正确。
// slice(): 返回一个由指定开始和结束索引之间的元素组成的新数组。
var arr = [ 1, 2, 3, 4, 5 ];
var slicedArr = arr.slice( 1, 3 );
console.log( slicedArr ); // [2, 3]
// some(): 测试数组的某些元素是否能通过指定函数的测试，并返回布尔值。
var arr = [ 1, 2, 3 ];
var hasEvenNum = arr.some( ( num ) => num % 2 === 0 );
console.log( hasEvenNum ); // true
// sort(): 对数组进行排序。
var arr = [ 5, 1, 4, 2, 3 ];
arr.sort();
console.log( arr ); // [1, 2, 3, 4, 5]
// splice(): 在指定位置添加或移除元素，并返回被移除元素的数组。
var arr = [ 1, 2, 3, 4, 5 ];
var removedNums = arr.splice( 1, 2, 'a', 'b' );
console.log( arr ); // [1, 'a', 'b', 4, 5]
console.log( removedNums ); // [2, 3]
// toLocaleString(): 将数组中所有元素转换为字符串，并根据指定语言环境中的规则展示。
var arr = [ 12345678.9, 'apple' ];
var str = arr.toLocaleString(); // 注意，这里没有指定语言环境和选项，所以结果可能根据您的浏览器和系统而有所不同
console.log( str ); // 一个逗号分隔的字符串，形式如'12,345,678.90 apple'，但具体的表现形式会因浏览器和系统而异
// toString(): 将数组中所有元素转换为一个字符串，使用逗号作为分隔符。
var arr = [ 'a', 'b', 'c' ];
var str = arr.toString();
console.log( str ); // 'a,b,c'
// toSource(): 返回一个表示当前数组源代码的字符串，该字符串可以用来创建一个新数组。
var arr = [ 'a', 'b', 'c' ];
var source;
// 使用for循环遍历数组
for ( var i = 0; i < arr.length; i++ )
{
// 将每个元素转换为字符串并添加引号
var element = arr[ i ].toString().replace( /'/g, "\\'" );
// 将元素添加到source变量中
source += '"' + element + '", ';
}
// 去除末尾多余的逗号和空格
source = source.slice( 0, -2 );
console.log( source ); // ['a', 'b', 'c'].toString()，结果同上，也是 'a,b,c'
// valueOf(): 返回数组本身。
var arr = [ 1, 2, 3 ];
var value = arr.valueOf();
console.log( value ); // [1, 2, 3]
// unshift(): 向数组的开头添加一个或多个元素，并返回新的长度。
var arr = [ 1, 2, 3 ];
var newLength = arr.unshift( 0, -1 );
console.log( arr ); // [0, -1, 1, 2, 3]
console.log( newLength ); // 5
// values(): 返回一个包含数组中所有元素值的可迭代对象。
var arr = [ 'a', 'b', 'c' ];
for ( let value of arr.values() )
{
console.log( value ); // 'a', 'b', 'c'
}
// at(): 返回指定索引位置的元素。支持负数索引和取多个元素。
var arr = [ 'a', 'b', 'c', 'd' ];
var element = arr.at( 1 );
console.log( element ); // 'b'
var elements = arr.at( -3, -1 );
console.log( elements ); // ['c', 'd']
// findLast(): 返回数组中最后一个通过指定测试的元素。
var arr = [ 1, 2, 3, 4, 5 ];
var lastEvenNum = arr.findLast( ( num ) => num % 2 === 0 );
console.log( lastEvenNum ); // 4
// flatMapDeep(): 与flatMap()类似，但会递归扁平化嵌套数组，最终返回一个单层的数组。
function flatMapDeep ( arr, fn )
{
let flattened = [].concat( ...arr );
return flattened.flatMap( fn );
}
var arr = [ 1, [ 2, [ 3, [ 4 ] ], 5 ] ];
var flattenedArr = flatMapDeep( arr, ( num ) =>
{
if ( num % 2 === 0 )
{
return [ num, num * 2 ];
} else
{
return [];
}
} );
console.log( flattenedArr );// [2, 4, 6, 8, 5]
// flatMapDepth(): 与flatMap()类似，但可以指定扁平化嵌套数组的深度。
var arr = [ 1, [ 2, [ 3, [ 4 ] ], 5 ] ];
function flatMapDepth ( array, fn, depth = 1 )
{
if ( depth === 1 )
{
return array.flatMap( fn );
} else
{
return array.flatMap( arr =>
{
if ( Array.isArray( arr ) )
{
return flatMapDepth( arr, fn, depth - 1 );
} else
{
return arr;
}
} );
}
}
var flattenedArr = flatMapDepth( arr, ( num ) =>
{
if ( num % 2 === 0 )
{
return [ num, num * 2 ];
} else
{
return [];
}
} );
console.log( flattenedArr ); // [2, 4, 3, [4], 5]
// from(): 将类似数组或迭代器对象转换为数组。
var arr1 = Array.from( 'hello' );
console.log( arr1 ); // ['h', 'e', 'l', 'l', 'o']
var arr2 = Array.from( { length: 5 }, ( _, index ) => index + 1 );
console.log( arr2 ); // [0, 1, 2, 3, 4] (原来的索引从0开始，所以这里应该是[0, 1, 2, 3, 4])
// of(): 创建一个新的数组，包含任意数量的参数。
var arr = Array.of( 1, 'a', true );
console.log( arr ); // [1, 'a', true]
</script>
扫一扫
148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
