Array数据处理（一）

<script>
        // 数组
        // 创建数组
        // 方法一：Array 构造函数
        // var arr1 = new Array(); // 创建了一个空数组
        // var arr2 = new Array(20); // 创建了一个长度为20的数组
        // var arr3 = new Array("测试", "zhang", 0,null);
        // console.log(arr1); // []
        // console.log(arr2.length); // 数组长度 20
        // console.log(arr3); //["测试", "zhang", 0, null]

        // 方法二：数组字面量表示法
        // var arr4 = []; //创建一个空数组
        // var arr5 = [20]; // 创建一个包含1项的数组
        // let arr6 = ["测试", "zhang"]; // 创建一个包含2个字符串的数组

        // 数组取值，储存
        // let array = [10,20,30]
        // // 取值
        // console.log(array[0]); // 10
        // // 长度
        // console.log(array.length); // 3
        // // 存储
        // array[0]='储存'
        // console.log(array); // ["储存", 20, 30]

        // 创建 长度为7的数组
        let arr = [1, 3, 9, 8, '张', '哈', '略']
        // console.log(arr.length); // 7

        // 2 push 在数组尾部添加，返回添加后的数组元素的个数
        // console.log(arr.push('尾部')); // 8
        // console.log(arr); // [1, 3, 9, 8, "张", "哈", "略", "尾部"]

        // 3 unshift 在数组头部添加，返回数组添加后元素的个数
        // console.log(arr.unshift('头部')); // 8
        // console.log(arr); // ["头部", 1, 3, 9, 8, "张", "哈", "略"]

        // 4 shift 删除数组的第一个元素，返回被删除的元素
        // console.log(arr.shift()); // 返回删除第一个元素 1
        // console.log(arr); // [3, 9, 8, "张", "哈", "略"]

        // 5 pop 删除数组的最后一个元素，返回被删除的元素
        // console.log(arr.pop()); // 略
        // console.log(arr); // [1, 3, 9, 8, "张", "哈"]

        // 6 concat    a.concat(b,b2,..)  将两个数组或多个拼接在一起，返回一个拼接后的新数组，且a内部的元素在新数组的前部
        // let arr1 = [1,2]
        // let arr2 = [3,4]
        // let arr3 = [5,6]
        // console.log(arr1.concat(arr1,arr2,arr3));[1, 2, 1, 2, 3, 4, 5, 6]

        // 7 toString 将数组转换成字符串
        // console.log(arr.toString()); //1,3,9,8,张,哈,略

        // 8 join (&) 将数组以&符号间隔转换为字符串   返回一个字符串
        // console.log(arr.join('-')); //1-3-9-8-张-哈-略

        // 9 reverse()  反转   返回倒序排列后的新数组
        // console.log(arr.reverse()); //["略", "哈", "张", 8, 9, 3, 1]

        // 10 indexOf() 方法可返回数组中某个指定的元素位置 从0 -> arr.length -1 首次出现的位置
        // 不能判断是否有NaN的元素。
        // array.indexOf(item,start)
        // item 查找的元素 开始索引为0
        // start 从哪个位置上开始查找
        // console.log(arr.indexOf('张'));//存在返回该元素位置 4 不存在返回 -1

        // 11 lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找 最后出现的位置
        // 不能判断是否有NaN的元素。
        // array.lastIndexOf(item,start)
        // console.log(arr.lastIndexOf('张')); // 存在返回该元素位置 4 不存在返回 -1

        // 12 includes 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false
        // arr.includes(item,start)
        // 第二个参数可以是负数，表示从右数过来第几个，但是不改变判断搜索的方向，搜索方向还是从左到右
        // 如果fromIndex 大于等于数组长度 ，则返回 false 。该数组不会被搜索:
        // console.log(arr.includes(9)); //true
        // console.log(arr.includes(9,10)); //false


        // 13 判断是否是数组
        // 13.1
        // let arr1 =[]
        // console.log(Array.isArray(arr1)); //true
        // // 13.2
        // console.log(Object.prototype.toString.call(arr1).slice(8, -1)); // Array
        // // 13.3
        // console.log(arr1.length); // 判断数组长度 0

        // 14 扩展运算符 ...
        // console.log(...arr,'测试'); //1 3 9 8 "张" "哈" "略"
        // 合并数组
        // console.log([...arr,"测试",]); // [1, 3, 9, 8, "张", "哈", "略", "测试"]
        // 将字符串转换为数组
        // console.log([..."今天天气怎么样？"]); //["今", "天", "天", "气", "怎", "么", "样", "？"]

        // 15 split() 把一个字符串分割成字符串数组
        // string.split(a,b)
        // a：字符串或正则表达式 ，必填
        // b：返回该字符串最大长度 ，可选
        let str = "a:b:c:456:123"
        // console.log(str.split(":")); // ["a", "b", "c", "456", "123"]
        
        // 16 slice 返回从原数组中指定开始下标到结束下标之间的项组成的新数组 从1开始 截取数组生成新数组，原数组不受影响
        // console.log(arr.slice(0)); //[1, 3, 9, 8, "张", "哈", "略"] 
        // console.log(arr.slice(1, 4)); //[3, 9, 8]
        // console.log(arr.slice(1, -2)); //[3, 9, 8, "张"]
        // console.log(arr.slice(-4, -1)); //[8, "张", "哈"]
        // console.log(arr); //[1, 3, 9, 8, "张", "哈", "略"]

        // 17 splice 数组处理 新建数组，并且更改原来的
        // 17.1 splice 删除
        /* array.splice(index,n)
           index：数组中需要删除数据的起始位置
           n：需要删除的元素，数据的个数
        */
        // console.log(arr.splice(1,2)); //输出删除元素  [3, 9]
        // console.log(arr); // [1, 8, "张", "哈", "略"]

        // 17.2 splice 插入
        /* array.splice(index,0,data1,data2,....)
           index：数组中需要插入数据的起始位置
           0：删除的个数为0
           data1,data2：需要插入的元素，用逗号隔开
        */
        // console.log(arr.splice(1,0,'添加元素1','添加元素2')); // []
        // console.log(arr); //[1, "添加元素1", "添加元素2", 3, 9, 8, "张", "哈", "略"]

        // 17.3 splice 替换
        /* array.splice(index,n,data1,data2,......)
           index：需要替换的元素的起始位置
           n：需要替换的元素的个数，实质是删除
           data1，data2：需要插入元素，用逗号隔开
        */
        // console.log(arr.splice(1,1,'插入元素1'));// [3] 元素3 被删除
        // console.log(arr); //[1, "插入元素1", 9, 8, "张", "哈", "略"]

        // 18 sort() 排序 
        // 18.1 默认排序顺序是根据字符串UniCode码
        // console.log(arr.sort()); // [1, 3, 8, 9, "哈", "张", "略"]

        // 18.2  升序排序 降序排序 
        // let arr1 = ["55","6654","4454","33","66","8548","00"]
        // // 并不是我们想要的结果
        // console.log(arr1.sort()); // ["00", "33", "4454", "55", "66", "6654", "8548"]
        // // 升序排序
        // function sortOrder(a,b) {
        //     return a-b //b-a 降序排序 
        // }
        // console.log(arr1.sort(sortOrder)); //["00", "33", "55", "66", "4454", "6654", "8548"]

        // 18.3 按照数组对象中某个属性值排序
        // let arr1 = [{name:'zhang',age:10},{name:'li',age:20},{name:'wang',age:30}]
        // function sortOrder(arr) {
        //     return function(a,b) {
        //         let data1 = a[arr]
        //         let data2 = b[arr]
        //         return data2 - data1 // age 降序排序
        //     }
        // }
        // console.log(arr1.sort(sortOrder('age')));// [{name:'wang',age:30},{name:'li',age:20},{name:'zhang',age:10}]

        // 18.4 根据参数来确定是升序还是降序
        // let arr1 = [{name:'zhang',age:10},{name:'li',age:20},{name:'li',age:20},{name:'wang',age:30}]
        // function sortOrder(arr,rev) {
        //     // 第二个参数没有传递，默认升序排列
        //     if (rev == undefined) {
        //         rev = 1
        //     }else{
        //         rev = rev ? 1 : -1 //-1 降序 
        //     }
        //     return function (a,b) {
        //         a=a[arr]
        //         b=b[arr]
        //         if (a<b) {
        //             return rev * -1
        //         }
        //         if (a>b) {
        //             return rev * 1
        //         }
        //         return 0 
        //     }
        // }
        // console.log(arr1.sort(sortOrder('age'))); //默认升序
        // console.log(arr1.sort(sortOrder('age',true))); //true 升序
        // console.log(arr1.sort(sortOrder('age',false))); //false 降序

        // 比较函数应该具有两个参数 a 和 b，其返回值如下：
        // 若 a 小于 b，即 a - b 小于零，则返回一个小于零的值，数组将按照升序排列
        // 若 a 等于 b，则返回 0
        // 若 a 大于 b, 即 a - b 大于零，则返回一个大于零的值，数组将按照降序排列
    </script>