数组常用方法汇总

最新推荐文章于 2023-03-01 17:12:58 发布
最新推荐文章于 2023-03-01 17:12:58 发布
阅读量324 收藏 2
点赞数
分类专栏： 技术贴 文章标签： JavaScript 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fannnnnn/article/details/90678640
版权

数组常用方法

基础

join

将数组中的元素转化为字符串并连接在一起，默认以逗号分隔元素，可以自定义分隔符，返回最终连接在一起的字符串。

    var arr = [1,2,3,4];
    console.log(arr.join());    // 打印："1,2,3,4,"。默认使用逗号隔开。
    var arr = [1,2,3,4];
    console.log(arr.join("-")); // 打印："1-2-3-4"。指定只用"-"隔开。
    var arr = [1,2,3,4];
    console.log(arr.join(""));  // 打印："1234"。使用空字符串时，字符之间没有分隔符。
    -------------------------------------------------------------------------
    var arr = [1,2,3,[4,5,6]];
    console.log(arr.join());   // 打印："1,2,3,4,5,6"。多维数组，会保留其中的逗号。
    var arr = [1,2,3,[4,5,6]];
    console.log(arr.join("")); // 打印："1234,5,6"。多维数组，会保留其中的逗号。
    var arr = [1,2,3,[4,5,6]];
    console.log(arr.jon("-")); // 打印："1-2-3-4,5,6"。多维数组，会保留其中的逗号。

reverse

将数组中的元素颠倒顺序，并返回改变后的数组。

var arr = [1,2,3];
console.log(arr.reverse()); // 打印：[3,2,1]。改变原数组。

sort

将数组中的元素排序并返回排序后的数组,默认按照元素字母顺序。

自定义排序规则：
1.返回 > 0，第一个参数应该在第二个参数后面；
2.返回 < 0，第一个参数应该在第二个参数前面；
3.返回 = 0，位置不变

var arr = [2,1,3];
console.log(arr.sort());    // 打印：[1,2,3]。改变原数组。
-------------------------------------------------------------------------
var arr = [undefined,2,1,'A'];
console.log(arr.sort()); // 打印：[1,2,'A',undefined]。当数组中存在undefined时，排序后会将undefined放到数组的最后。
-------------------------------------------------------------------------
var arr = [33,4,1111,222];
console.log(arr.sort()); // 打印：[1111,222,33,4]。由于没有指明compareFunction，因此在比较时，数字会先被转换为字符串然后再做比较。
arr.sort(function(a,b){
    return a - b;
})
console.log(arr);       // 打印：[4,33,222,1111]。
arr.sort(function(a,b){
    return b - a;
})
console.log(arr);      // 打印：[1111,222,33,4]。

concat

用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。

var arr = [1,2,3];
console.log(arr.concat(4,5,6));           // 打印：[1,2,3,4,5,6]。
var arr = [1,2,3];
console.log(arr.concat([4,5,6]));         // 打印：[1,2,3,4,5,6]。
var arr = [1,2,3];
console.log(arr.concat([4,5],[6,7]));     // 打印：[1,2,3,4,5,6,7]。
var arr = [1,2,3];
console.log(arr.concat([4,5,6,[7,8,9]])); // 打印：[1,2,3,4,5,6,[7,8,9]]。

slice

返回指定数组的一个片段或子数组。它的两个参数分别表示开始位置和结束位置，但不包括结束位置上的元素。

var arr = [1,2,3,4,5];
console.log(arr.slice(1,3)); // 打印：[2,3]。
var arr = [1,2,3,4,5];
console.log(arr.slice(3));   // 打印：[4,5]。

splice

删除现有元素和/或添加新元素来修改数组,并返回原数组中被修改的内容。

var arr = [1,2,3,4];
console.log(arr.splice(2));         // 打印：[3,4]，此时arr=[1,2]。
var arr = [1,2,3,4];
console.log(arr.splice(1,2));       // 打印：[2,3]，此时arr=[1,4]。
var arr = [1,2,3,4];
console.log(arr.splice(0,0,5,6));   // 打印：[]，此时arr=[5,6,1,2,3,4]。
var arr = [1,2,3,4];
console.log(arr.splice(0,0,[5,6])); // 打印：[]，此时arr=[[5,6],1,2,3,4]。splice()会插入数组本身并非数组中的元素，此特性与 concat()不同。

push

在数组末尾插入一个或多个元素，并返回数组新的长度。

var arr = [1,2];
console.log(arr.push(3));     // 打印：3，此时arr=[1,2,3]。
var arr = [1,2];
console.log(arr.push(3,4,5)); // 打印：5，此时arr=[1,2,3,4,5]。

pop

删除数组末尾一个元素，返回被删除的元素，改变数组长度。

var arr = [1,2,3,4,5];
console.log(arr.pop());     // 打印：5，此时arr=[1,2,3,4]。

unshift

在数组的头部插入一个或多个元素并返回数组新的长度。

var arr = [];
console.log(arr.unshift(1));     // 打印：1，此时arr=[1]。
var arr = [];
console.log(arr.unshift(1,2,3)); // 打印：3，此时arr=[1,2,3]。

shift

在数组的头部删除一个元素，返回被删除的元素，改变数组长度。

var arr = [1,2];
console.log(arr.shift());     // 打印：1，此时arr=[2]。

toString

将每个元素转换为字符串，并且输出用逗号分隔的字符串列表。与不使用任何参数调用join()方法返回的字符串一样。

var arr = [1,2,3,4,5];
console.log(arr.toString());  // 打印："1,2,3,4,5"。

ES5新增

isArray

用来判断一个对象是否为数组

console.log(Array.isArray([1, 2, 3]));  // 打印：true。
console.log(Array.isArray({foo: 123})); // 打印：false。
console.log(Array.isArray("foobar"));   // 打印：false。
console.log(Array.isArray(undefined));  // 打印：false。

indexOf

返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。查找顺序：从前往后。

var arr = ['apple', 'banana', 'pear'];
console.log(arr.indexOf('pear'))      // 打印：2。
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear'];
console.log(arr.indexOf('pear', 1))   // 打印：2。从数组第2个位置开始查找
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear'];
console.log(arr.indexOf('pear', 10))  // 打印：2。当查询位置大于或等于数组长度时，返回-1，不查找数组。
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear'];
console.log(arr.indexOf('pear', -2))  // 打印：2。其中-2表示从倒数第二个位置开始查找。若不改变查询顺序，还是默认按照从前往后查找。

lastIndexOf

返回在数组中可以找到一个给定元素的最后一个索引，如果不存在，则返回-1。查找顺序：从后往前。

var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.lastIndexOf('apple')) // 打印：3。
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.indexOf('apple', 1)) // 打印：0。从数组第2个位置开始先前查找
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.indexOf('apple', 10)) // 打印：3。其中10大于数组长度，则查找整个数组
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.indexOf('apple', -2)) // 打印：3。其中-2表示从数组末尾向前的偏移量。查找顺序还是从后往前。
-------------------------------------------------------------------------
var arr = ['apple', 'banana', 'pear', 'apple'];
console.log(arr.indexOf('apple', -10)) // 打印：-1。当负数的绝对值大于数组长度时，会返回-1，不查找数组。

every

检测数组中所有元素是否满足条件

var arr = [11, 24, 35, 30];
var result = arr.every(function(item) {
    return item > 10;
});
console.info(result); // 打印：true。检测数组中每个数字是否大于10
-------------------------------------------------------------------------
var arr = [11, 24, 35, 30];
arr[10] = 40;
var result = arr.every(function(item, index) {
    console.info(index);
    return item > 10;
});
console.info(result); // 打印：0,1,2,3,10,true。every只会为被赋了值的索引调用回调函数。

some

检测数组中是否有一个元素满足条件

var arr= [1, 5, -3, 4, 7];
var result = arr.some(function(item, index) {
    return item < 0;
});
console.info(result); // 打印：true。检测数组中是否存在小于0的数字

forEach

对数组中每个元素执行特定的方法

var arr = ['a', 'b', 'c', 'd'];
arr.forEach(function(item){
    console.info(item);
}); // 总是返回undefined，且不可中止或跳出forEach循环，除了抛出异常。

map

对数组中每个元素进行一定的操作后，返回新的数组

var arr = [2, 4, 6, 8, 10];
var newArr = arr.map(function(item) {
    return item * 2;
});
console.log(newArr); // 打印：3，8，12，16，20。

filter

对数组中每一个元素进行条件筛选，返回新的数组

var arr = [1,2,3,4,5,6,7];
var newArr = arr.filter(function(item) {
    return item % 2 === 0;
});
console.log(newArr);

reduce

对数组中每个元素执行特定的方法，最终返回累计处理的结果。升序

var arr = [1, 2, 3, 4];
var count = arr.reduce(function(accumulator, currentValue) {
    return accumulator + currentValue;
});
console.log(count); // 打印：10。accumulate：累计器。currentValue：当前值。按照升序执行回调函数，并且若没有提供initialValue时，第一次执行函数时，accumulator为数组第一个元素，currentValue为第二个元素。此后，accumulator为每次的累计值。
-------------------------------------------------------------------------
var arr = [1, 2, 3, 4];
var count = arr.reduce(function(accumulator, currentValue) {
    return accumulator + currentValue;
}, 5);
console.log(count); // 打印：15。此处提供了一个initialValue值，作为第一次执行函数时的accumulator的值。

reduceRight

对数组中每个元素执行特定的方法，最终返回累计处理的结果。降序

var arr = [[0, 1], [2, 3], [4, 5], [6, 7]];
var arr2 = arr.reduceRight(function(accumulator, currentValue) {
    return accumulator.concat(currentValue);
});
console.log(arr2); // 打印：[6, 7, 4, 5, 2, 3, 0, 1]。用法与reduce一样
fannnnnn
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前端必会的数组常用方法
m0_62877814的博客
11-26 701
前端必会的数组常用方法
数组常用的函数
m0_74331185的博客
10-18 2437
数组常用函数js
数组的常用方法大全
热门推荐
U_Are_My_Halo的博客
04-15 6万+
数组的方法 1. join (原数组不受影响) ​ 该方法可以将数组里的元素,通过指定的分隔符,以字符串的形式连接起来。 返回值:返回一个新的字符串 //将数组用 - 符号连接起来 let arr = [1,2,3,4,5]; let str = arr.join('-'); console.log(str)//str = 1-2-3-4-5; 2. split (原数组不受影响) ​ 该方法是......
数组的方法总结
qq_62793369的博客
03-01 224
1.concat方法 2.every() 方法 3.filter() 方法 4.fill() 方法 5.find() 方法 6.findIndex() 方法 7.forEach() 方法 8.includes() 方法 9.indexOf() 方法 10.isArray() 方法 11.join() 方法 12.lastIndexOf()方法 13.map() 方法 14.pop() 方法 15.push() 方法 16.reverse() 方法 17.shift() 方
数组的常用方法（函数）
qq_60837087的博客
10-19 8033
数组的常用方法（函数）
数组常用方法整理
H_carrot的博客
09-15 253
1、arr.push () 往数组最后的位置追加元素，并返回新数组的长度 2、arr.unshift() 数组最前面追加，返回新数组的长度 3、arr.pop( ) 删除数组中最后一个元素，并返回该元素的值 4、arr.shift( ) 删除数组中第一个元素，并返回该元素的值 5、arr.splice(起始位置，删除的个数) 如果省略删除个数默认从指定的起始位置删除直到最后 6、concat() 连接多个数组成为新数组 7、reverse() 反转数组顺序返
Javscript数组的常用方法有哪些？
铁锤妹妹的博客
03-16 1729
数组基本操作可以归纳为 增、删、改、查，需要留意的是哪些方法会对原数组产生影响，哪些方法不会 下面对数组常用的操作方法做一个归纳 增 下面前三种是对原数组产生影响的增添方法，第四种则不会对原数组产生影响 push() unshift() splice() concat() push() push()方法接收任意数量的参数，并将它们添加到数组末尾，返回数组的最新长度 let colors = []; // 创建一个数组 let count = colors.push("red", "green"); /.
数组有哪些常用方法
SpringRolls的博客
05-17 2276
答案： push 末尾添加 pop 末尾删除 shift 首部删除 unshift 首部添加 concat 数组合并 join 数组元素 通过连接符 连接 reverse 数组反转 sort 数组排序 map/forEach/filter/indexOf/includes/slice/splice 详细解析： 1.　Array.push()，向数组的末尾添加一个或多个元素，并返回新的数组长度。原数组改变。 .
数组的常用方法总结
lx_curry的博客
06-12 1154
将数组转化成字符串，每一项元素用逗号隔开 split() 将字符串转化为数组，括号内的参数为分隔符。 二、Array.join() join() 方法接收一个参数，即字符串分隔符，返回包含所有项的字符串 三、Array.shift() shift()方法用于删除数组的第一项，同时减少数组的length 值，返回被删除的项 四、Array.reverse()和Array.sort() reverse() 数组的反转，会改变原数组 sort() sort()方法接受一个比较函数，用于判断哪个值应该排在前面 五、
数组常用方法
a895544608的博客
04-01 8524
一、 改变原数组的方法 （常用） push : 尾部追加 (向数组的尾部添加一个或多个元素，返回值是数组的长度） unshift : 头部添加 (向数组的头部添加一个或多个元素，并返回数组长度) pop : 尾部删除 (删除数组最后一个元素） shift : 头部删除 (删除数组第一个元素） sort: : 排序 (对数组元素进行排序) join : 分隔 (将数组的每一项通过自己指定的字符进行拼接、默认连接为 ",") reverse : 反转 (将数组进行倒序) spli...
最全数组方法，最简单易懂，数组方法大全
weixin_46547740的博客
10-22 6373
常用数组： pop：原数组变，返回删除的元素 push：原素组变 shift：原数组变，返回删除的元素 unshift：原素组变 slice：返回新数组，截取索引开始，结束 splice：原数组变，返回截取的新数组，截取索引开始，长度，截取位插入值 reverse：原数组改变颠倒位置 sort：原数组改变大小排序 join：数组变为字符串（可加分隔符） concat：返回拼接的新数组 ES5新增： indexOf（）字符串、数组统用，返回指定字符首次出现的位置（索引值），返回这个索引值，否则返回-1 for
数组方法总结（最全）
DJ老邓的博客
01-21 2160
文章目录一、什么是数组二、数组中的方法1. join()2. push()和pop()3. shift() 和 unshift()4. sort()5. reverse()6. concat()7. slice()8. splice()9. indexOf()和 lastIndexOf() （ES5新增）10. forEach() （ES5新增）11. map() （ES5新增）12. filter() （ES5新增）13. every() （ES5新增）14. some() （ES5新增）总结 一、
使用Java将数组中的元素拼接（以某个字符串作为分隔符）
博客----
02-06 1万+
public String splicingElement(String[] elements, int size, String regex) { String ret = ""; for (int i = 0; i &lt; size; i++) { if (i &lt; size - 1) ret += elements[i] + regex; else { ...
将数组中所有的元素转换为由分隔符分隔的字符串
Wangdanting123的博客
07-27 1067
/** * 将array中所有的元素转换为由separator分隔的字符串 * Converts all elements in `array` into a string separated by `separator` * * @param {Array} array The array to convert * @param {string} [separator=','] Th...
数组常用的方法（17个）
辰俊
11-06 1万+
**数组常用方法** isArrary() 判断参数是不是数组，返回布尔值-----Array.isArrary() var arrs = [1, 2, 3, 13, 1] if (Array.isArray(arrs)) { //该方法返回一个布尔类型函数---true/false console.log(`arrs该参数是一个数组`) //返回该结果 } else { console.log(`该参数不是一个数...
数组
weixin_46579258的博客
04-29 136
什么是数组 创建数组 操作数组 数组的索引 数组的方法 一些API 数组的分类
JavaScript的20个数组方法详细用法说明
LoveYouZsw的博客
04-17 680
一、删除和插入数据的四个方法 1.push() 数组最后位置压入数据，返回新数组的长度 2.pop() 数组最后位置弹出最后一个元素，返回值是弹出的元素 3.shift() 数组开始位置删除第一位数据，返回值是删除的元素 4.unshift() 数组开始位置插入一个元素，返回新数组的长度 总结： 第一个相同点四个方法是相对应来记的，俩开始方法，俩结束方法，从汉语意思来记，push中文意思压入，pop中文弹出，shift中文移动，引申为移出、删除，unshift则就是插入。 第二个相同的地方是，这四个方法中
JavaScript数组方法总结
小瑾沐晚风的博客
09-25 3万+
一.JavaScript中创建数组的方式 1.使用Array构造函数 var color=new Array();     注意：括号里面参数可以有参数，若为一个数字，表示该数组的长度，如果为多个数字或者一个（多个）非数字表示的是传递数组中应该包含的值。 2.使用数组字面量 var color=[]; 二. 数组的长度 三.数组的方法有数组原型方法，也有从object对象继承来的...
js数组汇总方法md文档·
最新发布
06-06
以下是一些常用的 JavaScript 数组方法： 1. push()：向数组末尾添加一个或多个元素。 2. pop()：从数组末尾删除最后一个元素。 3. shift()：从数组开头删除第一个元素。 4. unshift()：向数组开头添加一个或多...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值