添加链接
link之家
链接快照平台
  • 输入网页链接,自动生成快照
  • 标签化管理网页链接

作用: 返回一个新数组,新数组中的元素为原数组中的元素调用回调函数处理后的值,不会改变原始数组
代码:

    let oldArr = [1,2,3];
	let newArr = oldArr.map((value,key,arr)=>{
		console.log("我是value:"+value);
		console.log("我是key:"+key);	
		console.log("我是原数组: "+ arr)
		return value * 2;
	console.log(oldArr);
	console.log(newArr);

结果:
在这里插入图片描述
参数:array.map(回调函数( value,index,arr ))

  • value:当前元素值
  • index:当前元素下标
  • arr:当前元素数组
    遍历 原数组中的元素,调用回调函数,将回调函数返回值添加到新数组中,不会改变原始数组

2.filter()

filter() 可以看成过滤函数,返回符合条件的元素的数组
作用:根据条件筛选原数组中符合条件的元素,添加到一个新数组中返回。不会修改原始数组

    let oldArr = [2,4,6,8,10];
	let newArr = oldArr.filter((v,i,arr)=>{
		console.log("我是当前数组的value:"+v);
		console.log("我是当前数组key:"+i);	
		console.log("我是原数组: "+ arr)
		return v > 5;
	console.log(oldArr);
	console.log(newArr);

在这里插入图片描述
参数:array.filter(回调函数( currentValue,index,arr ))

  • value - 当前元素值
  • index - 当前元素下标
  • arr - 当前数组

返回值:返回包含符合条件的元素的数组;没有符合条件的元素,则返回 空数组。

2.1 filter的应用

filter去掉空字符串、undefined、null

let arr = ['','1','2',undefined,'img',undefined,null] let newArr = arr.filter(item => item) console.log(newArr);//["1", "2", "img"]

filter去重

let arr=[1,1,2,3,3,4,4,5,6,6,7] let newArr = arr.filter((v,i,arr)=> arr.indexOf(v)=== i console.log(newArr); // [1, 2, 3, 4, 5, 6, 7] 去重推荐使用set let arr=[1,1,2,3,3,4,4,5,6,6,7] let newArr =Array.from(new Set(arr)) console.log(newArr) // [1, 2, 3, 4, 5, 6, 7]

3.flat()

作用: 数组的成员有时还有数组,Array.prototype.flat()用于将嵌套的数组“拉平”,变成一维数组。该方法返回一个新数组,对原数据没有影响。

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

上述代码中,原始数组中成员中有一个数组,flat()方法将子数组的成员取出来,添加在原来的位置。
flat()默认只会“拉平”一层,如果想要“拉平”多层的嵌套数组,可以将flat()方法的参数写成一个整数,表示想要拉平的层数,默认为1。

flat的应用

let arr = [1, 2, [3, 4, [5, 6]]];
// 默认只能 拉平 1层
arr.flat(); 
 [1, 2, 3, 4, [5, 6]]
// 参数为2 表示要拉平 2 层 嵌套数组
arr.flat(2); 
[1, 2, 3, 4, 5, 6]
// 也可以连续调用
arr.flat().flat(); 
 [1, 2, 3, 4, 5, 6]
// 如果不管有多少嵌套层,都要转成一维数组的话,可以用Infinity关键字作为参数
arr.flat(Infinity)
 [1, 2, 3, 4, 5, 6]

4.reduce()

reduce()函数接收一个回调函数(必须)和指定的初始值(非必须)作为参数。函数中的参数,分别为 初始值,当前项,当前数组,进行累加或者累积操作,初始值为每次累加或者累计后的结果

语法:array.reduce(callback, [initialValue])
reduce()方法接收callback函数,
function callback(preValue, curValue, index, array)

  • preValue: 必需,初始值(initialValue)或者计算结束后的返回值
  • curValue: 必需,当前元素
  • index: 可选,当前元素在数组中的索引值
  • array: 可选,当前元素所属的数组对象
  • initialValue:可选,传递给函数的初始值( 第一次调用callback函数时的preValue)

4.1 reduce的应用

let arr = [1,2,3,4,5];
const sum = arr.reduce((prev,cur,index,ary)=> prev + cur,10)
console.log(sum); //25
let arr = [1,2,3,4,5];
const sum = arr.reduce((prev,cur,index,ary)=> prev + cur)
console.log(sum); //15
let arr = [1, 2, 3, 4, 5]
  const fact=arr.reduce((prev, cur, index, ary) => {
  return prev * cur
})	console.log(fact); //120

展平数组(二维数组变为一维数组)

let arr = [[0,1], [2, 4, 6], [7, 8, 9]];
	const flat = arr.reduce((prev,cur)=>{
		return [...prev,...cur]
	console.log(flat)
let arr = [1, 2, 1, 2, 3, 0, 4, 5, 3, 1,1,1];
	let result = arr.sort().reduce((init, current) => {
    	if (init.length === 0 || init[init.length - 1] !== current) {
        	init.push(current);
    	return init;
	}, []);
	console.log(result); //[0,1,2,3,4,5]

计算数组中每个元素出现的次数

let letters = ['A', 'A', 'B', 'C', 'A'];
	const countletters= letters.reduce((allLetters, letter) => {
  		if (letter in allLetters) {
    		allLetters[letter] ++;
  		else {
    		allLetters[letter] = 1;
  		return allLetters;
		}, {});
console.log(countletters) //{A: 3, B: 1, C: 1}
const arraySum = (arr, val) => arr.reduce((acc, cur) => {
    return cur == val ? acc + 1 : acc + 0
}, 0);
let arr = [ 0, 1, 1,4,2, 0, 1, 3 ]
console.log(arraySum(arr, 1)) // 数组arr中 1 元素出现的次数为3
本质上就是能 “批量” 创建相同类型的变量(在Java,数组包含的变量必须是相同类型)。
数组的定义:
数据类型[] 数组变量名 = new 数据类型[整数];  //整数:数组的长度
数据类型[] 数组变量名 = {值1,值2,值3…值n};  //(静态初始化)
数据类型[] 数组变量名 = new 数据类型[]{值1,值2,值3…值n};  //(动态初始化)
数组(引用类型):
数组的下标不要越界使用,否则会报错(编译阶段不报错,运行报异常)
二维数组的定义:
数据类型[][] 数组变量名
                                    方法的参数是一个遍历函数,该函数可以接受三个参数,分别是当前数组成员、当前数组成员的位置(从零开始)、原数组。该方法返回一个新数组,不改变原数组。用于将嵌套的数组“拉平”,变成一维的数组。上面代码,遍历函数返回的是一个双层的数组,但是默认只能展开一层,因此。默认只会“拉平”一层,如果想要“拉平”多层的嵌套数组,可以将。方法的参数写成一个整数,表示想要拉平的层数,默认为1。方法将子数组的成员取出来,添加在原来的位置。的参数为2,表示要“拉平”两层的嵌套数组。上面代码,原数组的成员里面有一个数组,
                                    数组的reduce方法,接收一个函数(必须)和指定的初始值(非必须)作为参数,函数有三个参数,分别为初始值,当前项,当前数组,进行累加或者累积操作,初始值为每次累加或者累计后的结果 注意:在ie9一下的浏览器,并不支持该方法 ! 语法:arr.reduce(fn(pre,cur,arr){},[initialValue]) 一些妙用: 统计每个字符出现的次数
//方法1:
    var o...
let arr = [1,2,3,null,4,5]
let filterArray = arr.filter((item)=>{
return item != null //去掉数组的nu’l’l
filter()还可以用来去重
var r,
 ary = ['apple', 'strawberry', 'banana', 'pear', 'apple', 'orange', 'orange', 'strawberry'];
                                    map():
map和forEach等遍历方法不同,在forEachreturn语句是没有任何效果的,而map则可以改变当前循环的值,返回一个新的被改变过值之后的数组(map需return),一般用来处理需要修改某一个数组的值。
let arr1 = [1,2,3];
let arr2 = arr1.map((value,key,arr) => {
    console.l...