JavaScript中数组常用方法汇总！

超、凢脫俗 2024-03-17 13:04 27阅读 0赞

数组是一个复杂数据类型，我们在操作它的时候就不能再想基本数据类型一样操作了。

比如我们想改变一个数组

// 创建一个数组
    var arr = [1, 2, 3]
    
    // 我们想把数组变成只有 1 和 2
    arr = [1, 2]

这样肯定是不合理，因为这样不是在改变之前的数组。相当于重新制作了一个数组给到 arr 这个变量了，相当于把 arr 里面存储的地址给换了，也就是把存储空间换掉了，而不是在之前的空间里面修改。所以我们就需要借助一些方法，在不改变存储空间的情况下，把存储空间里面的数据改变了。

#### 数组常用方法之 push ####

作用：用来在数组的末尾追加元素

语法： 数组.push(数据)

返回值：添加数据以后, 数组最新的 长度

var arr = [1, 2, 3]
    
    // 使用 push 方法追加一个元素在末尾
    var res = arr.push(4)
    
    //返回数组的长度
    console.log(res); // 4
    
    console.log(arr) // [1, 2, 3, 4]

#### 数组常用方法之 pop ####

作用：pop 是用来删除数组末尾的一个元素

语法：数组.pop()

返回值：被删除的数据

var arr = [1, 2, 3]
    
    // 使用 pop 方法删除末尾的一个元素
    var res = arr.pop()
    
    // 返回被删除的元素
    console.log(res); 3
    console.log(arr) // [1, 2]

#### 数组常用方法之 unshift ####

作用：在数组的最前面添加元素

语法：数组.unshift(数据)

返回值：返回数组最新的长度

var arr = [1, 2, 3]
    
    // 使用 unshift 方法想数组的最前面添加一个元素
    var res = arr.unshift(9)
    
    //返回数组最新的长度
    console.log(res); // 4
    console.log(arr) // [9, 1, 2, 3]

#### 数组常用方法之 shift ####

作用：删除数组最前面的一个元素

语法：数组.shift()

返回值：被删除的数据

var arr = [4, 5, 6]
    
    // 使用 shift 方法删除数组最前面的一个元素
    var res = arr.shift()
    
    //返回被删除的数据
    console.log(res); // 4
    console.log(arr) // [5, 6]

#### 数组常用方法之 splice ####

作用: splice 是截取数组中的某些内容，按照数组的索引来截取

语法: splice(从哪一个索引位置开始，截取多少个，替换的新元素)

第三个参数可以不写

返回值：返回一个新数组，数组内的值就是刚刚删除掉的值

注意：该方法会改变原始数组

var arr = [1, 2, 3, 4, 5]
    
    // 使用 splice 方法截取数组
    var res = arr.splice(1, 2)
    
    //返回一个新数组 元素就是截取出来的数据
    console.log(res); //[2, 3]
    console.log(arr) // [1, 4, 5]

arr.splice(1, 2) 表示从索引 1 开始截取 2 个内容。第三个参数没有写，就是没有新内容替换掉截取位置。

var arr = [1, 2, 3, 4, 5]
    
    // 使用 splice 方法截取数组
    var res = arr.splice(1, 2, '我是新内容')
    
    //返回的是一个新数组，里面的元素就是截取出来的元素
    console.log(res); //[2, 3]
    console.log(arr) // [1, '我是新内容', 4, 5]

arr.splice(1, 2, '我是新内容') 表示从索引 1 开始截取 2 个内容，然后用第三个参数把截取完空出来的位置填充。

#### 数组常用方法之 reverse ####

作用：reverse 是用来反转数组使用的

语法：数组.reverse()

返回值：反转后的数组

var arr = [1, 2, 3]
    
    // 使用 reverse 方法来反转数组
    var res = arr.reverse()
    console.log(res); //[3, 2, 1]
    
    console.log(arr) // [3, 2, 1]

#### 数组常用方法之 sort ####

作用：sort 是用来给数组排序的

简单用法语法：数组.sort()

基础用法

var arr = [2, 3, 1, 4, 5, 18, 7, 32]
    
    // 使用 sort 方法给数组排序
    var res = arr.sort()
    
    console.log(res);
    
    console.log(arr) // [1, 18, 2, 3, 32, 4, 5, 7]

升序和降序用法

○语法->升序：数组.sort(function (a, b) \{ return a - b \})

○语法->降序：数组.sort(function (a, b) \{ return b - a \})

返回值：排序后的数组

var arr = [ 1, 23, 32, 20, 19, 10, 3, 5, 33 ]
    console.log('原始数组 : ', arr)
    
    // 升序排列
    var res = arr.sort(function (a, b) { return a - b })
    
    console.log('排序之后 : ', arr)
    console.log('返回值 : ', res)
    
    
    var arr = [ 1, 23, 32, 20, 19, 10, 3, 5, 33 ]
    console.log('原始数组 : ', arr)
    
    // 降序排列
    var res = arr.sort(function (a, b) { return b - a })
    
    console.log('排序之后 : ', arr)
    console.log('返回值 : ', res)

#### 数组常用方法之 concat ####

作用：concat 是把多个数组进行拼接

语法：数组.concat(数组)

返回值：返回一个新数组

和之前的方法有一些不一样的地方，就是 concat 不会改变原始数组，而是返回一个新的数组

var arr = [1, 2, 3]
    
    // 使用 concat 方法拼接数组
    var newArr = arr.concat([4, 5, 6])
    
    console.log(arr) // [1, 2, 3]
    console.log(newArr) // [1, 2, 3, 4, 5, 6]

注意： concat 方法不会改变原始数组

#### 数组常用方法之 join ####

作用: 数组里面的每一项内容链接起来，变成一个字符串

可以自己定义每一项之间链接的内容 join(要以什么内容链接)

不会改变原始数组，而是把链接好的字符串返回

var arr = [1, 2, 3]
    
    // 使用 join 链接数组
    var str = arr.join('-')
    
    console.log(arr) // [1, 2, 3]
    console.log(str) // 1-2-3

注意： join 方法不会改变原始数组，而是返回链接好的字符串

#### 数组常用方法之 slice ####

作用：slice 能够截取数组，并返回一个新的 数组不改变数组

语法：数组.slice(下标开始值,下标结束值)

注意：从下标开始值开始，保留到 下标结束值的前一个结束，如果没有下标结束值（也就是没有第二个参数），就保留到最后一个字符结束。

返回值：返回一个新的 数组

var arr = [1, 2, 3, 8, 4, 9]
    
    // 使用slice截取
    var str = arr.slice(2, 4)
    
    console.log(arr) // [1, 2, 3, 8, 4, 9]
    console.log(str) //[3, 8]

#### 数组常用方法之 indexOf ####

语法: 数组名.indexOf(要查找的数据)

语法二: 数组名.indexOf(要查的数据,索引)

*  这个语法的意思是.要从指定的索引开始查找该数据,
 *  如果有就放回该数据在原数组中第一个出现的位置,如果没有就返回 -1

作用: 从前往后在数组中查找该数据第一次出现的位置

返回值: 如果该数组中有这个数据就返回这个数据第一个次出现的位置也就是索引,如果没有返回 -1

// indexOf() 方法
    // 语法一:
    var arr = [200, 300, 100, 200, 300, 200, 300]
    var res = arr.indexOf(100)
    console.log('原始数组:', arr);
    console.log('返回值:', res);
    
    
    // 语法二:
    var arr = [200, 300, 100, 200, 300, 200, 300]
    var res = arr.indexOf(300, 1)
    console.log('原始数组:', arr);
    console.log('返回值:', res);

#### 数组常用方法之 lastIndexOf ####

语法: 数组名.lastIndexOf(要查的数据)

语法二: 数组名.lastIndexOf(要查找的数据,索引)

*  这个语法的意思是.要从指定的索引开始查找该数据,
 *  如果有就放回该数据在原数组中第一个出现的位置,如果没有就返回 -1

作用: 从后往前在数组中查找这个数据第一次出现的位置

返回值: 如果该数组中有这个数据就返回这个数据第一个次出现的位置也就是索引,如果没有返回 -1

// lastIndexOf() 方法
    // 语法一:
    var arr = [200, 300, 100, 200, 300, 200, 300]
    var res = arr.lastIndexOf(400)
    console.log('原始数组:', arr);
    console.log('返回值: ', res);
    
    
    // 语法二:
    var arr = [200, 300, 100, 200, 300, 200, 300]
    var res = arr.lastIndexOf(200, 2)
    console.log('原始数组:', arr);
    console.log('返回值: ', res);

#### 数组常用方法之 forEach ####

作用：和 for 循环一个作用，就是用来遍历数组的

语法：arr.forEach(function (item, index, arr) \{\})

*  item 表示数组内的每一项
 *  index 表示数组内每一项的索引
 *  arr 表示原始数组

返回值：没有返回值，是undefined

var arr = [100, 200, 300, 400, 500]
    
    arr.forEach(function(item, index, arr) {
        // 这个函数会根据数组内有多少成员执行多少回
        console.log('我执行了')
        console.log(item);
        console.log(index);
        console.log(arr);
        console.log(item, ' ---- ', index, ' ---- ', arr)
    })

*  forEach() 的时候传递的那个函数，会根据数组的长度执行
 *  数组的长度是多少，这个函数就会执行多少回

#### 数组常用方法之 map ####

和 forEach 类似，只不过可以对数组中的每一项进行操作，返回一个新的数组

语法：arr.map(function (item, index, arr) \{\})

返回值：是一个新数组, 并且和原始数组长度一致

*  新数组内每一个数据都是根据原始数组中每一个数据映射出来的
 *  映射条件以 return 的形式书写

var arr = [1, 2, 3]
    
    // 使用 map 遍历数组
    var newArr = arr.map(function(item, index, arr) {
        // item 就是数组中的每一项
        // index 就是数组的索引
        // arr 就是原始数组
        return item + 10
    })
    
    console.log(newArr) // [11, 12, 13]

#### 数组常用方法之 filter ####

作用：和 map 的使用方式类似，按照我们的条件来筛选数组

语法：arr.filter(function (item, index, arr) \{\})

返回值：把原始数组中满足条件的筛选出来，组成一个新的数组返回

var arr = [1, 2, 3]
    
    // 使用 filter 过滤数组
    var newArr = arr.filter(function(item, index, arr) {
        // item 就是数组中的每一项
        // index 就是数组的索引
        // arr 就是原始数组
        return item > 1
    })
    
    console.log(newArr) // [2, 3]

我们设置的条件就是 > 1，返回的新数组就会是原始数组中所有 > 1 的项

#### 数组常用方法之 every ####

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

语法：arr.every(function (item, index, arr) \{\})

返回值：一个布尔值

*  如果数组中每一个都满足条件, 那么返回值 true
 *  只要数组中任何一个不满足条件, 那么返回 false

判断条件以 return 的形式书写

var arr = [100, 200, 300, 400, 500]
    console.log('原始数组 : ', arr)
    
    var res = arr.every(function(item, index, srr) {
        console.log(item)
        console.log(index);
        // 以 return 的形式书写 判断 条件
        return item < 500
    
        // return index > 6
    })
    
    console.log('返回值 : ', res) //false

#### 数组常用方法之 some ####

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

语法：arr.some(function (item, index, arr) \{\})

返回值：一个布尔值

*  如果数组中有任何一个满足条件, 那么返回 true
 *  只有数组中所有的都不满足条件, 才会返回 false

var arr = [100, 200, 300, 400, 500]
    console.log(arr)
    
    var res = arr.some(function(item, index, arr) {
        console.log(item);
        console.log(index);
    
        // 以 return 的形式书写 判断 条件
        return item < 50
    
        // return index > 6
    })
    
    console.log(res) //false

#### 数组常用方法之 reduce ####

作用：进行叠加累计，函数根据数组中的成员进行重复调用

语法：arr.reduce(function (prev, item, index, arr) \{\}, 初始值)

*  prev: 初始值 或 每一次叠加后的结果
 *  item: 每一项
 *  index: 索引
 *  arr: 原始数组

初始值: 默认是数组索引 0 位置数据, 表示从什么位置开始叠加

返回值：返回最终的结果

var arr = [100, 200, 300, 400, 500]
    console.log(arr)
    
    var res = arr.reduce(function a(prev, item, index, arr) {
        console.log(prev);
        console.log(item);
        console.log(index);
        // 以 return 的形式书写每次的叠加条件
        return prev + item
    }, 0)
    
    console.log(res)

#### 数组常用方法之 find ####

作用：查找数组中某一个数据

语法：arr.find(function (item, index, arr) \{\})

返回值：数组中你查找到的该数据。

查找条件以 return 的形式书写

var arr = [100, 200, 301, 400, 500]
    console.log(arr)
    
    // 我想找到原始数组中的哪一个 奇数
    var res = arr.find(function(item, index, arr) {
        console.log(item);
        console.log(index);
    
        // 以 return 的形式书写查找条件
        return item % 2 === 1
    })
    
    console.log(res)

#### 数组常用方法之 findIndex ####

作用：查找数组中某一个数据

语法：arr.findIndex(function (item, index, arr) \{\})

返回值：数组中你查找到的该数据所在的索引位置。

查找条件以 return 的形式书写

以上就是JavaScript中数组常用的方法汇总。你平时都用哪些方法呢？欢迎留言讨论哟！