• 数组笔记


    (一)数组的创建

     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
            }
  • 相关阅读:
    Python入门11 —— 基本数据类型的操作
    Win10安装7 —— 系统的优化
    Win10安装6 —— 系统的激活
    Win10安装5 —— 系统安装步骤
    Win10安装4 —— 通过BIOS进入PE
    Win10安装2 —— 版本的选择与下载
    Win10安装1 —— 引言与目录
    Win10安装3 —— U盘启动工具安装
    虚拟机 —— VMware Workstation15安装教程
    Python入门10 —— for循环
  • 原文地址:https://www.cnblogs.com/restart77/p/12337033.html
走看看 - 开发者的网上家园