数组笔记

（一）数组的创建

 Let arr=[]
 Let arr = new Array()
    两种区别：
       用new关键字，需要单独开辟一个存储地址，比较耗资源，耗内存
       字面量的方式直接在内存开辟一个存储字段，相对比较简单，也不耗资源
        new Array()有缺点，就是参数问题引起的重载
    优点：
        1.按照索引查询元素速度快 
        2、能存储大量数据 
        3、按照索引遍历数组方便
        4、不用定义大小，可以随意的存储值，，也可以为空，且访问很方便，比较灵活
        5、 任何类型的数据，都可以放入到数组里

    缺点：   
        1、根据内容查找元素速度慢 
        2、数组的大小一经确定不能改变。 【修改后返回的数组其实是单独开辟的空间，原始数组并未被改变】
        3、数组只能存储一种类型的数据 
        4、增加、删除元素效率慢 
        5、未封装任何方法，所有操作都需要用户自己定义。
        6、安全性能太低，后期可以随意改变数组的值

（二）数组自带属性
    Constructor.  //返回创建数组对象的原型函数
    Length //返回数组对象的长度
    关于数组的length属性：    
       1.该属性不是只读属性，该属性可读可写，可以通过这个属性，向数组的末尾添加和删除元素
       2.如果将length的属性设置为大于数组长度的值，且没有赋值，那么新增的每一项都是undefined 
        Prototype. //可以增加数组的原型方法和属性     

（三）检测是否为数组
    Instanceof  用于判断一个变量是否是某个对象的实例
    Var arr = [1,2,3]    
    arr   instanceof Arrar.   //true
    isArray() 用于判断一个变量是否是数组
    let arr = [1,2,3,4,5,2]
    Array.isArray(arr). //true
（四）数组的方法
    1 arr.push() 从后面添加元素，返回值为添加完后的数组的长度
        let arr = [1,2,3,4,5]. arr.push(5) // [1,2,3,4,5,5]

    2 arr.pop() 从数组的后面删除元素，返回值是删除的元素
        let arr = [1,2,3,4,5]. arr.pop()  //返回5 Arr = [1,2,3,4]

    3 arr.shift() 从前面删除元素，只能删除一个 返回值是删除的元素
        let arr = [1,2,3,4,5]. arr.shift() // 返回1 Arr = [2,3,4,5]

    4 arr.unshift() 从前面添加元素, 返回值是添加完后的数组的长度
        let arr = [1,2,3,4,5] arr.unshift(2). //返回长度 6 Arr = [2,1,2,3,4,5]

    5 arr.splice(i,n) 删除从i(索引值)开始的那个元素，返回值是删除的元素 【注：此方法会对原数组进行修改】
        参数： i 开始位置的索引值      n 个数
        let arr = [1,2,3,4,5] arr.splice(2,2) //返回[3,4] Arr = [1,2,5]

    6 arr.concat() 连接两个数组 返回值为连接后的新数组，原始数组不被修改
        let arr = [1,2,3,4,5] arr1=arr.concat([6,7]))  //返回[1,2,3,4,5,6,7] Arr=[1,2,3,4,5] arr1=[1,2,3,4,5,6,7]

    7 str.split() 将字符串转化为数组
        let str = ‘123456' str.split('') //返回["1", "2", "3", "4", "5", "6"]

    8 arr.sort() 将数组进行排序,返回值是排好的数组，默认是按照最左边的数字进行排序，不是按照数字大小排序的，见例子。
        let arr = [2,10,6,1,4,22,3]                     console.log(arr.sort())   // [1, 10, 2, 22, 3, 4, 6]
        let arr1 = arr.sort((a, b) =>a - b)                 console.log(arr1)   // [1, 2, 3, 4, 6, 10, 22]
        let arr2 = arr.sort((a, b) =>b-a)   console.log(arr2)  // [22, 10, 6, 4, 3, 2, 1]

    9 arr.reverse() 将数组反转,返回值是反转后的数组
        let arr = [1,2,3,4,5] arr.reverse()//返回[5,4,3,2,1] Arr =[5,4,3,2,1]

    10 arr.slice(start,end)    用来切割数组，返回值是切出来的数组，但是并不影响原数组
        注意：1.传递一个参数的时候，是从参数位置截取到数组的末尾
             2.传递两个参数的时候，是从起始位置，截取到结束位置，但是不包含结束位置
        let arr = [1,2,3,4,5]
            console.log(arr.slice(4)) //返回[5] Arr =[1,2,3,4]
            console.log(arr.slice(2,2))   // [3,4]  Arr =[1,2,5]
            console.log(arr)    //  [1,2,3,4,5]

    11 arr.splice()    
        let arr = [1,2,3,4,5] arr.splice(2,2) //返回[3,4] Arr = [1,2,5]
         注意：1.传递一个参数的时候，是从参数位置截取到数组的末尾，返回的是删除项
              2.传递两个参数的时候，是从起始位置，截取到结束位置，包含结束位置
              3.传递三个参数，看中间的数组是否是0，如果是则是在起始位置添加数值，如果中间是正整数，则是在起始位置之后用第三个参数的值，来替换相对应长度的数据
        let arr = [1,2,3,4,5]
            console.log(arr.splice(2)) //返回[3,4,5] Arr =[1,2]
            console.log(arr.splice(1,3)) //返回[2,3,4] Arr =[1,5]
            console.log(arr.splice(1,2,6))//返回[2, 3] Arr =[1, 6, 4, 5]

（五）数组与字符串的相互转化
        数组转字符串
            let arr = [1,2,3,4,5]
            1.arr.join(). //“1,2,3,4,5"
            2.arr.toString(). //"1,2,3,4,5"
            3.arr.toLocaleString(). //“1,2,3,4,5”
            如果数组中的某一项是null | undefined 那么该返回值在字符串中以空字符串展示 

        字符串转数组
            let str = "abc,abcd,aaa";
            Let arr = str.split(‘,'). //[abc,abcd,aaa]
            let str1 = "helloworld";
            Let arr = str1.split(‘'). //["h", "e", "l", "l", "o", "w", "o", "r", "l", "d”]

（六）元素在数组中的位置
        1 arr.indexOf() 查找某个元素的索引值，若有重复的，则返回第一个查到的索引值若不存在，则返回 -1
            let arr = [1,2,3,4,5,2]
            let arr1 = arr.indexOf(2)
                console.log(arr1)  // 1
            let arr2 = arr.indexOf(9)
                console.log(arr2)  // -1
        2 arr.lastIndexOf()   和arr.indexOf()的功能一样，不同的是从后往前查找

            let arr = [1,2,3,4,5,2]
            let arr1 = arr.lastIndexOf(2)
                console.log(arr1)  // 5
            let arr2 = arr.lastIndexOf(9)
                console.log(arr2)  // -1

    3.find()方法用于找出第一个符合条件的数组元素【es6】
            [1, 4, -5,-2,10].find((n) => n < 0). //-5
                find方法的回调可以接受三个值,【当前的值，当前位置，原数组】
            [1, 4, 5,10].find(function(value, index,arr){
                retrun value > 9 //10
            })

    4.findIndex()方法 ，返回符合条件的数组元素的索引,如果没有找到，则返回-1【es6】
        [1, 4, -5,-2,10].findIndex((n) => n < 0). //2
            find方法的回调可以接受三个值,【当前的值，当前位置，原数组】
        [1, 4, 5,10].findIndex(function(value, index,arr){
            retrun value > 9 //3
        })
            这两个方法都可以接受第二个参数，用来绑定回调函数的this对象【es6】
        [1, 4, -5,-2,10].find((n) => n < 0)
            find方法的回调可以接受三个值,【当前的值，当前位置，原数组】
            function f(v){
                Return v >this.age;
            }
            let person = {age:20,name:”john”}
            [10，12，20，26].find(f, person) //-5

    5.includes方法返回一个 布尔值，表示某个数组是否包含给定的值【es6】
         这个方法接受两个参数，要查找的元素，开始查找索引的位置
            [1,2,3].includes(2) //true || [5,6,7].includes(2) //false
            [1, 2, 3].includes(3, 3);  // false ||. [1, 2, 3].includes(3, 2);  //true
            [1, 2, 3].includes(3, -1);  //true

    6.every()   判断数组中是否所有的元素都符合条件【every:一假即假:】【es6】
        Var arr =[1,2,3,4,18]
            Var every = arr.every(function(){
            return obj >17 //false
        })
        Var arr =[18,19,20]
            Var every = arr.every(function(){
            return obj >17 //true
        })
    7.some()   判断数组中是否所有的元素都符合条件【some:一真即真 】【es6】
        var arr=[1,2,3,4,18]
        Var arr =[1,2,3,4,18]
        Var some = arr.some(function(){
            return obj >17 //true
        })
    Var arr =[18,19,20]
        Var some = arr.some(function(){
        return obj >17 //true
    })

8.isArray()   判断元素是否是数组【es6】
     var arr=[1,2,3,4,18]
        if( Array.isArray( arr ) ){
            Console.info(‘2222’)  //2222
        }