数组基本操作案例

• 冒泡排序

    var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]
    // 下标    0  1  2  3   4  5  6  7  8
    console.log('原始数组: ', arr)
  
    for (var k = 0; k < arr.length - 1; k++) {
         console.log(`这是第 ${k + 1} 轮循环(k == ${k})`)
         for (var i = 0; i < arr.length - 1 - k; i++) {
             console.log(arr[i], arr[i + 1])
             if (arr[i] > arr[i + 1]) {
                 var temp = arr[i]
                 arr[i] = arr[i + 1]
                 arr[i + 1] = temp
             }
         }
     }
     console.log('冒泡排序结束后的arr: ', arr)
  

• 选择排序

    var arr = [50,80,79,61,82,5,28,68,44]
    console.log(arr)
    for(var k = 0;k < arr.length; k++){
        var minIndex = k
        for(var i = k + 1;i < arr.length; i++){
            if(arr[minIndex] > arr[i]){
                minIndex = i
            }
        }
        var temp = arr[k]
        arr[k] = arr[minIndex]
        arr[minIndex] = temp
    }
    console.log(arr)
  

数组常用方法

• push; pop; unshift; shift;

• reverse; sort; splice; slice; concat; join; indexOf; lastIndexOf

• forEach; map; filter; find; findIndex; every; some; reduce;

  • 数组的方法 1~7 是能够改变原数组的方法

    1. push;
        语法: 数组.push(数据)
        作用: 向 数组末尾 添加数据
        返回值: 追加数据后, 数组最新的长度
    
    2. pop;
        语法: 数组.pop()
        作用: 删除数组的最后一项
        返回值: 删除的哪一项数据
    
    3. unshift;
        语法: 数组.unshift(数据)
        作用: 向 数组头部 添加数据
        返回值: 追加数据后, 数组最新的长度
    
    4. shift;
        语法: 数组.shift()
        作用: 删除数组头部(第一项)的数据
        返回值: 删除的哪一项数据
    
    5. reverse;
        语法: 数组.reverse()
        作用: 反转数组
        返回值: 反转后的数组
    
    6. sort;
        语法: 数组.sort(); 数组.sort(function (a, b) {retrun a - b}); 数组.sort(function (a, b) {retrun b - a})
        作用:
            不传参数
                会将数组内所有值, 转换为字符串, 然后一位一位的对比(第一位相同,对比第二位,...)
            传参---函数 return a - b
                会将数组内所有的值, 按照数字的 从小到大排列
            传参---函数 return b - a
                会将数组内所有的值, 按照数字的 从大到小排列
        返回值: 
            不传参数
                将排序后的数组返回
            传递参数
                将排序后的数组返回
    
    7. splice;
        语法: 数组.splice(开始索引, 多少个);  数组.splice(开始索引, 多少个, 数据1, 数据2, 数据3...)
        作用: 
            不传参数: 剪切数组中的某一段数据
            传递参数: 剪切数组中的某一段数据, 将第三个参数开始, 当成新数据插入到数组内
        返回值: 截切后的数据(数组形式)
    
    
    
    8. slice;   (不会改变原数组)
        语法: 数组.slice(开始索引, 结束索引)
        参数特点: 1. 包含开始索引, 不包含结束索引(到结束索引前一位)
                 2. 参数接受负数(相当于 数组.length + 负数)
                 3. 不传结束索引     相当于写了 数组.length
                 4. 一个参数都不传   相当于复制整个数组, 或者只传递第一个参数为 0
        作用: 复制数组中的某一段数据
        返回值: 复制出来的内容
    
    
    9. concat;
        语法: 数组.concat(数据1, 数据2)
        作用: 将 参数, 合并到 指定数组内(如果参数写了数组, 那么会将数组的每一个值合并到指定数组)
        返回值: 合并后的数组
    
     10. join;
        语法: 数组.join(连接符)
            参数可以不传, 不传递默认按照 , 逗号
        作用: 通过连接符连接数组的每一个值
        返回值: 连接好的数组
    
     11. indexOf; 
        语法: 数组.indexOf(数据);   数组.indexOf(数据, 开始索引)
        作用: 在数组内寻找指定数据
        返回值: 
            1. 找到数据的时候, 返回数据第一次出现的下标
            2. 找不到的时候, 返回 -1
            
     12. lastIndexOf
        语法: 数组.lastIndexOf(数据);   数组.lastIndexOf(数据, 开始索引)
        作用: 在数组内寻找指定数据(倒叙寻找)
        返回值: 
            1. 找到数据的时候, 返回数据第一次出现的下标
            2. 找不到的时候, 返回 -1
    

数组的遍历方法

• forEach; map; filter; find; findIndex; every; some; reduce;

      1. forEach
          语法: 数组.forEach(function(item, index, origin){})
          参数: 
                  1. 数组实际每一项的值
                  2. 数组每一项对应的下标
                  3. 原数组
          作用: 遍历数组
          返回值:   返回值是 undefined  哪怕你手写了 return 也是 undefined
  
      2. map
           语法: 数组.map(function (item, index, origin) {})
           参数: 
                  1. 数组每一项实际的值
                  2. 数组每一项实际的值对应的下标
                  3. 原数组
           作用: 映射数组
           返回值: 返回一个和原数组长度一样的数组, 返回的数组的每一个值, 取决参数的return怎么写
     
      3. filter; 
           语法: 数组.filter(function (item, index, origin) {})
           参数: 
                  1. 数组每一项实际的值
                  2. 数组每一项实际的值对应的下标
                  3. 原数组
           作用: 过滤数组
           返回值: 过滤数组后的新数组, 过滤条件取决于 参数的 return 怎么写
  
      4. find; 
          语法: 数组.find(function (item, index, origin) {})
          参数: 
                  1. 数组每一项实际的值
                  2. 数组每一项实际的值对应的下标
                  3. 原数组
           作用: 查找数据
           返回值: 在数组内找到的第一个数据(不是数组)
          
      5. findIndex;
           语法: 数组.findIndex(function (item, index, origin) {})
           参数:
                  1. 数组每一项实际的值
                  2. 数组每一项实际的值对应的下标
                  3. 原数组
          作用: 查找数据 第一次出现的 下标
          返回值: 在数组内找到的第一个数据出现的下标
     
      6. every; 
           语法: 数组.every(function(item, index, origin){})
           参数:
                  1. 数组第一项实际的值
                  2. 数组第一项实际的值对应的下标
                  3. 原数组
          作用: 判断数组内数据是否全都满足条件
          返回值: 一个布尔值
              true ---> 数组内数据全都符合条件
              false ---> 数组内起码有一个数据 不符合条件
      
      7. some;
           语法: 数组.some(function (item, index, origin) {})
           参数:
                  1. 数组每一项实际的值
                  2. 数组每一项实际的值对应的下标
                  3. 原数组
           作用: 判断数组内数据是否  有一项 满足条件的
           返回值: 一个布尔值
              true: 表示数组内至少有一项满足条件
              false: 数组内数据全都不满足条件
     
      8. reduce;
           语法: 数组.reduce(function (prve, item, index, origin) {}, init)
           reduce方法的参数: 
                  1. 如果传递第二个参数 init, 执行次数和数组长度相同
                  2. 如果不传递第二个参数 init, 默认第一值为数组第一项的值, 并且执行次数在数组长度上 减1
           参数1的函数中4个形参的含义:
                  1. 表示初始值或者数组第一项的值(具体是什么取决于是否传递 init)
                  2. 数组每一项实际的值
                  3. 数组每一项实际的值对应的下标
                  4. 原数组
           作用: 累加(叠加)
           返回值: 循环运行结束后得到的值