15个必须知道的JavaScript数组方法

 在JavaScript中，数组是一个特殊的变量，用于存储不同的元素。它具有一些内置属性和方法，可用于根据需要添加，删除，迭代或操作数。并且了解JavaScript数组方法可以提升你的开发技能。

创新互联专业为企业提供怀安网站建设、怀安做网站、怀安网站设计、怀安网站制作等企业网站建设、网页设计与制作、怀安企业网站模板建站服务，十年怀安做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

在本文中，我们将介绍15种关于JavaScript的数组方法，这些方法可以帮助你正确地处理数据。

  •  1.some（）
  •  2. reduce（）
  •  3. Every（）
  •  4. map（）
  •  5. flat（）
  •  6. filter（）
  •  7. forEach（）
  •  8. findIndex（）
  •  9. find（）
  •  10. sort（）
  •  11. concat（）
  •  12. fill（）
  •  13. includes（）
  •  14. reverse（）
  •  15. flatMap（）

注意，大多数情况下，我们将简化作为参数传递的函数。

 
 
 
 
    
  
  
  
  
  1. // Instead of using this waymyAwesomeArray.some(test => {  if (test === "d") {    return test  }})// We'll use the shorter onemyAwesomeArray.some(test => test === "d")
    2.

1、some()

此方法为参数传递的函数测试数组。如果有一个元素与测试元素匹配，则返回true，否则返回false。

译者注： some() 不会对空数组进行检测；some() 不会改变原始数组。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = ["a", "b", "c", "d", "e"] 
    2. 
  
  
  
  
  2. myAwesomeArray.some(test => test === "d") 
    3. 
  
  
  
  
  3. //-------> Output : true
    4.

2、reduce（）

此方法接收一个函数作为累加器。它为数组中的每个元素依次执行回调函数，不包括数组中被删除或者从未被赋值的元素。函数应用于累加器，数组中的每个值最后只返回一个值。

译者注：reduce() 方法接受四个参数：初始值（上一次回调的返回值），当前元素值，当前索引，原数组。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [1, 2, 3, 4, 5] 
    2. 
  
  
  
  
  2. myAwesomeArray.reduce((total, value) => total * value) 
    3. 
  
  
  
  
  3. // 1 * 2 * 3 * 4 * 5 
    4. 
  
  
  
  
  4. //-------> Output = 120
    5.

3、Every（）

此方法是对数组中每项运行给定函数，如果数组的每个元素都与测试匹配，则返回true，反之则返回false。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = ["a", "b", "c", "d", "e"] 
    2. 
  
  
  
  
  2. myAwesomeArray.every(test => test === "d") 
    3. 
  
  
  
  
  3. // -------> Output : falseconst myAwesomeArray2 = ["a", "a", "a", "a", "a"] 
    4. 
  
  
  
  
  4. myAwesomeArray2.every(test => test === "a") 
    5. 
  
  
  
  
  5. //-------> Output : true
    6.

4、map（）

该方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。它按照原始数组元素顺序依次处理元素。

译者注：map() 不会对空数组进行检测；map() 不会改变原始数组。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [5, 4, 3, 2, 1]myAwesomeArray.map(x => x * x) 
    2. 
  
  
  
  
  2. //-------> Output : 25 
    3. 
  
  
  
  
  3. //                  16 
    4. 
  
  
  
  
  4. //                  9 
    5. 
  
  
  
  
  5. //                  4 
    6. 
  
  
  
  
  6. //                  1
    7.

5、flat（）

此方法创建一个新数组，其中包含子数组上的holden元素，并将其平整到新数组中。请注意，此方法只能进行一个级别的深度。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [[1, 2], [3, 4], 5] 
    2. 
  
  
  
  
  2. myAwesomeArray.flat() 
    3. 
  
  
  
  
  3. //-------> Output : [1, 2, 3, 4, 5]
    4.

6、filter（）

该方法接收一个函数作为参数。并返回一个新数组，该数组包含该数组的所有元素，作为参数传递的过滤函数对其返回true。

译者注：filter（）方法是对数据中的元素进行过滤，也就是说是不能修改原数组中的数据，只能读取原数组中的数据，callback需要返回布尔值；为true的时候，对应的元素留下来；为false的时候，对应的元素过滤掉。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [  { id: 1, name: "john" },   
    2. 
  
  
  
  
  2. { id: 2, name: "Ali" },  { id: 3, name: "Mass" },   
    3. 
  
  
  
  
  3. { id: 4, name: "Mass" },] 
    4. 
  
  
  
  
  4. myAwesomeArray.filter(element => element.name === "Mass") 
    5. 
  
  
  
  
  5. //-------> Output : 0:{id: 3, name: "Mass"}, 
    6. 
  
  
  
  
  6. //                  1:{id: 4, name: "Mass"}
    7.

7、forEach（）

此方法用于调用数组的每个元素。并将元素传递给回调函数。

译者注: forEach() 对于空数组是不会执行回调函数的。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [  { id: 1, name: "john" },   
    2. 
  
  
  
  
  2. { id: 2, name: "Ali" },  { id: 3, name: "Mass" },] 
    3. 
  
  
  
  
  3. myAwesomeArray.forEach(element => console.log(element.name)) 
    4. 
  
  
  
  
  4. //-------> Output : john 
    5. 
  
  
  
  
  5. //                  Ali 
    6. 
  
  
  
  
  6. //                  Mass
    7.

8、 findIndex（）

此方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。它为数组中的每个元素都调用一次函数执行，当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。如果没有符合条件的元素返回 -1

译者注：findIndex() 对于空数组，函数是不会执行的， findIndex() 并没有改变数组的原始值。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [  { id: 1, name: "john" },  
    2. 
  
  
  
  
  2.  { id: 2, name: "Ali" },  { id: 3, name: "Mass" },]myAwesomeArray.findIndex(element => element.id === 3)// -------> Output : 2myAwesomeArray.findIndex(element => element.id === 7)//-------> Output : -1
    3.

9、 find（）

此方法返回通过测试（函数内判断）的数组的第一个元素的值。find() 方法为数组中的每个元素都调用一次函数执行：当数组中的元素在测试条件时回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。如果没有符合条件的元素返回 undefined。

译者注: find() 对于空数组，函数是不会执行的；find() 并没有改变数组的原始值。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [  { id: 1, name: "john" },  
    2. 
  
  
  
  
  2.  { id: 2, name: "Ali" },  { id: 3, name: "Mass" },] 
    3. 
  
  
  
  
  3.  myAwesomeArray.find(element => element.id === 3) 
    4. 
  
  
  
  
  4.  // -------> Output : {id: 3, name: "Mass"} 
    5. 
  
  
  
  
  5.  myAwesomeArray.find(element => element.id === 7) 
    6. 
  
  
  
  
  6.  //-------> Output : undefined
    7.

10、 sort（）

此方法接收一个函数作为参数。它对数组的元素进行排序并返回它。也可以使用含有参数的sort()方法进行排序。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [5, 4, 3, 2, 1] 
    2. 
  
  
  
  
  2. // Sort from smallest to largestmyAwesomeArray.sort((a, b) => a - b) 
    3. 
  
  
  
  
  3. //  -------> Output : [1, 2, 3, 4, 5] 
    4. 
  
  
  
  
  4. // Sort from largest to smallestmyAwesomeArray.sort((a, b) => b - a) 
    5. 
  
  
  
  
  5. //-------> Output : [5, 4, 3, 2, 1]
    6.

11、 concat（）

此方法用于连接两个或多个数组/值，它不会改变现有的数组。而仅仅返回被连接数组的一个新数组。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [1, 2, 3, 4, 5]const  
    2. 
  
  
  
  
  2. myAwesomeArray2 = [10, 20, 30, 40, 50] 
    3. 
  
  
  
  
  3. myAwesomeArray.concat(myAwesomeArray2) 
    4. 
  
  
  
  
  4. //-------> Output : [1, 2, 3, 4, 5, 10, 20, 30, 40, 50]
    5.

12、 fill（）

此方法的作用是使用一个固定值来替换数组中的元素。该固定值可以是字母、数字、字符串、数组等等。它还有两个可选参数，表示填充起来的开始位置（默认为0）与结束位置（默认为array.length）。

译者注：fill() 方法用于将一个固定值替换数组的元素。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [1, 2, 3, 4, 5] 
    2. 
  
  
  
  
  2. // The first argument (0) is the value 
    3. 
  
  
  
  
  3. // The second argument (1) is the starting index 
    4. 
  
  
  
  
  4. // The third argument (3) is the ending indexmyAwesomeArray.fill(0, 1, 3) 
    5. 
  
  
  
  
  5. //-------> Output : [1, 0, 0, 4, 5]
    6.

13、 includes（）

此方法用于判断字符串是否包含指定的子字符串。如果找到匹配的字符串则返回 true，否则返回 false。

译者注：includes() 方法区分大小写。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [1, 2, 3, 4, 5] 
    2. 
  
  
  
  
  2. myAwesomeArray.includes(3) 
    3. 
  
  
  
  
  3. // -------> Output : truemyAwesomeArray.includes(8) 
    4. 
  
  
  
  
  4. // -------> Output : false
    5.

14、 reverse（）

此方法用于颠倒数组中元素的顺序。第一个元素成为最后一个，最后一个元素将成为第一个。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = ["e", "d", "c", "b", "a"] 
    2. 
  
  
  
  
  2. myAwesomeArray.reverse() 
    3. 
  
  
  
  
  3. // -------> Output : ['a', 'b', 'c', 'd', 'e']
    4.

15、 flatMap（）

该方法将函数应用于数组的每个元素，然后将结果压缩为一个新数组。它在一个函数中结合了flat（）和map（）。

 
 
 
 
    
  
  
  
  
  1. const myAwesomeArray = [[1], [2], [3], [4], [5]] 
    2. 
  
  
  
  
  2. myAwesomeArray.flatMap(arr => arr * 10) 
    3. 
  
  
  
  
  3. //-------> Output : [10, 20, 30, 40, 50] 
    4. 
  
  
  
  
  4. // With .flat() and .map()myAwesomeArray.flat().map(arr => arr * 10) 
    5. 
  
  
  
  
  5. //-------> Output : [10, 20, 30, 40, 50] 
    6.

新闻名称：15个必须知道的JavaScript数组方法
文章转载：http://www.mswzjz.cn/qtweb/news39/303889.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 贝锐智能

贝锐智能技术为您推荐以下文章

微信小程序知识

同城分类信息

成都保温材料　　 　成都花箱厂家　　 　成都网站设计　　 　成都网站维护　　 　四川瑞杰　　 　西云主机托管　　 　成都定制网页设计　　 　力比特机械　　 　成都发电机维修　　 　服务器租凭　　 　重庆网络营销　　 　星宇光彩照明　　 　香港虚拟主机腾讯云　　 　创新互联重庆　　 　成都网站优化　　 　成都网站设计公司　　 　正泰动物　　 　成都枢纽中心　　 　成都网站推广　　 　草坪音箱