数组

295 阅读3分钟

数组概念

计算机内存中一段连续的空间,使用一个变量名来表示

定义:
      var arr=new Array(多个数据)
      var arr=[多个数据]  
      

基本操作

访问元素:
        数组[下标]
        
设置元素:
        数组[下标]=值
        下标原本存在    为修改
        下标原本不存在  为新增

删除:
    delete 数组[下标]
    但只能删除数据,不能删除空间

长度:
    数组.length
    数组.length=长度
       
遍历:
    for循环,循环每个元素的下标,条件通常用数组.length
    
 arguments:
     拿到传入参数的下标
    

数组API

 sort:
     升序:arr.sort(function(a,b){
     return a-b
 })
     降序:arr.sort(function(a,b){
     return b-a
 })
 
 arr.push()  在末尾添加一个元素
     var arr=[1,2,3]
     arr.push(4)
     console.log(arr) // arr=[1,2,3,4]
 
 arr.pop()   删除末尾一个元素
     var arr=[1,2,3,4]
     arr.pop()
     console.log(arr) // arr=[1,2,3]
 
 arr.unshift()    在开头添加一个元素
     var arr=[1,2,3,4]
     arr.unshift(5)
     console.log(arr) // arr=[5,1,2,3,4]
 
 arr.shift()      在开头删除一个元素
     var arr=[1,2,3,4,5]
     arr.shift()
     console.log(arr) // arr=[2,3,4,5]
     
 arr.splice(开始下标,n)  从开始下标删除n个元素
     var arr=[1,2,3,4,5]
     arr.splice(1,2)
     console.log(arr) // arr=[1,4,5]
     
 arr.splice(开始下标,0,新元素,...)   从开始下标添加新元素
     var  arr=[1,2,3,4,5]
     arr.splice(2,0,6,7)
     console.log(arr) // arr=[1,2,6,7,3,4,5]
 arr.splice(开始下标,n,新元素)       从开始下标替换新元素
     var arr=[1,2,3,4,5]
     arr.splice(0,2,6,7,8)
     console.log(arr) // arr=[6,7,8,3,4,5]
 
 arr.slice(开始下标,n)   从开始下标截取到结束下标
     var arr=[1,2,3,4]
     var brr=arr.slice(1,2)
     console.log(brr) // brr=[2]
 arr.slice(开始下标)      从开始下标截取到末尾
     var arr=[1,2,3,4,5]
     var brr=arr.slice(2)
     console,log(brr) // brr=[3,4,5]
 arr.slice()             从数组开始截取到末尾
     var arr=[1,2,3,4,5]
     var brr=arr.slice()
     console.log(brr) // brr=[1,2,3,4,5]
 arr.concat()            合并数组
     var arr=[1,2,3]
     var brr=arr.concat([4,5,6])
     console.log(brr) // brr=[1,2,3,4,5,6]
     
 arr.join                拼接数组
     var arr=[1,2,3,4]
     console.log(arr.join("+")) // arr=[1+2+3+4]
 reverse                 翻转数组
     var arr=[1,2,3,4,5]
     console.log(arr.reverse()) // arr=[5,4,3,2,1]
     
 indexof                 找元素在数组中第一次出现得下标
     
 lastIndexof             找元素在数组中最后一次出现的下标
 
 forEach                 遍历数组
 
 map                     映射新数组
 
 filter                  过滤出符合条件的元素组成新数组
 
 every                   判断数组中是否所有元素都满足条件
 
 some                    判断数组中是否至少有一个是满足条件的
 
 find                    查找数组中符合条件的第一个元素
 
 findIndex               在数组中符合条件的一个元素
 
 reduce                  求和
 

数组排序

冒泡排序:
        for (var a = 0; a < arr.length - 1; a++) {  
            for (var b = 0; b < arr.length - 1 - a; b++) {  
                if (arr[b] < arr[b + 1]) {  
                    var tmp = arr[b]  
                    arr[b] = arr[b + 1]  
                    arr[b + 1] = tmp  
                   }  
               }  
           }
  
选择排序:
        for (var a = 0; a < arr.length - 1; a++) {  
            for (var b = a + 1; b < arr.length; b++) {  
                    if (arr[a] < arr[b]) {  
                    var tmp = arr[a]  
                    arr[a] = arr[b]  
                    arr[b] = tmp  
                  }  
               }  
           }
          
         for (var a = 0; a < arr.length - 1; a++) {  
                    var maxIndex = a  
            for (var b = a + 1; b < arr.length; b++) {  
                    if (arr[a] < arr[b]) {  
                    maxIndex = b  
                }  
            }  
                    var tmp = arr[a]  
                    arr[a] = arr[maxIndex]  
                    arr[maxIndex] = tmp  
         }

基础类型和引用类型

           根据内存空间类型分类:
               
               1.基础类型:
                         number
                         string
                         boolean
                         undefined
                         null
               
               2.引用类型:
                         function
                         {}
                         []
                         
           基础类型和引用类型区别:
               1.存储方式不同:
                       1)基础类型将数据存在栈中
                       2)引用类型将数据存在堆中,将队得地址存在栈中
               
               2.赋值方式不同:
                       1)基础类型将数据复制一份给另一个变量
                       2)引用类型是栈中得地址复制一份给另一个变量
               
               3.相等的比较方式不同:
                       1)基础类型比较数据、类型
                       2)引用类型,只比较内存地址