数组的常用方法

 

命令符:

1. push()

        + 语法: 数组.push(数据)

        + 作用: 向数组的末尾追加一个数据, 等价于 arr[arr.length] = 值

        + 返回值: 追加数据后最新的数组长度

---

      2. pop()

        + 语法: 数组.pop()

        + 作用: 删除数组的最后一个数据

        + 返回值: 被删除的数据

---

      3. unshift()

        + 语法: 数组.unshift(数据)

        + 作用: 向数组的最前面插入一个数据

        + 返回值: 插入数据后最新的数组长度

---

      4. shift()

        + 语法: 数组.shift()

        + 作用: 删除数组最前面一个数据

        + 返回值: 被删除的数据

---

 

1.  5. reverse()

           + 语法: 数组.reverse()

           + 作用: 反转数组

           + 返回值: 反转以后的数组

   ---

         6. sort()

           + 语法:

             => 数组.sort()

               -> 按照数据一位一位看待进行排列的, ASCII 码进行排列的

             => 数组.sort(function (a, b) { return a - b })

               -> 按照数字大小进行升序排列, 从小到大

             => 数组.sort(function (a, b) { return b - a })

               -> 按照数字大小进行降序排列, 从大到小

           + 作用: 对数组进行排序

           + 返回值: 排序以后的数组

   ---

         7. splice()

           + 语法:

             => 数组.splice(开始索引, 多少个)

             => 数组.splice(开始索引, 多少个, 要插入的内容)

               -> 要插入的内容可以写多个

               -> 注意: 从哪里开始删除, 从哪里开始插入

           + 作用: 截取数组中的部分内容, 并且插入内容

           + 返回值: 必然是一个新的数组

             => 新数组内是被删除的部分内容

             => 如果你没有删除的内容, 那么就是一个空的新数组       

   ---

    

    8. concat()

      + 语法: 原始数组.concat(数据或者数组)

        => 参数可以是数据, 也可以是一个数组

          => 可以书写多个

        + 作用: 拼接数组, 把参数的所有内容拼接到数组的末尾

          => 如果你的参数也是一个数组, 会把参数数组拆开, 依次拼接到原始数组内

        + 返回值: 拼接好的数组

---

      9. join()

        + 语法: 数组.join(连接符号)

          => 参数不写的时候, 默认使用 逗号(,) 连接

        + 作用: 使用连接符号把数组内的每一个数据连接成一个 **字符串**

        + 返回值: 必然是一个字符串类型, 连接好的内容

---

      10. slice()

        + 语法: 数组.slice(开始索引, 结束索引)

          => 特点1: 包前不包后, 包含开始索引位置, 不包含结束索引位置

          => 特点2: 可以填写负整数, 表示倒数多少个, 其实就是 数组.length + 负整数

        + 作用: 截取数组的部分内容

        + 返回值: 必然是一个新的数组

          => 你截取了内容, 那么新数组内就是你截取的内容

          => 你没有截取内容, 那么就是一个空的新数组

---

      11. indexOf()

        + 语法: 数组.indexOf(数据, 开始索引)

          => 开始索引位置可以不写, 默认是 0

        + 作用: 从左到右查看该数据在数组中 **第一次** 出现的索引位置

        + 返回值:

          => 如果数组中有该数据存在, 那么就是第一次出现的索引位置

          => 如果数组中没有该数据存在, 那么就是 -1

---

      12. lastIndexOf()

        + 语法: 数组.lastIndexOf(数据, 开始索引)

          => 开始索引位置可以不写, 默认是数组的最后一位索引

        + 作用: 从后向前查看该数据在数组中 **第一次** 出现的索引位置

        + 返回值:

          => 如果数组中有该数据存在, 那么就是第一次出现的索引位置

          => 如果数组中没有该数据存在, 那么就是 -1

        + 注意: 只是从后向前查找, 但是不改变数据的索引位置

---

 13. forEach()

        + 语法: 数组.forEach(function (item, index, arr) {})

        + 作用: 遍历数组

        + 返回值: 没有

---

      14. map()

        + 语法: 数组.map(function (item, index, arr) {})

        + 作用: 映射数组

        + 返回值: **是一个新的数组, 和原始数组长度一模一样的新数组**

          => 新数组内的每一个数据是从原始数组中映射过来的(操作一下原始数组的数据)

        + 注意: 映射条件以 return 的形式书写

---

      15. filter()

        + 语法: 数组.filter(function (item, index, arr) {})

        + 作用: 过滤数组

        + 返回值: **是一个新的数组, 原始数组中满足条件的项**

          => 新数组内的每一个数据都是从原数组中过滤出来的内容

        + 注意: 过滤条件以 return 的形式书写

---

      16. find()

        + 语法: 数组.find(function (item, index, arr) {})

        + 作用: 在数组中查找第一个符合条件的数据

        + 返回值: 你查找到的符合要求的数据

        + 注意: 查找条件以 return 的形式书写

---

      17. findIndex()

        + 语法: 数组.findIdnex(function (item, index, arr) {})

        + 作用: 在数组中查找第一个符合条件的数据的索引

        + 返回值: 你查找到的符合要求的数据的索引

        + 注意: 查找条件以 return 的形式书写

---

      18. every()

        + 语法: 数组.every(function (item, index, arr) {})

        + 作用: 判断数组中是不是每一个都满足条件

        + 返回值: 必然是一个布尔值

          => 如果数组中每一项都满足条件, 那么返回 true

          => 只要数组中有任何一项不满足条件, 那么返回 false

        + 注意: 判断条件以 return 的形式书写

---

      19. some()

        + 语法: 数组.some(function (item, index, arr) {})

        + 作用: 判断数组中是不是有某一个满足条件

        + 返回值: 必然是一个布尔值

          => 如果数组中有任何一个满足条件, 那么返回 true

          => 只有数组中所有的都不满足条件的时候, 返回 false

        + 注意: 判断条件以 return 的形式书写

---

用法：

// 准备一个数组

    var arr = [ 100, 200, 300, 400, 500 ]

    console.log('原始数组 : ', arr)

---

    1. push()

    // var res = arr.push('新来的')

    // console.log('追加之后 : ', arr)

    // console.log('返回值 : ', res)

---

    // 2. pop()

    // var res = arr.pop()

    // console.log('删除之后 : ', arr)

    // console.log('返回值 : ', res)

---

    // 3. unshift()

    // var res = arr.unshift('新来的')

    // console.log('插入之后 : ', arr)

    // console.log('返回值 : ', res)

---

    // 4. shift()

    var res = arr.shift()

    console.log('删除之后 : ', arr)

    console.log('返回值 : ', res)

---

// 5. reverse()

    // var arr = [ 'hello', 'world', '你好', '世界' ]

    // console.log('原始数组 : ', arr)

    // var res = arr.reverse()

    // console.log('反转之后 : ', arr)

    // console.log('返回值 : ', res)

---

    // 6. sort()

    // var arr = [ 1, 22, 3, 11, 10, 7, 21, 105 ]

    // console.log('原始数组 : ', arr)

    // 语法1:

    // var res = arr.sort()

  console.log('排序之后 : ', arr)

    console.log('返回值 : ', res)

    // 语法2:

    // var res = arr.sort(function (a, b) { return a - b })

    // console.log('排序之后 : ', arr)

    // console.log('返回值 : ', res)

    // 语法3:

    // var res = arr.sort(function (a, b) { return b - a })

    // console.log('排序之后 : ', arr)

    // console.log('返回值 : ', res)

---

    // 7. splice

    var arr = [ 100, 200, 300, 400, 500, 600, 700 ]

    //           0    1    2    3    4    5    6

    console.log('原始数组 : ', arr)

    // 语法1:

    // 表示从数组 [2] 位置开始, 删除 3 个内容

    // var res = arr.splice(2, 3)

    // console.log('删除之后 : ', arr)

    // console.log('返回值 : ', res)

    // 语法2:

    // 表示从数组 [2] 位置开始, 删除 1 个内容, 把 '新来的' 内容插入到 [2] 位置

    // var res = arr.splice(2, 1, '新来的')

    // console.log('删除之后 : ', arr)

    // console.log('返回值 : ', res)

  // 表示从数组 [2] 位置开始, 删除 1 个内容, 把 '新来的' 和 '又来一个' 插入到 [2] 位置和 [3] 位置, 剩余数据向后顺延

    // var res = arr.splice(2, 1, '新来的', '又来一个')

    // console.log('删除之后 : ', arr)

    // console.log('返回值 : ', res)

    // 表示从数组 [2] 位置开始, 删除 0 个数据, 把 '新来的' 插入到 [2] 位置, 剩余的向后顺延

    // var res = arr.splice(2, 0, '新来的')

    // // [ 100, 200, '新来的', 300, 400, 500, 600, 700 ]

    // console.log('删除之后 : ', arr)

    // console.log('返回值 : ', res)

---

// 8. concat()

    // var arr = [ 100, 200, 300 ]

    // console.log('原始数组 : ', arr)

    // 把 '新来的' 和 arr 组成一个新的数组

    // var res = arr.concat('新来的')

    // console.log('拼接之后 : ', arr)

    // console.log('返回值 : ', res)

    // 把 [ 'a', 'b', 'c' ] 内的所有内容和 原始数组 arr 拼接成一个数组

    // var res = arr.concat([ 'a', 'b', 'c' ], [ 10, 20, 30 ], 666)

    // console.log('拼接之后 : ', arr)

    // console.log('返回值 : ', res)

---

    // 9. join()

    // var arr = [ 2022, 3, 25 ]

    // console.log('原始数组 : ', arr)

    // var res = arr.join('-')

    // console.log('连接之后 : ', arr)

    // console.log('返回值 : ', res)

---

    // 10. slice()

    // var arr = [ 100, 200, 300, 400, 500, 600, 700 ]

    //           0    1    2    3    4    5    6

    // console.log('原始数组 : ', arr)

    // 表示从数组 [2] 位置开始截取到数组 [5] 位置, 包含 [2] 位置数据, 不包含 [5] 位置数据

    // 注意: 不会改变原始数组, 相当于把指定位置的内容复制一份拿出来

    // 注意: 如果第一个参数不写, 那么就是 0

    // 注意: 如果第二个参数不写或者超出数组的长度, 那么就是截取到数组末尾

    // var res = arr.slice(2, 5)

    // console.log('截取之后 : ', arr)

    // console.log('返回值 : ', res)

    // 你填写的 -2 等价于 arr.length + -2, 其实就是 5

    // var res = arr.slice(2, -2)

    // console.log('截取之后 : ', arr)

    // console.log('返回值 : ', res)

---

    // 11. indexOf()

    // var arr = [ 100, 200, 300, 400, 100, 200, 300, 100, 200, 100 ]

    // console.log('原始数组 : ', arr)

    // 表示从左到右开始查找 200 这个数据在 arr 中第一次出现的位置

    // var res = arr.indexOf(200)

    // console.log('返回值 : ', res)

    // 表示从 [2] 位置开始, 从左到右查找 200 这个数据在 arr 中第一次出现的位置

    // var res = arr.indexOf(200, 2)

    // console.log('返回值 : ', res)

---

    // 12. lastIndexOf()

    var arr = [ 100, 200, 300, 400, 100, 200, 300, 100, 200, 100 ]

    console.log('原始数组 : ', arr)

    // 表示从右向左开始查找 200 这个数据在 arr 中第一次出现的位置

    // var res = arr.lastIndexOf(200)

    // console.log('返回值 : ', res)

    // 表示从 [7] 位置开始, 从右向左查找 200 这个数据在 arr 中第一次出现的位置

    var res = arr.lastIndexOf(200, 7)

    console.log('返回值 : ', res)

---

// 13. forEach()

    // var arr = [ 100, 200, 300, 400, 500 ]

    // console.log('原始数组 : ', arr)

    // 这个 函数 会根据 arr 数组中有多少个成员, 执行多少回

    // 这个 函数 可以接受三个形参

    //   第一个形参: 表示 数组中的每一项

    //   第二个形参: 表示 数组每一项的索引

    //   第三个形参: 表示 原始数组

    // arr.forEach(function (item, index, arr) {

    //   console.log('我执行了')

    //   console.log('item : ', item)

    //   console.log('index : ', index)

    //   console.log('arr : ', arr)

    //   console.log('---------------------------')}

---

    // 14. map()

    // var arr = [ 10, 20, 30, 40, 50 ]

    // console.log('原始数组 : ', arr)

    // var res = arr.map(function (item, index) {

    //   // 把原始数组中的每一项放大十倍

    //   return item * 10

    // })

    // console.log(res) // [100, 200, 300, 400, 500]

---

    // 15. filter()

    // var arr = [ 100, 200, 300, 400, 500 ]

    // console.log('原始数组 : ', arr)

    // var res = arr.filter(function (item, index) {

    //   // 把原始数组中所有 大于 300 的数据过滤出来

    //   return item > 300

    // })

    // console.log('返回值 : ', res)

---

    // 16. find()

    // var arr = [ 100, 200, 300, 400 ]

    // console.log('原始数组 : ', arr)

    // var res = arr.find(function (item) {

    //   // 从 每一项 中, 查找第一个 百位数是 偶数的

    //   return parseInt(item / 100) % 2 === 0

    // })

    // console.log('返回值 : ', res)

---

    // 17. findIndex()

    // var arr = [ 100, 200, 300, 400 ]

    // console.log('原始数组 : ', arr)

    // var res = arr.findIndex(function (item) {

    //   // 从 每一项 中, 查找第一个 百位数是 偶数的

    //   return parseInt(item / 100) % 2 === 0

    // })

    // console.log('返回值 : ', res)

---

    // 18. every()

    // var arr = [ 100, 200, 300, 400, 500 ]

    // console.log('原始数组 : ', arr)

    // var res = arr.every(function (item) {

    //   // 判断是不是每一项都 大于 100

    //   return item > 100

    // })

    // console.log('返回值 : ', res)

---

    // 19. some()

    var arr = [ 100, 200, 300, 400, 500 ]

    console.log('原始数组 : ', arr)

    var res = arr.some(function (item) {

      // 判断是不是有大于 100 的项

      return item > 400

    })