概述
// push(参数列表)：向数组末尾追加新内容，返回增加后数组长度（原数组改变，返回数组长度）,参数之间使用逗号隔开，数组中的每一项可以说是任意数据类型，会改变原数组结构
let ary= [1,2,3];
ary.push(4); // => 返回长度4，原数组改变为[1,2,3,4]
ary.push(5,6); // => 返回长度6，原数组改变为[1,2,3,4,5,6]
// unshift（参数列表）：向数组开头追加新内容（原数组改变，返回数组长度）,参数之间使用逗号隔开，数组中的每一项可以说是任意数据类型，会改变原数组结构
let ary1 = [1,2,3];
ary1.unshift(4); // => 返回长度4，原数组改变为[4,1,2,3]
ary1.unshift(5,6); // => 返回长度6，原数组改变为[5,6,1,2,3,4]
// pop:删除数组最后一项，无参数，原数组改变（原数组改变，返回删除项）
// shift：删除数组第一项（原数组改变，返回删除项）
let ary2 = [1,2,3];
ary2.pop(); // => 返回3，原数组改变为[1,2]
ary2.shift(); // => 返回1，原数组改变为[2]
// splice(n,m,x):可以用来做数组增删改的方法，表示从数组的n下标项开始，删除m个项，将x放进删除位置
// splice，可以用来做数组的增删改：（原数组改变，返回删除项集合数组，无删除返回空数组）
// splice(n,m);从索引n开始删除m个，m不写则删除到末尾，返回一个保存删除内容的数组
// 原有数组会改变，参数为0时会清空数组，无参数则一项都不删除，返回一个空数组
// splice(n,m,x):在原有删除的基础上用x代替删除内容（替换）
// splice(n,0,x):n所有开始，删除0项，再在n索引前位添加上x
let ary3 = [1,2,3,4,5];
ary3.splice(1,1); // => 返回[2],原数组改变为[1,3,4,5]
ary3.splice(1,0,8); // => 返回空数组，原数组改变为[1,8,2,3,4,5]
ary3.splice(1,1,8); // => 返回[1],原数组改变为[1,8,3,4,5]
// slice(n,m);返回索引n到索引m处的项(新数组)，包括n不包括m,原数组不变（原数组不变，返回新数组）
// 只有一个参数，则从参数索引返回到末尾，无参与参数0一样，返回原数组克隆体(与原数组地址不同)
// 支持负数索引，负数索引代表倒数
let ary4 = [1,2,3,4];
ary4.slice(1,3); // => 返回[2,3]，原数组不变
ary4.slice(-3,-1) // => 返回[2,3],原数组不变（4-3=1,4-1=3，转化为ary4.slice(1,3)）
ary4.slice() // => 返回[1,2,3,4],原数组不变，返回的新数组是原数组的克隆体，非原数组
//数组1.concat(数组2，数组3,数据值等等)：将多个数组拼接在一起，无参返回原数组克隆体(与原数组地址不同)：[1,2,3]
let ary5 = [1,2],ary6=[3,4];
ary5.concat(ary6); // => 返回[1,2,3,4],原数组不变
ary5.concat(ary6, 5); // => 返回[1,2,3,4,5],原数组不变
// toString：将数组转化为字符串(转换后的字符串是以逗号隔开的)，返回转换后的字符串，原有数组不变
// join(分隔符):将数组以指定分隔符转化为字符串，与字符串split想对应，原有数组不变，不传参数默认用,拼接，空字符串则以单项拼接 （原数组不变，返回连接后的新字符串）
// 小技巧：数组纯数字，使用join('+')变为字符串再使用eval()将字符串转换为js表达式执行就可以求数组中数的和了
let ary7 = [1,2,3];
ary7.toString(); // => 返回“1,2,3”，原数组不变
ary7.join('+'); // => 返回"1+2+3"，原数组不变
// reverse：将数组中的每一项倒过来排列，无参，返回排序后的数组，原数组会发生改变
let ary8 = [1,2,3];
ary8.reverse() // => 返回[3,2,1]，原数组改变
/*
sort：数组排序，无参(无参只能排序相同位数的数字，全是三位数或者全是四位数这样的，因为不传参数是按照unicode码来排序的)
或者回调函数作参，原数组会改变，
sort(function(a,b){
return a-b;//升序
return b-a；//降序
})
*/
let ary9 = [2,12,333,49];
ary9.sort(); //返回[12,2,333,49](unicode码排序)，原数组会改变
ary9.sort((a,b)=>a-b); //返回[2,12,49,333]升序
ary9.sort((a,b)=>b-a); //返回[333,49,12,2]降序 _
// indexOf(参数)：获取参数项在数组中的第一次出现位置的索引，没有返回-1。IE6-8不支持
// lastIndexOf(参数):获取参数项在数组的最后一次出现位置索引，没有返回-1。IE6-8不支持
let ary10 = [1,2,3,4];
ary10.indexOf(2); //返回1，2的首次出现位置
ary10.lastIndexOf(5); //返回-1
// 数组遍历方法都不会改变原数组
// 数组遍历方法之forEach
// 语法：数组名.forEach(function(value,index,ary){}):数组中的每一项都要执行function函数，value是当前遍历对象的值，index是索引，ary是我们遍历的原数组对象，就是将数组传进来用ary变量接受，forEach如果除了传第一个回调函数外还传了第二个参数的话，那么第二个参数就会是第一个回调函数中的this
let ary11 = [1,2,3];
ary11.forEach((item,index)=>{console.log(item,index)}) // 打印1，0，2，1，3，2
// map（映射----更新）
// 数组名.map(function(value,index){return xxx}):数组中的每一项都要执行function函数，value是当前遍历对象的值，index是索引，不同于forEach的是，map会返回一个新数组，每一次遍历后的return返回值都会添加进新数组中，最后返回新数组
let ary12 = [1,2,3];
ary12.map((item,index)=>{return item+''+index}) // 返回[10,21,32]
/*
filter（过滤----删除）
ary.filter(function(item,index){ // 使用数组的filter方法进行过滤，参数是一个回调函数，第一个参数是遍历的当前项第二个参数是遍历的当前项的索引
return item>20; // filter会返回一个新数组，遍历当前项时return的是true就把当前项放进新数组中，return的是false就不放，所以其实return后面
//跟着的就是过滤条件，遍历数组判断是否符合过滤条件，是就放进新数组不是就不放
})
*/
let ary13 = [1,2,3];
ary13.filter(item=>item===2) //返回[2]
// 数组名.includes(参数)：遍历数组判断，每一项是否等于参数项，等于返回true不再执行（ES6）
let ary14 = [1,2,3];
ary14.includes(2); //返回true
ary14.includes(5); //返回false
// 数组名.find(回调函数，与forEach，map的回调函数类似)，return后面是true就返回当前项，接着就不会再往后进行遍历了，找完没找到就返回undefined
let ary15 = [1,2,3];
console.log(ary15.find(item=>{
return item===2; // 返回2
return item===3; // 返回3
return item===5; // 返回undefined
}));
/*
数组名.every(参数)：遍历数组判断，用于检测数组所有元素是否都符合指定条件,返回布尔值
如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
如果所有元素都满足条件，则返回 true。
注意： every() 不会对空数组进行检测。
*/
let ary16 = [1,2,3];
ary16.every(item=>{
return item < 2; // 整个表达式返回fasle
return item < 4; // 整个表达式返回true
})
// 数组名.some(回调函数，与forEach，map的回调函数类似)，return后面是false就返回当前项，接着就不会再往后进行遍历了，找完没找到就返回undefined（ES6）
let ary17=[1,2,3];
ary17.some(item=>{
return item>2; // 返回1
return item<2; // 返回2
})
/*
reduce遍历方法：
第一次遍历时第一个参数是第一项的值，第二个个参数是第二项的值，第三个参数是第二个参数项的索引，第四个参数是原数组
第二次遍历时第一个参数是第一次遍历的返回值，第二个参数是第三项的值，第三个参数是第二个参数项的索引，第四个是原数组
由此可得：reduce遍历第一次传入头两项和第二项索引加原数组，第二次传如第一次返回值和第三项以及第三项的索引和原数组
数组求和：ary.reduce(function(a,b){return a+b})
如果第一个参数回调函数后面还有第二个参数，那么第二个参数会被当做第一次遍历的第一个参数来使用，这样就避免了第一次传入两项，后面每一次传入一项的情况了
*/
let ary18=[1,2,3,4,5];
ary18.reduce((item1,item2,index2,ary)=>{
// 第一次遍历：1，2，1，[1,2,3,4,5]
// 第二次遍历：第一次返回值，3，2，[1,2,3,4,5]
// 第三次遍历：第二次返回值，4，2，[1,2,3,4,5]
// ......
})
ary18.reduce((item1,item2,index2,ary)=>{
// 第一次遍历：10，1，0，[1,2,3,4,5]
// 第二次遍历：第一次返回值，2，1，[1,2,3,4,5]
// 第三次遍历：第二次返回值, 3，2，[1,2,3,4,5]
// ......
},10)
// 如求数组中数的和：
let ary19 = [1,2,3,4,5];
let a=ary19.reduce((run,item,index)=>{
return run+item;
},0);
// a => 15;
最后
以上就是畅快摩托为你收集整理的javascript中的数组方法(包含数组自带的8种遍历方法)的全部内容，希望文章能够帮你解决javascript中的数组方法(包含数组自带的8种遍历方法)所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复