数组的概念、基本属性方法 补充（深入）

 <script>
        //一、数组是一个特殊的对象
        //1、数组是按顺序排列的一组值(元素)每个位置都有编号从0开始,这个编号叫索引（下标）。数组的值可以是任意数据类型
        var arr1 = ['a', 'b', 'c', 3, { a: 1 }, [2, 2, 3]]
        //2.数组的索引可以理解是number类型的属性名，只能用[]取相应的值
        console.log(arr1[0]);//a
        //3.数组有length的属性，就是数组里面元素的数量
        console.log(arr1.length);
        //4.可以动态给数组添加值，根据索引添加或者修改元素
        arr1[0] = 'd'
        console.log(arr1);


        //二、in  运算符可以判断数组里面是否有该元素
        console.log(31 in arr1);//false


        //三、for...in可以遍历数组，一般不用for...in 因为开销比较大。
        for (var item in arr1) {
            console.log(arr1[item]);
        }


        //四、forEach(function(item){})可以遍历数组，一般数组用for循环或者forEach来遍历。forEach遍历不能使用break.
        arr1.forEach(function (item) {
            console.log(item);
        })


        //五、数组的控制，数组的元素是空
        //数组中空位返回的值是undefined,  length包含空位
        var arr2 = [1, , 2, 3]//4
        console.log(arr2);
        console.log(arr2.length);//4
        //delete删除数组的元素，位置会被保留，一般不用delete删除数组元素
        delete arr2[0]
        console.log(arr2);
        console.log(arr2.length);//4


        //六、类似数组对象，有下标和length属性的对象，长得像数组，但是不能按数字的方法去使用。真数组的length会随元素变化。
        var arrObj = {
            0: 'a',
            1: 'b',
            2: 'c',
            length: 3
        }
        console.log(arrObj);
        console.log(arrObj[0]);
        console.log(arrObj.length);
        //函数的arguments参数就是一个类数组对象
        function f1() {
            console.log(arguments);
            console.log(Array.isArray(arguments));//false  不是一个数组
        }
        f1(1, 2, 3)



        //七、Array是一个js原生对象（主要包含了处理数组的方法和属性），Array（）也是一个构造函数（可以构造一个数组出来）。
        var arr3 = new Array(3)//如果传递一个数字参数，则是创建数组并指定数组的长度
        var arr4 = new Array('a', 'b', 0)//如果床底的是非数字或者数字大于1，则是设置数组的元素
        console.log(arr4);


        //八、Array.isArray()判断是否是一个数组
        console.log(Array.isArray({}));//false  不是一个数组  返回false


        //九、创建的数组都会继承Array对象，可以使用很多数组内置的属性和方法
        //1、valueOf();返回数组本身
        console.log(arr3.valueOf());//[empty × 3]

        //2、toString();返回数组的字符串形式
        console.log(arr4.toString());//a,b,0

        //3、push()  在数组的末尾添加一个或者多个元素  返回新增后数组的长度
        arr3.push(1, 2, 3);//[empty × 3, 1, 2, 3]
        console.log(arr3);

        //4、pop（）;删除数组的最后一个元素，并返回该元素
        console.log(arr3.pop());//3

        //5.unshift()  在数组的头部插入一个或者多个元素  返回数组的长度
        arr4.unshift(1, 2)
        console.log(arr4);//[1, 2, "a", "b", 0]

        //6、shift()  删除头部元素，并返回该元素
        var item = arr4.shift();
        console.log(item);//1
        console.log(arr4);//[2, "a", "b", 0]
        console.log('---------------------------------------');

        //7、join()  把数组转为指定分隔符的字符串，返回一个字符串,原数组不变
        var arr5 = ['a', 'b', 'c', 'd']
        console.log(arr5.join(','));//a,b,c,d
        console.log(arr5.join(';'));//a;b;c;d
        console.log(arr5);

        //8.concat() , 可以合并多个数组，返回一个新的数组
        var arr6 = ['a', 'b']
        var arr7 = [1, 2]
        var newArr = arr6.concat(arr7, ['c', 'd'])//把arr7数组元素和['c','d']进行合并，返回一个新的数组
        console.log(newArr);
        //8.1 concat()可以接受其它类型的参数，把参数作为数组元素合并到数组里面，返回一个新的数组.push()可以接受其它类型的参数，是在原数组的基础上进行操作，影响原数组
        console.log(arr6.concat('aaaaa', { name: 'zs' }));

        //9、reverse() 可以倒序数组，改变原数组，返回值为改变后的数组
        var arr8 = ['a', 'b', 1, 2]
        console.log(arr8.reverse());//[ [2, 1, "b", "a"]]
        console.log(arr8);// [2, 1, "b", "a"]

        //10. slice(startIndex,endIndex)截取数组中的一部分，返回一个新的数组，原数组不变
        //startIndex指开始截取的索引，endIndex指的是结束索引（不包含该索引）（如果省略，则是截取到结尾）
        console.log(arr5.slice(1, 3));//['b','c']  原数组为['a','b','c','d']

        //11.splice(startIndex,count,element1,element2,...)删除原数组的一部分成员，还可以在删除的位置添加新的成员，返回值是被删除的元素,影响原数组
        var arr = [1, 2, 3, 4]
        /* 
        var res = arr.splice(1, 2)//从索引为1开始，删除2个元素，被删除元素会作为数组返回
        console.log(arr);//[1,4]
        console.log(res);//[2,3] 
        */
        /*
         var res = arr.splice(1, 2, 'a', 'b')//从索引1开始，删除2个元素，然后再从1索引开始插入'a' 'b'元素，相当于替换了2和3
        console.log(arr);// [1, "a", "b", 4]
        console.log(res);//[2,3] 
        */
        //可以用此方法在数组中插入元素
        arr.splice(1, 0, 'a', 'b')//在索引为1的地方不删除元素，插入'a''b'元素
        console.log(arr);//[1, "a", "b", 2, 3, 4]

        //12、map（function(item){return return item}）遍历数组的成员，把成员作为函数的参数，函数里面依次返回成员，最后返回一个新的数组，不会影响原数组。此方法可以用来修改数组成员，返回新数组。
        var arr9 = [1, 2, 3, 4]
        var newArr9 = arr9.map(function (item) {
            item += 'a'
            return item;
        })
        console.log(newArr9);//["1a", "2a", "3a", "4a"]
        console.log(arr9);//[1, 2, 3, 4]

        //13.filter(function(item){return true})用户过滤数组成员，满足条件的成员组成一个新的数组返回
        var arr10 = [1, 2, 3, 4, 5, 6, 7]
        var newArr10 = arr10.filter(function (item) {
            return item > 3;
        })
        console.log(newArr10);

        //14.reduce(function(a,b){return })依次处理数组的成员，最终累计为一个值。reduceRight()，和reduce一样的作用，reduce 是从左往右开始累计，reduceRight（）是从右往左开始累计。
        var count = arr10.reduce(function (a, b) {
            return a + b
        })
        console.log(count);

        //15.sort(function（a,b）{})数组排序。可以接受一个函数作为参数，a,b两个参数时数组相邻的两个元素，如果返回值大于0，则第一个成员在第二个成员的后面，其他元素不变。此方法会改变原数组，返回的是排序后的数组
        var small = arr10.sort(function (a, b) {
            return b - a;
        })
        console.log(small);//[7, 6, 5, 4, 3, 2, 1]
        //a-b是从小到大  b-a是从大到小
        var arr11 = [
            {
                name: 'ls',
                age: 18
            },
            {
                name: 'zs',
                age: 19
            },
            {
                name: 'wem',
                age: 20
            }

        ]
        var big = arr11.sort(function (a, b) {
            return b.age - a.age
        })
        console.log(big);

        //16.some(function(ele,index,arr){return })只要有一个成员返回true。整个some就返回true，否则返回false
        var arr11 = [1, 2, 3, 3, 4, 5, 6, 7]
        var flag = arr11.some(function (element) { return element > 3 })//查询数组里面是否有大于3的数字
        console.log(flag);//true

        //17.every(function(ele,index,arr){return })所有成员返回true，整个some返回true，否则返回false
        var ok = arr11.every(function (element) { return element > 3 })//查看数组里面是否每个数字都大于3
        console.log(ok);//false

        //18.indexOf(element)返回查询元素在数组中第一次出现的序列号，如果没有查询到，则返回-1
        //可以用该方法查询数组里面是否存在某个元素
        var position = arr11.indexOf(3);
        console.log(position);//2

        //19.lastIndexOf(element)返回查询元素最后一次出现的位置，从右往左找
        var lastPosition = arr11.lastIndexOf(3)
        console.log(lastPosition);//3


        //链式操作，如果方法返回的是数组，可以用链式操作
        //从小到大的顺序排列，每一个对象添加一个属性，筛选出年龄大于9的
        var arr12 = [{ name: "a1", age: 10 }, { name: "a2", age: 8 }, { name: "a3", age: 13 }, { name: "a4", age: 9 }]
        var newArr12 = arr12.sort(function (a, b) {
            return a.age - b.age
        })
            .map(function (item, index) {
                item.number = index;
                return item
            })
            .filter(function (item) {
                return item.age > 9
            })
        console.log(newArr12);



    </script>