JavaScript中的数组常用方法

1. join(arg) 作用将数组变成字符串，只有一个参数为字符串连接符（可选，默认为 , ）,返回值为一个字符串

        var arr = [1,2,3,4]
        console.log(arr.join()); //1,2,3,4
        console.log(arr.join('-')); //1-2-3-4

2. reverse() 作用翻转数组，无参数，返回值为翻转后的数组，会改变原数组。

        var arr2= [1,2,3,4]
        console.log(arr2.reverse()); //[4, 3, 2, 1]

3. push(arg) 作用从后面添加成员（一个或多个），参数是要插入的成员，返回值为新的数组长度。

        var arr3 = [1,2,3,4]
        console.log(arr3.push(6,3)); //6
        console.log(arr3); // [1, 2, 3, 4, 6, 3]

4. unshift(arg) 作用从前面添加成员（一个或多个），参数是要插入的成员，返回值为新的数组长度

        var arr4 = [2,3,6]
        console.log(arr4.unshift(9,8)); //5
        console.log(arr4); // [9, 8, 2, 3, 6]

5. pop() 作用删除数组的最后一个元素，无参数，返回值为最后一个成员。
6. shift 作用删除数组的第一个元素，无参数，返回值为第一个成员。

        var arr5 = [1,2,3,4,5,6]
        console.log(arr5.pop()); //6
        console.log(arr5); //[1, 2, 3, 4, 5]
        console.log(arr5.shift()); //1
        console.log(arr5); //[2, 3, 4, 5]
        //返回值都为自己删除的那个

7. Array.isArray(arr) 作用是检测目标是否为数组 ，参数是要检测的对象，是数组返回true，否则返回false。

        var arr6 = []
        var str = ''
        console.log(Array.isArray(arr6)) //true
        console.log(Array.isArray(str)) //false

8. includes(arg) 作用是检测数组是否包含某个成员，参数为要检测的成员，包含则返回true，否则返回false。

        var arr7 = [1,2,3,4,'www']
        console.log(arr7.includes(2)) //true
        console.log(arr7.includes('www')) //true

9. every(fn) 作用是用于检测数组所有元素是否都符合指定条件，参数fn是个函数，函数接收三个参数，第一当前成员（item 必须），第二当前成员的下标（index 可选），第三当前成员所属数组（arr 可选），所有成员都符合条件返回true，否则返回false。

        var arr8 = [1,2,3,4]
        console.log(arr8.every(function (item,index,arr){
            return item > 0
        })); //true
        console.log(arr8.every(function (item,index,arr){
            return item > 3
        })); //false

10. some(fn) 作用是用于检测数组是否有元素符合指定条件，参数fn是个函数，函数接收三个参数，第一当前成员（item 必须），第二当前成员的下标（index 可选），第三当前成员所属数组（arr 可选），只要有一个成员符合条件就返回true，否则返回false。

        var arr9 = [1,2,3,4]
        console.log(arr9.some(function (item,index,arr){
            return item > 3
        })); //true
        console.log(arr9.some(function (item,index,arr){
            return item > 6
        })); //false

11. indexOf(arg) 作用从左边开始检测成员在数组的下标（lastIndexOf(arg)是从右边开始检测），参数是需要检测的成员，有则返回第一个符合条件的成员下标，没有则返回-1。 注：indexOf()只适用数组成员为基本类型的数组

        var arr10 = [1,2,1,3,4]
        console.log(arr10.indexOf(1)); //0
        console.log(arr10.lastIndexOf(1));  //2
        console.log(arr10.indexOf(6)); //-1

12. findIndex(fn) 作用是在数组查找符合条件的成员的下标，参数fn是个函数，函数接收三个参数，第一当前成员（item 必须），第二当前成员的下标（index 可选），第三当前成员所属数组（arr 可选），有则返回第一个符合条件的成员的下标，没有则返回-1。 注： findIndex(fn)适用任何数组

        var arr11 = [1,2,3,4]
        console.log(arr11.findIndex(function (item){
            return item >2
        })); // 下标 2

13. find(fn) 作用是在数组中查找符合条件的成员，参数fn是个函数，函数接收三个参数，第一当前成员（item 必须），第二当前成员的下标（index 可选），第三当前成员所属数组（arr 可选），有则返回第一个符合条件的成员，没有则返回-undefined。

        var arr12 = [1,2,3,4]
        console.log(arr12.find(function (item){
            return item >2
        })); // 成员 3

14. slice(arg1,arg2) 作用是截取数组，第一个参数是截取开始的数组下标（包含），第二个参数是截取结束的数组下标（不包含），返回值是一个新数组，不会改变原数组。

        var arr13 = [1,2,3,4,5,6]
        console.log(arr13.slice(2,-1)); //[3, 4, 5]
        console.log(arr13); //[1, 2, 3, 4, 5, 6]

15. splice(index,num,item) 作用是删除（任意位置）或替换数组成员，第一个参数是开始删除的下标（index），第二个参数是删除成员的个数（num），第三个参数是用以替换的新成员（item 可选），返回值为由被删除的元素组成的数组，该方法会改变原数组。

        var arr14 = [1,2,3,4,5,6]
        console.log(arr14.splice(0,3,9,9,9)); //[1, 2, 3]
        console.log(arr14); //[9, 9, 9, 4, 5, 6]

16. map(fn) 作用是按照原始元素顺序依次处理元素，参数fn是个函数，函数接收三个参数，第一当前成员（item 必须），第二当前成员的下标（index 可选），第三当前成员所属数组（arr 可选），返回值为一个被fn函数处理过的新数组，不会改变原数组。

        //map() 改头换面
        var arr15 = [{ name: 'www', num: 10 }, { name: 'ssss', num: 22 }, { name: 'rrr', num: 33 }]
        var newArr15 = arr15.map(function (item) {
            return {
                userName: item.name,
                value: item.num
            }
        })
        console.log(arr15); //不变
        console.log(newArr15);
        /*
            {userName: 'www', value: 10}
            {userName: 'ssss', value: 22}
            {userName: 'rrr', value: 33}
        */

17. filter(fn) 作用是返回符合条件的数组，参数fn是个函数，函数接收三个参数，第一当前成员（item 必须），第二当前成员的下标（index 可选），第三当前成员所属数组（arr 可选），返回值是一个被fn函数处理过的新数组，不会改变原数组。

        var arr15 = [1,2,3,4,5]
        console.log(arr15.filter(function(item){
            return item > 2
        }))//[3, 4, 5]

18. forEach(fn) 作用是遍历数组，参数fn是个函数，函数接收三个参数，第一当前成员（item 必须），第二当前成员的下标（index 可选），第三当前成员所属数组（arr 可选），无返回值

        var arr16 = [1,2,3]
        arr16.forEach(function (item,index){
            console.log(item,index);
            /*
                1 0
                2 1
                3 2
            */
        })

19. sort(fn) 作用对数值成员进行排序，

• 第一种情况字符串数组，无参数，返回值为按升序排列的数组，会改变原数组（若要降序，翻转数组即可）。
• 第二种情况数字数组，参数是fn函数，fn接收两个参数，升序排列只需function(a,b){return a-b}，降序排列只需function(a,b){return b-a}。
• 第三种情况对象数组，参数是fn函数，接收两个参数a,b。升序排列只需 if a[属性名] > b[属性名] return 1;if a[属性名] < b[属性名] return -1;if a[属性名] === b[属性名] return 0;。降序只需改return 后面的数值。

// 第一种情况字符串数组(升序)
        var strArr = ['wqe','saf','cxz','lkj']
        console.log(strArr.sort()); //['cxz', 'lkj', 'saf', 'wqe']
        //  第二种情况数字数组(降序)
        var numArr = [2,1,4,1,3,5]
        console.log(numArr.sort(function(a,b){
            return a-b
        })); //[1, 1, 2, 3, 4, 5]
        // 第三种情况对象数组
        var objArr = [{id:2,name:'fsw'},{id:3,name:'wsw'},{id:1,name:'qrw'},{id:1,name:'q11w'}]
        objArr.sort(function(a,b){
            // 按id升序
            if(a['id'] > b['id']){
                return 1;
            }else if(a['id'] < b['id']){
                return -1;
            }else if(a['id'] === b['id']){
                return 0;
            }
        })
        console.log(objArr);
        /*
            {id: 1, name: 'qrw'}
            {id: 1, name: 'q11w'}
            {id: 2, name: 'fsw'}
            {id: 3, name: 'wsw'}
        */

20. reduce(fn,initValue) 作用是获取数组累加总和，第一个参数为函数，函数有4个参数，第一是数组总和（必须），第二是当前成员（必须），第三是当前成员下标（可选），第四是当前成员所在数组（可选）。第二个参数为initValue（累加初始值，默认值为0）

        var arr20 = [1,2,4,6]
        var sum =  arr20.reduce(function(sum,item,index,arr){
            // console.log(sum);
            // console.log(item);
            // console.log(index);
            // console.log(arr);
            return {num:sum['num'] + item} 
            //sum第一次的值为初始值（{num:0}），后面sum的值就为返回值
        },{num:0})
        console.log(sum) //{num: 13}