数组es6方法总结

//--------------------------indexOf(n) lastIndexOf(n)
//参数：要查找的字符
//功能：跟字符串查找一样，查找指定元素是否存在，如果存在，返回索引值，如果不存在返回-1
//返回值：返回n在arr数组中的索引值
//是否改变原数组：没有

// var arr = [1,2,3,4,3];
// var a = arr.indexOf(3);
// console.log(a);//2
// console.log(arr);//[1, 2, 3, 4,3]

// var b = arr.indexOf(22);
// console.log(b);//-1
// console.log(arr);//[1, 2, 3, 4,3]

// var c = arr.lastIndexOf(3);
// console.log(c);//4
// console.log(arr);//[1, 2, 3, 4, 3]

//----2. 迭代方法----01.arr.forEach( )
// 迭代（遍历）

// 参数：回调函数
// 功能：遍历(回调函数内部的打印结果是数据区分map方法回调函数内部ruturn，外部打印该方法的返回值是一个数组)
// 返回值：undefined
// 是否改变原数组：没有
// 回调函数的返回值造成了什么影响：没有影响

//第一个参数(回调函数)：function(value, index, arr){};
// var arr = [1,2,3,4];
// var a = arr.forEach(function(value,index,arr){
//     console.log(value,index,arr);
//     return "hello"
// });
// console.log(a);
// 1 0 (4) [1, 2, 3, 4]
// 2 1 (4) [1, 2, 3, 4]
// 3 2 (4) [1, 2, 3, 4]
// 4 3 (4) [1, 2, 3, 4]
// undefined


// var arr = [20,13,11,8,0,11];
// var min = arr[0];
// arr.forEach(function(value,index,array){
//     //练习一
//     if(value%2)
//     console.log(value);// 13  11  11
//     //练习二
//     if(value<min){
//         min=value
//     }
    
// })
// console.log(min);//0

//-----------------------------02、arr.map( )
// 参数：回调函数
// 功能：遍历 可有运算之后的返回数组
// 返回值：数组，数组内是，每个回调函数的返回值
// 是否改变原数组：没有
// 回调函数的返回值造成了什么影响：被放在了map最终返回的数组内

// var arr = [1,2,3]
// var a = arr.map(function(value,index,array){
//     console.log(value,index,array);
//     //return "hello" // (3) ["hello", "hello", "hello"]
//     return value * 2//(3) [2, 4, 6]
//     //return value //(3) [1, 2, 3]
//     //return array//(3) [Array(3), Array(3), Array(3)]
// })
// console.log(a);
// 1 0 (3) [1, 2, 3]
// 2 1 (3) [1, 2, 3]
// 3 2 (3) [1, 2, 3]

//-----------------------------------03、arr.filter( )
// 参数：回调函数
// 功能：可以过滤值，并返回到一个新数组中
// 返回值：数组，数组内是满足某个筛选之后的值
// 是否改变原数组：没有
// 回调函数的返回值造成了什么影响：被放在了filter最终返回的数组内

// var arr = [1,2,3,4];
// var a = arr.filter(function(value,index,array){
// //     return value > 1//(3) [2, 3, 4] 返回值大于1的数组
//        return value%2//(2) [1, 3] 返回奇数数组

// })
// console.log(a);
// console.log(arr);//[1, 2, 3, 4]

//------------------------------04、arr.some( )
// 参数：回调函数
// 返回值：布尔值，只要有一个满足，就返回true
// 功能：遍历数组中是否有符合条件的值，只要有符合，那么就是true，同时停止遍历,
// 是否改变原来数组：否
// 回调函数的返回值造成了什么影响：true/false

// var arr = [1,2,3];
// var a = arr.some(function (value,index,array) {
//         //return 2;   //true
//         return value>2//true
// })
// console.log(a);
// console.log(arr);//(3) [1, 2, 3]

// var arr = [{q:1},{w:2},{e:3}];
// var x = 3;
// var i ;
// var a = arr.some(function(value,index){
//     i = index;
//     return value.e == x
// })
// console.log(a);
// console.log(i);//return是关于内容的比较式，则index会输出相应索引

//------------------------------------------05、arr.every( )
// 参数：回调函数
// 返回值：布尔值，所有条件都符合才返回true
// 功能： 遍历数组中是否有符合条件的值，必须全部符合，都是true，才是true，如果有一个false，那么就是false，同时停止遍历
// 是否改变原来数组：否

// var arr = [1,2,3,4];
// var a = arr.every(function (value,index,array) {
//     //return value<5;//true
//     return value<4//false
// })
// console.log(a);
// console.log(arr);//(4) [1, 2, 3, 4]

3、归并方法
//------------------------01、arr.reduce()
//------------------------02、reduceRight()
//reduce()回调函数有四个参数，
//第一个参数为：之前计算过的值，
//第二参数为：之前计算过的值的下一个值
//第三个参数：当前索引
//第四个参数为：当前数组对象
//功能：类似递归，可以求和之类的操作
//reduce()和reduceRight()类似，只是执行方向不同，
//reduce()从数组的开头往后递归
//reduceRight()从数组的末尾往前递归

// var arr = [13,2,3,4,11];
// var a = arr.reduce(function(prev,next,index,array){
//     console.log(prev+'-----'+next+'-----'+index+'-------'+array);
//     return prev+val
    
// })
// console.log(a);
//13-----2-----1---------13,2,3,4,11
//15（和）-----3-----2---------13,2,3,4,11
//18（和）-----4-----3---------13,2,3,4,11
//22（和）-----11-----4---------13,2,3,4,11
//33（和）

// var arr = [1,2,3,4]
// var a = arr.reduceRight(function(prev,next,index,array){
//     console.log(prev+'-----'+next+'-----'+index+'-------'+array);
//     //return prev + next
    
// })
// console.log(a);
//4-----3-----2-------1,2,3,4
//7（和）-----2-----1-------1,2,3,4
//9（和）-----1-----0-------1,2,3,4
//10（和）