javascript里数组的各方法解析

	**1. push() 可以接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度。**
    // var arr = [1, 2, 3]
    // var arr1 = arr.push(2) //原数组改变，返回值是改变后的数组长度，从后面加
    // console.log(arr, arr1) //[1, 2, 3, 2] 4

    **2.pop() 从数组末尾移除最后一项，减少数组的length值，然后返回移除的项。**
    // var arr = [1, 2, 3]
    // var arr1 = arr.pop() //**原数组改变，返回值是被删除的数，从后面删除**
    // console.log(arr, arr1) //[1, 2] 3

     **3.unshift()可以接收任意数量的参数，把它们逐个添加到数组前面，并返回修改后数组的长度**
    // var arr = [1, 2, 3]
    var arr1 = arr.unshift(4) //**原数组改变，返回值是改变后的数组长度，从头部加**
    // console.log(arr, arr1) //[4, 1, 2, 3] 4

    **4.shift() 从数组末尾移除前面一项，减少数组的length值，然后返回移除的项。**
    // var arr = [1, 2, 3]
    // var arr1 = arr.shift() //**原数组改变，返回值是被删除的数，从头部删除**
    // console.log(arr, arr1) //[2, 3]  1

    **5.reverse() 方法会反转数组项的顺序。**
    // var arr = [1, 2, 3]
    // var arr1 = arr.reverse() //**原数组改变，返回值是改变后的数组**
    // console.log(arr, arr1) //[3, 2, 1] [3, 2, 1]

    **6.sort() 方法按字母表升序排列数组项，只能排0到9，如果要排两位数及以上，要把比较函数作为参数。如果按其他方式而非字母表顺序进行数组排列，必须给sort方法传递一个比较函数做参数。**
    //10以内的数组
    // var arr = [1, 5, 7, 4, 2, 1, 9]
    // var arr1 = arr.sort() //**原数组改变，返回值就是改变后的数组**
    // console.log(arr, arr1) //[1, 1, 2, 4, 5, 7, 9]  [1, 1, 2, 4, 5, 7, 9] 
    //10以内倒叙
    // var arr = [1, 5, 7, 4, 2, 1, 9]
    // var arr1 = arr.sort(function(i, j) {
    //         return j - i //默认是i - j ，结果就是由小到大
    //     }) //**原数组改变，返回值就是改变后的数组**
    // console.log(arr, arr1) //[9, 7, 5, 4, 2, 1, 1]  [9, 7, 5, 4, 2, 1, 1]  
    //10以外的数和其他字符排序
    // var arr = [5, 5, 4, 11, 24, 14, 6]
    // var arr1 = arr.sort(function(i, j) { //可以将比较函数在外面写好，这里写函数名就行，不要加小括号
    //         if (i < j) {
    //             return -1;
    //         } else if (i > j) {
    //             return 1;
    //         } else {
    //             return 0;
    //         }
    //     }) //**原数组改变，返回值就是改变后的数组**
    // console.log(arr, arr1) //[4, 5, 5, 6, 11, 14, 24] [4, 5, 5, 6, 11, 14, 24]

    **7.concat() 方可以基于当前数组中的所有项创建一个新数组，参数可以是数组项或者数组。**
    // var arr = [1, 2, 32]
    // var arr2 = [6, 8, 9]
    // var arr1 = arr.concat(5, 6) //**返回值是拼接后的数组，原数组不变**
    // console.log(arr, arr1) //[1, 2, 32] [1, 2, 32, 5, 6]
    // var arr3 = arr.concat(arr2)
    // console.log(arr, arr3) // [1, 2, 32]  [1, 2, 32, 6, 8, 9]

    // 8.slice() 方法它能够基于当前数组中的一或多个项创建一个新数组。可以接受一或两个参数，即要返回项的起始和结束位置，不包括结束位置。
    // var arr = [1, 2, 3, 4, 5, 6]
    // var arr1 = arr.slice(1) //原数组不变，返回值是被截取的数值组成的数组
    // console.log(arr, arr1) //[1, 2, 3, 4, 5, 6]  [2, 3, 4, 5, 6] 
    // var arr1 = arr.slice(1, 3) //含头不含尾
    // console.log(arr, arr1) //[1, 2, 3, 4, 5, 6]  [2, 3]
    // var arr1 = arr.slice(-3) //负数从后往前数
    // console.log(arr, arr1) //[1, 2, 3, 4, 5, 6]  [4, 5, 6]
    // var arr1 = arr.slice(-3, -6) //开头的索引大于结束的索引，不截取
    // console.log(arr, arr1) // [1, 2, 3, 4, 5, 6] []

    //9. splice() 方法对数组进行删除、插入、替换，是最强大的数组方法，返回值是数组，改变原数组。
    //var arr = [1, 2, 3, 4, 5, 6]
    // var arr1 = arr.splice(1, 2) //原数组改变，返回值是被截取的数值组成的数组
    // console.log(arr, arr1) //[1, 4, 5, 6]  [2, 3]
    // var arr1 = arr.splice(1, 0, 9, 9, 9) //原数组增加数值，不截取数值，所以返回值为空
    // console.log(arr, arr1) //[1, 9, 9, 9, 2, 3, 4, 5, 6] []
    // var arr1 = arr.splice(-3, 2) //负数从后往前数
    // console.log(arr, arr1) //[1, 2, 3, 6] (2) [4, 5]
    // var arr1 = arr.splice(2, 0, [6, 6, 6]) //不截取且增加数组
    // console.log(arr, arr1) // [1, 2, Array(3), 3, 4, 5, 6] []

    //10. join()方法，将数组转换成对应的字符串。参数就是连接符。
    // var str = "123456"
    // console.log(str.split()) //["123456"]
    // console.log(str.split("")) //["1", "2", "3", "4", "5", "6"]
    // console.log(str.split(",")) //["123456"]

    // var arr = [1, 2, 3, 4, 5, 6]
    // console.log(arr.join()) //1,2,3,4,5,6
    // console.log(arr.join("")) //123456
    // console.log(arr.join(",")) //1,2,3,4,5,6
    // console.log(arr.join("*")) //1*2*3*4*5*6

    //es5新增方法：位置方法
    //11. indexOf() 方法从数组的开头开始向后查找。
    // var arr = ["a", "b", "f", "s", "f", "y"]
    // console.log(arr.indexOf("f")) //2,从头开始找，只会找第一个出现的字符索引
    //12.lastIndexOf() 方法则从数组的末尾开始向前查找。
    // var arr = ["a", "b", "f", "s", "f", "y"]
    // console.log(arr.lastIndexOf("f")) //4,从后往前找，只会找第一个出现的字符索引

    // es5新增方法：迭代方法
    //13. every()
    // 对数组中的每一项运行给定函数，如果该函数对每一项都返回 true ，则返回 true 。
    // var arr = [3, 4, 5, 6, 7, 8, 9]
    // var res = arr.every(function(value, index, array) {
    //     console.log(value, index); //3 0  4 1  5 2  6 3
    //     return value < 6; //满足值小于6则进行迭代，一旦不满足，迭代结束，且输出false，只有全部符合才是true
    // })
    // console.log(res) //false
    
    // 14.some()
    // 对数组中的每一项运行给定函数，如果该函数对任意一项返回 true ，则返回 true 。
    // var arr = [3, 4, 5, 6, 7, 8, 9]
    // var res = arr.some(function(value, index, array) {
    //     console.log(value, index); //3 0  4 1  5 2  6 3  7 4
    //     return value > 6; //满足值大于6则进行迭代查找，一旦满足，迭代结束，且输出true，只有全部不符合才是false
    // })
    // console.log(res) //true

    // 15.filter()
    // 对数组中的每一项运行给定函数，返回该函数结果为 true 的项组成的数组。
    // var arr = [3, 4, 5, 6, 7, 8, 9]
    // var res = arr.filter(function(value, index, array) {
    //     console.log(value, index); //3 0  4 1  5 2  6 3  7 4  8 5  9 6 全部遍历一遍
    //     return value < 6; //满足值小于6的值通过作为返回值输出数组，其他不满足的不输出
    // })
    // console.log(res) //[3, 4, 5]

    //16. map()
    // 对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。如果是判断大小就是返回true和false，如果是输出数值就按数组形式输出
    // 返回就是数组，不考虑true或者false；
    // var arr = [3, 4, 5, 6, 7, 8, 9]
    // var res = arr.map(function(value, index, array) {
    //     console.log(value, index); //3 0  4 1  5 2  6 3  7 4  8 5  9 6 全部遍历一遍
    //     return value < 6; //满足值小于6的值输出true，不满足输出false
    // })
    // console.log(res) //[true, true, true, false, false, false, false]
    // var arr = [3, 4, 5, 6, 7, 8, 9]
    // var res = arr.map(function(value, index, array) {
    //     console.log(value, index); //3 0  4 1  5 2  6 3  7 4  8 5  9 6 全部遍历一遍
    //     return value * 2; //返回值是将value的值*2并且用数组输出
    // })
    // console.log(res) //[6, 8, 10, 12, 14, 16, 18]

    // 17.forEach() ：对数组中的每一项运行给定函数。这个方法没有返回值。
    // var arr = [3, 4, 5, 6, 7, 8, 9]
    // var res = arr.forEach(function(value, index, array) {
    //     console.log(value, index); //3 0  4 1  5 2  6 3  7 4  8 5  9 6 全部遍历一遍
    //     return value < 6; //没有返回值
    // })
    // console.log(res) //undefined

    // es5新增方法：归并方法
    // 18.reduce() 方法从数组的第一项开始，逐个遍历到最后。
    // var arr = [1, 2, 3, 4, 5, 6]
    // var result = arr.reduce(function(res, curr, index, array) { //参数代表 数组第一个数  curr表示第二个数 index为索引 array是数组，如果reduce传第二个参数，那个这个参数就是res的值。curr就是数组第一个数的值
    //     console.log(res, curr, index)
    //     return res + curr //就是res = res + curr 然后这个res作为下一个归并res的值

    // }) //因为没有传入第二个参数，其实很不好看，res为1，curr为2
    // console.log(result) //21，是数组的值和
    // var arr = [1, 2, 3, 4, 5, 6]
    // var result = arr.reduce(function(res, curr, index, array) { //参数代表 数组第一个数  curr表示第二个数 index为索引 array是数组，如果reduce传第二个参数，那个这个参数就是res的值。curr就是数组第一个数的值
    //         console.log(res, curr, index)
    //         return res + curr //就是res = res + curr 然后这个res作为下一个归并res的值
    //     }, 0) //因为传入第二个参数，所以res一开始为0，curr为1
    // console.log(result) //21，是数组的值和

    //19. reduceRight() 方法从数组的最后一项开始，向前遍历到第一项。
    // var arr = [1, 2, 3, 4, 5, 6]
    // var result = arr.reduceRight(function(res, curr, index, array) { //参数代表 数组第一个数  curr表示第二个数 index为索引 array是数组，如果reduce传第二个参数，那个这个参数就是res的值。curr就是数组第一个数的值
    //         console.log(res, curr, index)
    //         return res + curr //就是res = res + curr 然后这个res作为下一个归并res的值

    //     }, 0) //因为有传入第二个参数，所以res一开始为0，curr为6
    // console.log(result) //21，是数组的值和

//20.Array.from() 方法用于将对象转为真正的数组(类数组转数组)
//对象转数组的话，需要将属性名改成有序的数字且增加length属性，值为原有的对象属性个数
// let obj = {
// name: ‘zhangsan’,
// age: 100,
// sex: ‘男’
// };

// //经典面试题
// let obj1 = {
//     0: 'zhangsan',
//     1: 100,
//     2: '男',
//     length: 3
// }

// console.log(Array.from(obj)); //[]  obj对象无对应的索引下标，无法转换
// console.log(Array.from(obj1)); //["zhangsan", 100, "男"]

//类数组转数组  可以直接转换
// let aLi = document.querySelectorAll('li');  获取的是li标签类数组
// aLi = Array.from(aLi); //转换
// aLi.push(document.body); //如果不转换成数组的话，是无法添加的，只有转换成数组才行
// console.log(aLi);//[li, li, li, li, li, body]

//21.Array.of() 方法用于将一组值， 转换为数组。
// console.log(Array.of(1, 2, 3)); //[1, 2, 3]
// console.log(Array.of(1)); //[1]
// console.log(Array.of('a', 'b', 'c'));//["a", "b", "c"]

//22. fill() 方法使用给定值， 填充一个数组。
// let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// console.log(arr.fill('hello')); //["hello", "hello", "hello", "hello", "hello", "hello", "hello", "hello", "hello", "hello"]
// console.log(arr.fill('hello', 3, 5)); //替换区间   参2：开始的索引   参3：结束的索引，不包括。

总结：
会改变原数组的方法
push 返回值是改变后数组的长度
pop 返回值是删除的数
unshift 返回值是改变后数组的长度
shift 返回值是删除的数
reverse 返回值是改变后的数组
sort 返回值是排序后的数组
splice 返回值是截取的数组成的数组
fill 返回值是修改后的数组

个人见解，如有遗漏，雨我无瓜QAQ