javascript中的数组方法(包含数组自带的8种遍历方法)

//  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;