JavaScript数组

数组

本文章是本人笔记，仅供参考。

数组是JavaScript中很常用的一个类型。JavaScript中的数组表示一组类型相同或者类型不同的数据。ECMAscript定义，数组的每个元素可以是任意类型的。

var arr = [123,'a',null,undefined,true];//数组里面的数据可以是任意类型的

一、数组的创建

1.new运算符

var arr1 = new Array(123,'a',null,undefined);//这里的括号里面用来放数组元素，用逗号隔开

但是如果你的括号里面只放了一个阿拉伯数字，那么，JavaScript将认为你是设定了数组的长度，而不是放了一个数组元素：

var arr2 = new Array(4);
console.log(arr2); // [empty × 4]

2.字面量方式
如果每次都使用new运算符的方式就太麻烦了，所以 有种更加常用的方法来创建一个数组：

//var arr = [];
var arr = [123, 'a', null, undefined, true];//你可以在数组里面添加任意类型的元素，用逗号隔开，即时你一个元素也不添加，也是可以的

二、数组的属性和下标

数组的length属性：代表数组的长度，通俗来说就是你的数组中游多少个数组元素（0-length）；
数组的下标：数组的下标是固定的，都是从零开始的，即第一个数组元素的下标是0，第二个是1；
通过数组的下标，我们可以很方便的取出或者添加数组元素，或者对数组进行一些其他操作。

var arr = [123, 'a', null, undefined, true];
console.log(arr[0]);//123

三、数组的方法

数组具有很多有用的方法，但是方法太多，很不方便记忆，但是如果能够归类一下，则会好记一些

栈方法
push() ：括号可以接收任意数量的参数，并把它们逐个添加到数组末尾，并返回修改后数组的长度
pop() ：从数组末尾移除最后一项，数组的length值减一，并返回移除的项
队列方法
unshift()：括号可以接收任意数量的参数，把它们逐个添加到数组前面，并返回修改后数组的长度
shift() ：从数组末尾移除前面一项，减少数组的length值，并返回移除的项
上面两类方法很类似，是比较好记的
重排序方法
reverse() ：反转数组项的顺序
sort() 方法按字母表升序排列数组项（但是它是按照字母表来进行排序的，如果要对数字进行排序，需要传入一个比较函数做参数即可实现，表格下面附上这个函数的相关代码段）
操作方法
concat（）：拼接数组
slice（begin，end）：截取数组项，不会改变原数组
splice（）：可对数组进行插入，删除，替换，会改变原数组，是数组中最强大的方法，拥有多个参数，在下面用代码进行演示
join（）：将数组转换成字符串，括号里面用来设定连接方式
位置方法
indexOf（）：从数组的开头开始查找数组项，找到返回索引位置，找不到返回-1
lastindexOf（）：从数组的尾部开始查找数组项，这两个方法都一样，查找的项必须严格相等
indexOf和lastindexOf一样，都可以传入两个参数，第一个参数为可选项，传入需要查询的项，第二个表示开始查询的起始位置
迭代方法
every（）：所有元素都通过函数的测试返回true
some():至少一个元素通过测试函数，返回true
filter():生成一个新数组，包含其通过测试函数的所有元素
forEach():对数组的每个元素执行一次给定的函数，该方法可以实现遍历数组
map():创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值
上面的迭代方法的第一个参数都是传入一个函数，而每个函数也可以选择传入三个参数，分别是：当前值（current），索引（index），数组对象（array）
归并方法
reduce（）：从数组第一项开始，遍历到最后，将值返回到第一项
reduceRight（）：从数组的最后一项开始遍历每一项

• sort（）：排序数组

        var arr = [1, 23, 34, 33, 56, 12, 23, 78, 56, 123, 231, 156]; //待排序数组
        //console.log(arr.sort()); //直接使用sort方法：[1, 12, 123, 156, 23, 23, 231, 33, 34, 56, 56, 78],很明显不是我们想要的结果

        //我们定义一个比较函数
        function compare(a, b) {
            if (a < b) { // 按某种排序标准进行比较, a 小于 b
                return -1;
            }
            if (a > b) { // a大于b
                return 1;
            }
            return 0; //a等于b
        }
        console.log(arr.sort(compare)); //[1, 12, 23, 23, 33, 34, 56, 56, 78, 123, 156, 231],这样就按照从下到大的顺序排好了

        //比较函数也可以写成这样
        function compare2(a, b) {
            return a - b;
        }

        //甚至直接用箭头函数写
        console.log(arr.sort((a, b) => {
            a - b
        }));//[1, 12, 23, 23, 33, 34, 56, 56, 78, 123, 156, 231],也能得到升序的效果
        //如果想要降序排序，只需要改变比较函数即可

• concat（）：连接数组

        var arr1 = [1, 2, 3];
        var arr2 = [4, 5, 6];
        console.log(arr1.concat(arr2)); //[1, 2, 3, 4, 5, 6]
        // concat()括号里面的参数可以是数组或多个数组，也可以是其他类型的数据，都会拼接成新数组
        console.log(arr1.concat(arr2, 7, 'a')); // [1, 2, 3, 4, 5, 6, 7, "a"]

• slice（）:截取数组

        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        console.log(arr.slice()); //[1, 2, 3, 4, 5, 6, 7, 8, 9]
        console.log(arr.slice(3)); //[4, 5, 6, 7, 8, 9],从第三个数开始，截取到最后
        console.log(arr.slice(3, 5)); //[4, 5],从第三个开始，截取到第五个，但是不含第五个，（含头不含尾）

• splice（）：对数组进行增，删，插入操作，算是数组最强大的方法，但是会改变原数组

		// var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // console.log(arr.splice()); //[]
        // console.log(arr.splice(1, 3)); //[2, 3, 4]，从第一个数开始，删除三个数字，返回被删除的数字，原数组发生改变


        // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // arr.splice(1, 0, 12)//在第一个数的位置开始，删除0个数，添加一个数12，允许插入多个数字
        // console.log(arr);//[1, 12, 2, 3, 4, 5, 6, 7, 8, 9]

        // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // arr.splice(2, 1, 23); //从第二位开始，删除一个 - '3'，再插入一个数字23；
        // console.log(arr); // [1, 2, 23, 4, 5, 6, 7, 8, 9]


        //splice()的参数允许传入负数
        // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // arr.splice(-2, 1); //从倒数第二位开始，删除一个数字 - '8'
        // console.log(arr);//[1, 2, 3, 4, 5, 6, 7, 9]


        // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // arr.splice(2);//从第二位开始，删除后面所有的数字
        // console.log(arr);//[1, 2]

• 迭代方法

	    //迭代方法 -- every():所有元素都通过函数的测试返回true
        // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // console.log(arr.every((value) => {
        //     return value > 10
        // })); //false  
        // console.log(arr.every((value) => {
        //     return value < 10
        // })); //true


        //迭代方法 -- some():至少一个元素通过测试函数，返回true
        // console.log(arr.some((value) => {
        //     return value > 10
        // })); //false
        // console.log(arr.some((value) => {
        //     return value < 10
        // })); //true


        //迭代方法 -- filter():生成一个新数组，包含其通过测试函数的所有元素
        // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // console.log(arr.filter((value) => {
        //     return value > 5
        // }));//[6, 7, 8, 9],输出所有值大于5的项


        //迭代方法 -- forEach():对数组的每个元素执行一次给定的函数
        // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // arr.forEach(element => {
        //     console.log(element)
        // })//遍历输出所有数组项元素--每个元素都执行了一次给定的函数

        //迭代方法 -- map():创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值
        // var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
        // console.log(arr.map((value) => {
        //     return value * 2
        // })); //产生一个新数组[2, 4, 6, 8, 10, 12, 14, 16, 18]
        // console.log(arr);//元素组未发生改变[1, 2, 3, 4, 5, 6, 7, 8, 9]

• reduce（）和reduceRight（）：这两个方法都允许接收两个参数，第一个参数为对每一项都会调用的函数（可选），第二项为归并的初始值，如果不设置，将默认为归并开始的第一项值；而传入的函数也允许接收四个参数，分别是：前一个值、当前值、项的索引和数组对象。

// reduce(function(prev,current,index,array){},initial);函数的参数也是可选的，根据需要添加，通常我们只需要前两项即可
        var arr = [1, 2, 4, 12, 12, 11, 5, 6, 7];
        var sum = arr.reduce(function(prev, curr) {
            return prev + curr;
        }, 0)//如果这里不设初始值，那么第一次归并的初始值就是第一项的值，也就是1
        console.log(sum);//60

数组相关方法，更多详情查阅这里：array方法