所有数组方法归纳

最新推荐文章于 2022-11-01 15:01:59 发布
最新推荐文章于 2022-11-01 15:01:59 发布
阅读量273 收藏 9
点赞数 9
分类专栏： HTML与css 文章标签： javascript 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48651355/article/details/121001491
版权

目录

1.1 join()

1.2 shift() 与 pop()

1.2.1 shift()

1.2.2 pop()

1.3 unshift() 与 push() 

1.3.1 unshift()

1.3.2 push()

1.4  sort()

1.5  reverse()

1.6 concat()

1.7 slice()

1.8  splice()

1.9 toString()

1.10 indexOf() 与 lastIndexOf() ------ES5新增

1.10.1 indexOf() 

1.10.2 lastIndexOf() 

1.11 forEach() ------ES5新增

1.12 some() ------ES5新增

1.13 map() ------ES5新增

1.14  filter() ------ES5新增

1.14  every() ------ES5新增

1.15 concat() ------ES5新增

1.16 copyWithin() ------ES6新增

1.17  entries() ------ES6新增

1.18  fill() ------ES6新增

1.19  find() 和 findIndex() ------ES6新增

1.19.1 find()

1.19.2 findIndex()

1.20  from() ------ES6新增

1.21 includes() ------ES6新增

1.22  keys() ------ES6新增

1.23  values() ------ES6新增

1.24 of() ------ES6新增

1.25 reduce() 和 reduceRight() ------ES6新增

1.25.1 reduce()

1.25.2 reduceRight()

1.26 flat() 和 flatMap() ------ES10新增

1.26.1 flat()

1.26.2  flatMap()

1.1 join()

        将数组以指定值去分隔，不指定值默认为逗号（,）

  • 语法：数组.join();
  • 返回值：分隔后的字符串
let arr = ['hello','friend']
let str1 = arr.join();
let str2 = arr.join('-')
console.log(str1);//hello,friend
console.log(str2);//hello-friend

注意： 不改变原始数组

1.2 shift() 与 pop()

1.2.1 shift()

        删除数组第一个数据

  • 语法：数组.shift()
  • 返回值：删除的数据
let arr = [1,2,3,4,5]
let str = arr.shift();
console.log(str);//1

注意：改变了原始数组（也就是说长度也被改变）

1.2.2 pop()

        删除数组最后一个数据

  • 语法：数组.pop()
  • 返回值：删除的数据
let arr = [1,2,3,4,5]
let str = arr.pop();
console.log(str);//5

注意：改变了原始数组（也就是说长度也被改变）

1.3 unshift() 与 push() 

1.3.1 unshift()

        将指定的数据添加到数组开头

  • 语法：数组.unshift(‘值1’,‘值2’)
  • 返回值：添加后新数组长度
let arr = ['l','l','o']
let str = arr.unshift('h','e');
console.log(str);//5

注意：改变了原始数组（也就是说长度也被改变）

1.3.2 push()

        将指定的数据添加到数组末尾

  • 语法：数组.push(‘值1’,‘值2’)
  • 返回值：添加后新数组长度
let arr = ['h','e','l']
let str = arr.push('l','o');
console.log(str);//5

注意：改变了原始数组（也就是说长度也被改变）

1.4  sort()

        对数组的数据进行排序（升序或者降序）

  • 语法：数组.sort(回调函数)
  • 返回值：排列好的数组
let arr = ['1','2','3',4,5]
let str2 = arr.sort(function(a,b){return a-b});
console.log(str2);//['1', '2', '3', 4, 5]

let arr = ['edit','banner','canner','die']
let str1 = arr.sort();
console.log(str1);//['banner', 'canner', 'die', 'edit']
console.log(arr);
  • 默认排序顺序是将元素转为字符串，然后比较的是它们的UTF-16代码单元值
  • 回调函数有两个参数用来进行判断（升序或降序排列）返回值小于0，a 会被排列到 b 之前；等于0，a 和 b 的相对位置不变；大于0，b 会被排列到 a 之前

注意：

  • 改变了原始数组顺序
  • 加了回调函数只能判断数字和字符串类型的数字（例如：‘7’，‘8’），像（‘abc’，‘a’，‘banner’）无法使用回调函数去排序。这种只能用不加回调函数的sort去升序，然后用reverse()来颠倒数组做降序

1.5  reverse()

        颠倒数组中的数据

  • 语法：数组.reverse(回调函数)
  • 返回值：颠倒后的数组
let arr = ['edit','banner','canner','die']
let str = arr.reverse();
console.log(str);//['die', 'canner', 'banner', 'edit']

注意：改变了原始数组

1.6 concat()

        连接两个数组

  • 语法：数组1.concat(数组2)
  • 返回值：连接后的新数组
let arr1 = ['edit','banner','canner','die']
let arr2 = [1,2,3]
let str1 = arr1.concat(arr2);
console.log(str1);//['edit', 'banner', 'canner', 'die', 1, 2, 3]

注意：没有改变原始数组（返回的是新数组）

1.7 slice()

        截取数组指定位置的数据（浅拷贝）

  • 语法：数组.slice(开始索引，结束索引)        不包括结束索引
  • 返回值：截取后的新数组
let arr = ['edit','banner','canner','die',1,2,3]
let str = arr.slice(1,3);
console.log(str);//['banner', 'canner']

注意：

  • 没有改变原始数组（返回的是新数组）
  • 截取的数据复制成新数组是浅拷贝不是深拷贝
  • 如果不声明开始索引和结束索引，截取的是整个数组；只给一个索引会当做是开始索引

1.8  splice()

        这个方法功能就比较多了，能删除、替换现有的元素或者添加新的元素到指定地方

  • 语法：数组.splice(索引，删除的个数，添加的数据) 
  • 返回值：根据第二个参数进行返回，返回类型为数组
//从下标为1的位置删除2个数据
let arr = ['edit','banner','canner','die',1,2,3]
let str = arr.splice(1,2);
console.log(str);//['banner', 'canner']

//将下标为1的元素替换为指定元素‘1’
let arr = ['edit','banner','canner','die',1,2,3]
let str = arr.splice(1,1,'1');
console.log(str);//['banner']

//在指定位置添加指定元素‘1’
let arr = ['edit','banner','canner','die',1,2,3]
let str = arr.splice(1,0,'1');
console.log(str);//[]

注意：改变了原始数组

1.9 toString()

        将数组转换字符串

  • 语法：数组.toString()
  • 返回值：转换后的字符串
    let arr = ['h','e','l','l','o']
    let str = arr.toString();
    console.log(str);//h,e,l,l,o

注意：没有改变原始数组

1.10 indexOf() 与 lastIndexOf() ------ES5新增

1.10.1 indexOf() 

        找到第一个给定元素的索引

  • 语法：数组.indexOf(‘查询的元素’,‘从哪个位置找’)
  • 返回值：查询到元素的索引，没查询到返回-1
    let arr = [1,2,3,1,2,4,5,6]
    let str1 =arr.indexOf(2);//1
    let str2 = arr.indexOf(2,2);//4
    console.log(str1,str2);

注意：

  • 没有改变原始数组
  • 如果第二个参数大于等于数组的长度就直接返回-1
  • 如果第二个参数为负数则从末尾开始抵消，-1即最后一个元素，-2即倒数第二个元素。知道指定位置后在往后查找。

1.10.2 lastIndexOf() 

        找到第一个给定元素的索引（从后往前）

  • 语法：数组.indexOf(‘查询的元素’,‘从此位置开始逆向查找’)
  • 返回值：查询到元素的索引，没查询到返回-1
    let arr = [1,2,3,1,2,4,5,2,6]
    let str1 =arr.lastIndexOf(2);//7
    let str2 = arr.lastIndexOf(2,4);//4
    console.log(str1,str2);

 查找机制 ：-1为最末尾的元素，如果第二个参数是-5，那么他会从后往前数第五个数据开始往前去找，例如

let arr = [1,2,3,1,2,4,5,2,6]
let str1 =arr.lastIndexOf(2);//7
let str2 = arr.lastIndexOf(2,-5);//4

注意： 

  • 没有改变原始数组
  • 该方法为逆向查找，注意第二个参数值

1.11 forEach() ------ES5新增

        遍历数组每个元素，并执行给定函数

  • 语法：数组.forEach(回调函数( '处理的元素' , '下标' , '数组本身'){},回调函数使用的this值)
  • 返回值：undefined
    let arr = [1,2,3,4,5]
    let str = arr.forEach(function(value,index,arr){console.log(value,index);});
    console.log(str);//undefined

注意：没有改变原始数组

1.12 some() ------ES5新增

        遍历数组找到符合要求的数据

  • 语法：数组.some(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
  • 返回值：布尔值
let arr = [1,2,3,4,5,6]
let str = arr.some(function(a,index,arr){console.log(index,arr);return a%2===0 ;});
console.log(str);//true

//下标即index参数，会返回从0下标到符合值的下标，是可选参数
//数组本身即arr，会返回原数组，为可选参数
//回调函数this值也为可选参数

注意：没有改变原始数组

1.13 map() ------ES5新增

        遍历数组执行指定的回调函数

  • 语法：数组.map(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
  • 返回值：每个元素执行完回调函数返回的结果组成的新数组
    let arr = [1,2,3,4,5]
    let str = arr.map(function(value,index,arr){console.log(value,index); return value>3});
    console.log(str);//[false, false, false, true, true]

注意：没有改变原始数组

1.14  filter() ------ES5新增

        筛选出数组中想要的数据

  • 语法：数组.filter(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
  • 返回值：返回一个通过测试即通过回调函数的新数组
    let arr = [1,2,3,4,5]
    let str = arr.filter(function(value,index,arr){console.log(value,index); return value>3});
    console.log(str);//[4, 5]

注意：没有改变原始数组

1.14  every() ------ES5新增

        判断数组所有元素是不是都能通过回调函数规则

  • 语法：数组.every(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
  • 返回值：布尔值
    let arr = [1,2,3,4,5]
    let str = arr.every(function(value,index,arr){console.log(value,index); return value>3});
    console.log(str);//false

注意：没有改变原始数组

1.15 concat() ------ES5新增

        用于合并两个数组的数据

  • 语法：数组.concat(值1，值2，值3)
  • 返回值：数组
    let arr1 = [1,2,3,4,5];
    let arr2 = [6,7,8,9]
    let str = arr1.concat(arr2);
    console.log(str);//[1, 2, 3, 4, 5, 6, 7, 8, 9，0]

注意：没有改变原始数组

1.16 copyWithin() ------ES6新增

        复制数组的一部分然后放到同一数组的某个位置

  • 语法：数组.copyWithin(插入的索引 , 复制开始索引 , 复制结束索引)
  • 返回值：改变后的数组
    let arr = [1, 2, 3, 4, 5];
    let str = arr.copyWithin(1,3,4);//这个就是从索引3开始复制到索引4（不包括），然后添加到索引为1的位置
    console.log(str); //[1, 4, 3, 4, 5]

注意：

  • 改变了原始数组
  • 参数一为必选，其他参数为可选（只有一个参数就是添加到指定索引，复制是整个数组；两个参数，第二个参数是开始复制索引，没有第三个参数会从开始索引复制到数组最后一个元素）
  • 复制添加后整个数组的长度不变，所以就会导致复制添加的元素长度大于指定索引到数组最后一个元素索引的话，就会使复制添加元素后面几个元素被忽略（代码如下）
    let arr = [1, 2, 3, 4, 5];
    let str = arr.copyWithin(2,0,4);
    console.log(str); //[1, 2, 1, 2, 3]  复制的是整个数组，但是添加到数组的只有1,2,3

1.17  entries() ------ES6新增

        返回一个新的Array Iterator对象

  • 语法：数组.entries()
  • 返回值：新的Array Iterator对象
    let arr = [1, 2, 3, 4, 5];
    let str = arr.entries();
    let str1 = str.next().value
    let str2 = str.next().value;
    console.log(str);//Array Iterator {}
    console.log(str1,str2); //(2) [0, 1] (2) [1, 2]

注意：没有改变原始数组

1.18  fill() ------ES6新增

        向数组中某一段位置填充指定数据

  • 语法：数组.fill( 填充的数据, 开始索引 , 结束索引)
  • 返回值：改变后的数组
    let arr = [1, 2, 3, 4, 5];
    let str = arr.fill(6,2,4);
    console.log(str); //[1, 2, 6, 6, 5]

//不包含结束索引
//不指定开始结束索引会填充整个数组
//不指定结束索引会从开始索引填充到数组最后一个元素

注意：改变了原始数组

1.19  find() 和 findIndex() ------ES6新增

1.19.1 find()

        找到数组中满足回调函数的第一个元素

  • 语法：数组.find( 回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
  • 返回值：满足条件的元素（没有返回undefined）
    let arr = [1, 2, 3, 4, 5];
    let str = arr.find((function(value,index,arr){console.log(value,index); return value>3}));
    console.log(str); //4

注意：没有改变原始数组

1.19.2 findIndex()

        找到数组中满足回调函数的第一个元素的索引

  • 语法：数组.findIndex( 回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
  • 返回值：满足条件的第一个元素的索引（没有返回-1）
    let arr = [1, 2, 3, 4, 5];
    let str = arr.findIndex((function(value,index,arr){console.log(value,index); return value>3}));
    console.log(str); //3

注意：没有改变原始数组

1.20  from() ------ES6新增

        将伪数组或可迭代对象经过指定处理转为一个新数组

  • 语法：Array.from( 伪数组 , 回调函数 , 回调函数使用的this值)
  • 返回值：处理后的新数组
    let str1 = Array.from('12345');//['1', '2', '3', '4', '5']
    let str2 = Array.from([1,2,3],(function(value,index,arr){console.log(value,index); return value*=3}))//[3, 6, 9]

1.21 includes() ------ES6新增

        判断数组中是否包含指定的数据

  • 语法：数组.includes(查找的元素 , 从哪开始找)
  • 返回值：布尔值
    let arr = [1, 2, 3, 4, 5];
    let str = arr.includes(3)
    console.log(str); //true

注意：没有改变原始数组

1.22  keys() ------ES6新增

        返回一个包含数组中每个索引键的Array Iterator对象

  • 语法：数组.keys()
  • 返回值：新的Array Iterator对象
    let arr = [1, 2, 3, 4, 5];
    let str = arr.keys();
    for (const key of str) {
      console.log(key); //0,1,2,3,4
    }
    console.log(str);//Array Iterator {}

注意：没有改变原始数组

1.23  values() ------ES6新增

         返回一个包含数组中每个索引值的Array Iterator对象

  • 语法：数组.values()
  • 返回值：新的Array Iterator对象
    let arr = [1, 2, 3, 4, 5];
    let str = arr.values();
    for (const value of str) {
      console.log(value); //1,2,3,4,5
    }
    console.log(str);//Array Iterator {}

注意：没有改变原始数组

1.24 of() ------ES6新增

        创建一个包含指定元素的数组

  • 语法：Array.of(值1 , 值2 , 值3)
  • 返回值：数组
    let str = Array.of(7,6,5,4,3,2,1)
    console.log(str);//[7, 6, 5, 4, 3, 2, 1]

注意：Array(5)是创建一个长度为5的空数组，Array.of(5)是创建一个数组包含一个元素5

 1.25 reduce() 和 reduceRight() ------ES6新增

1.25.1 reduce()

        数组求和

  • 语法：数组.reduce(回调函数(累加器，处理的元素，下标，数组本身){},首次累加器的值)
  • 返回值：累加器处理的结果
    let arr = [1, 2, 3, 4, 5];
    let str = arr.reduce(function(sum,value,index){console.log(sum,value,index); return sum+=value},0)
    console.log(str);//15

注意：没有改变原始数组

1.25.2 reduceRight()

        与reduce用法相同，从后往前累加求和

1.26 flat() 和 flatMap() ------ES10新增

1.26.1 flat()

        深度递归，扁平化数组

  • 语法：数组.flat(提取嵌套的深度，默认为1)
  • 返回值：扁平化后新数组
    let arr = [1, [2, 3, 4], 5];
    let str = arr.flat();
    console.log(str);//[1, 2, 3, 4, 5]


    let arr = [1, [[2, 3], 4], 5];
    let str1 = arr.flat();
    let str2 = arr.flat(2);
    console.log(str1);//[1, Array(2), 4, 5]
    console.log(str2);//[1, 2, 3, 4, 5]

注意：没有改变原始数组

1.26.2  flatMap()

        数组每个元素执行回调函数，相当于执行map方法，然后返回值在执行flat方法

  • 语法：数组.flatMap(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
  • 返回值：新数组
    let arr = [1, [2, 3, 4], 5];
    let str = arr.flatMap(function(value,index){console.log(value,index); return value*2});
    console.log(str);//[2, NaN, 10] 这个NaN是下标为1的数组乘2的结果

注意：没有改变原始数组

总结： 

方法语法是否改变数组版本
jion()数组.join()否ES5以下
shift()与pop()数组.shift()
数组.pop()		是ES5以下
unshift()与push()数组.unshift(‘值1’,‘值2’)
数组.push(‘值1’,‘值2’)		是ES5以下
sort()数组.sort(回调函数)是ES5以下
reverse()数组.reverse(回调函数)是ES5以下
concat()数组1.concat(数组2)否ES5以下
slice()数组.slice(开始索引，结束索引) 否ES5以下
splice()数组.splice(索引，删除的个数，添加的数据) 是ES5以下
toString()数组.toString()否ES5以下
indexOf()与lastIndexOf()数组.indexOf(‘查询的元素’,‘从哪个位置找’)
数组.indexOf(‘查询的元素’,‘从此位置开始逆向查找’)		否ES5
forEach()数组.forEach(回调函数( '处理的元素' , '下标' , '数组本身'){},回调函数使用的this值)否ES5
some()数组.some(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)否ES5
map()数组.map(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)否ES5
filter()数组.filter(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)否ES5
every()数组.every(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)否ES5
concat()数组.concat(值1，值2，值3)否ES5
copyWithin()数组.copyWithin(插入的索引 , 复制开始索引 , 复制结束索引)是ES6
entried()数组.entries()否ES6
fill()数组.fill( 填充的数据, 开始索引 , 结束索引)是ES6
find()与findIndex()数组.find( 回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)
数组.findIndex( 回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)		否ES6
from()Array.from( 伪数组 , 回调函数 , 回调函数使用的this值)ES6
includes()数组.includes(查找的元素 , 从哪开始找)否ES6
keys()与value()数组.keys()
数组.values()		否ES6
of()Array.of(值1 , 值2 , 值3)ES6
reduce()与reduceRight()数组.reduce(回调函数(累加器，处理的元素，下标，数组本身){},首次累加器的值)
数组.reduceRight(回调函数(累加器，处理的元素，下标，数组本身){},首次累加器的值)		否ES6
flat()与flatMap()数组.flat(提取嵌套的深度，默认为1)
数组.flatMap(回调函数(处理的元素，下标，数组本身){},回调函数使用的this值)		否ES10

cjh_code
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
lotus domino 数组使用归纳总结
03-03
lotus domino 数组使用归纳总结
数组的常用方法大全
热门推荐
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 (原数组不受影响) ​ 该方法是......
数组常用的函数
m0_74331185的博客
10-18 2366
数组常用函数js
splice 的用法
一直在路上的博客
10-21 1880
splice 的用法 splice 是数组的一个方法，使用这个方法会改变原来的数组结构，splice（index ，howmany ， itemX）；这个方法接受三个参数，我们在使用的时候可根据自己的情况传递一个参数，或两个参数，或者三个参数； 总结splice（）这个方法就是可以删除数组中的项，也可以向数组中添加新的项 传递一个参数时 ： 传递一个参数的时候表示从这个参数的位置开始一直截取到最后 var arr = [2,4,6,7,8,9]; console.log(arr);//[2,4,6,7,8,
数组方法的总结
m0_64246150的博客
11-01 395
map：返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组，会分配内存空间存储新数组并返回。遍历数组，查找数组当中是否有元素满足条件，如果有至少一个元素满足条件，则返回true，否则返回false。遍历旧数组，然后拿着旧数组元素去查询新数组，如果该元素在新数组里面没有出现过，我们就添加，否则不添加。把旧数组里面不重复的元素选取出来放到新数组里面，重复的元素只保留一个，放到新数组中去重。遍历数组，如果数组的每个元素都满足条件，则返回true，否则返回false。
总结: 数组常用的方法
hmxs_hmbb的博客
05-05 1465
还等啥? 进来看看啥都明白了!!!!!!!
常用PHP数组排序函数归纳
12-18
数组排序：数组中的元素能够以字母或数字顺序进行升序或降序排序。 常用的PHP数组排序函数  •sort() – 以升序对数组排序  •rsort() – 以降序对数组排序  •asort() – 根据值，以升序对关联数组进行排序  ...
数组的常用方法知识点归纳
04-07
数组的常用方法知识点归纳
JS数组去重常用方法实例小结【4种方法】
12-11
js数组去重，老生长谈，今天对其进行一番归纳，总结出来4种方法 贴入代码前 ，先对浏览器Array对象进行支持indexOf和forEach的polyfill Array.prototype.indexOf = Array.prototype.indexOf || function(item) { ...
数组的常用方法总结
lx_curry的博客
06-12 1147
将数组转化成字符串，每一项元素用逗号隔开 split() 将字符串转化为数组，括号内的参数为分隔符。 二、Array.join() join() 方法接收一个参数，即字符串分隔符，返回包含所有项的字符串 三、Array.shift() shift()方法用于删除数组的第一项，同时减少数组的length 值，返回被删除的项 四、Array.reverse()和Array.sort() reverse() 数组的反转，会改变原数组 sort() sort()方法接受一个比较函数，用于判断哪个值应该排在前面 五、
数组常用方法汇总
大G的博客
11-07 3万+
Array.length 返回或设置一个数组中的元素个数 设置 length 属性的值来截断任何数组 Array.from() : 对伪数组或可迭代对象(包括arguments Array,Map,Set,String…)转换成数组对象 语法 Array.from(arrayLike, mapFn, thisArg)arrayLike 想要转换成数组的伪数组对象或可迭代对象。mapFn (可选参数
数组方法大全
haiyangfsg的博客
03-20 148
常用数组： pop：原数组变，返回删除的元素 push：原素组变 shift：原数组变，返回删除的元素 unshift：原素组变 slice：返回新数组，截取索引开始，结束 splice：原数组变，返回截取的新数组，截取索引开始，长度，截取位插入值 reverse：原数组改变颠倒位置 sort：原数组改变大小排序 join：数组变为字符串（可加分隔符） concat：返回拼接的新数组 ES5新增： indexOf（）字符串、数组统用，返回指定字符首次出现的位置（索引值），返回这个索引值，否则返回-1 for
所有数组的方法：
weixin_41255023的博客
10-15 348
所有数组的方法： 方法名 对应版本 功能 原数组是否改变 concat() ES5- 合并数组，并返回合并之后的数据 n join() ES5- 使用分隔符，将数组转为字符串并返回 n pop() ES5- 删除最后一位，并返回删除的数据 y shift() ES5- 删除第一位，并返回删除的数据 y unshift() ES5- 在第一位新增一或多个数据，返回长度...
最全数组方法，最简单易懂，数组方法大全
weixin_46547740的博客
10-22 6363
常用数组： pop：原数组变，返回删除的元素 push：原素组变 shift：原数组变，返回删除的元素 unshift：原素组变 slice：返回新数组，截取索引开始，结束 splice：原数组变，返回截取的新数组，截取索引开始，长度，截取位插入值 reverse：原数组改变颠倒位置 sort：原数组改变大小排序 join：数组变为字符串（可加分隔符） concat：返回拼接的新数组 ES5新增： indexOf（）字符串、数组统用，返回指定字符首次出现的位置（索引值），返回这个索引值，否则返回-1 for
数组的所有方法
weixin_43627806的博客
03-04 2万+
JavaScript中创建数组有两种方式 （一）使用 Array 构造函数： var arr1 = new Array(); //创建一个空数组 var arr2 = new Array(20); // 创建一个包含20项的数组 var arr3 = new Array(“lily”,“lucy”,“Tom”); // 创建一个包含3个字符串的数组 （二）var 创建数组 var arr4 = [...
数组常用方法
a895544608的博客
04-01 8507
一、 改变原数组的方法 （常用） push : 尾部追加 (向数组的尾部添加一个或多个元素，返回值是数组的长度） unshift : 头部添加 (向数组的头部添加一个或多个元素，并返回数组长度) pop : 尾部删除 (删除数组最后一个元素） shift : 头部删除 (删除数组第一个元素） sort: : 排序 (对数组元素进行排序) join : 分隔 (将数组的每一项通过自己指定的字符进行拼接、默认连接为 ",") reverse : 反转 (将数组进行倒序) spli...
JS数组全部方法
motility_scy的博客
07-15 5487
⭐数组方法⭐ 容易混淆的地方: Vue中 响应式并不包括数组中的 项 vue对在data中声明的数据进行处理，将这些数据都变成响应式的。(响应式即数据变化会自动更新页面) 对在data中声明的基本类型的数据，对象及对象中的属性，都是响应式的，但是例外对数组中的项并不是响应式的 new Vue({ el: '#app', data: { // 基本类型的数据，响应式的 str: 'abc', num: 123, flag:
对这些数组方法进行整理归纳，方便我记忆
最新发布
04-03
8. join() - 将数组中的所有元素合并为一个字符串 9. reverse() - 反转数组中的元素 10. sort() - 对数组中的元素进行排序 11. filter() - 返回一个新的数组，其中包含满足条件的元素 12. map() - 返回一个新的数组...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值