js中array对象的常用方法,js中的array数组拥有哪些优缺点

　　本文主要介绍JS Array数组常用方法的总结和实例，JavaScript创建数组、查找数组元素、删除数组重复的方式，需要对数组排序的朋友可以参考一下。

一、JavaScript中创建数组的方式

　　(1)使用数组构造函数：

　　var arr 1=new Array()；//创建一个空数组

　　var arr2=新数组(15)；//创建长度为15的数组

　　var a=新数组([15])；//创建一个长度为1，第一位为15的数组。

　　var arr3=新数组( sf ， zs ， zsf )；//创建一个包含3个字符串的数组

　　(2)使用数组文字符号：

　　var arr 4=[]；//创建一个空数组

　　var arr 5=[15]；//创建一个长度为1且数字为“15”的数组

　　var arr6=[sf ， zs ， zsf ]；//创建一个包含3个字符串的数组

二、数组方法概括

　　数组的方法一般以是否会改变原数组来区分。

　　使用以下方法会改变原数据

　　方法作用是原数组是否更改pop()删除最后一位，返回删除数据yshift()删除第一位，返回删除数据ypush在末尾添加一个或多个数据，返回长度yunshift()在第一位添加一个或多个数据，返回长度ysort()排序(字符规则)，返回结果yreverse()反转数组，返回结果ysplice()。

　　该方法的功能是判断原始数组是否更改了join()分隔符，是否将数组转换为字符串并返回nconcat()合并数组，以及是否返回合并数据。nslice()在指定位置截取数组，返回ntoString()直接转换成字符串。并返回nvalueOf()返回数组对象的原始值nindexOf()查询并返回数据的索引nlastIndexOf()查询并返回数据的索引。参数nforEach()是一个回调函数，它将遍历数组中的所有项。回调函数接受三个参数，即value、index和self。forEach没有返回值nmap()和ForEach，回调函数返回数据组成新数组。map返回nfilter()和forEach，回调函数返回布尔值。为真的数据形成一个新的数组。filter返回nevery()和forEach，回调函数返回布尔值，都为真。every返回的Truensome()与forEach相同，回调函数返回一个布尔值。只要有一个为真，且some返回的trueeducation()被合并，数组中的所有项都用forEach迭代，构造一个最终值，与reduce返回的nreduceRight()反向合并，数组中的所有项都用forEach迭代。并构建一个最终值，reduceRight返回nfindIndex()来查找数组中第一个合格元素的下标，不再遍历n

三、方法详解

1、pop()

　　Pop():从数组末尾移除最后一项，减小数组的长度值，然后返回移除的项。

　　ar arr=[1，2，3]；

　　console . log(arr . pop())；//3

　　console . log(arr)；//[1，2]-原始数组被更改

2、shift()

　　函数：方法用于删除和返回数组的第一个元素。

　　var arr=[1，2，3]

　　console . log(arr . shift())；//1

　　console . log(arr)；//[2，3]-原始数组被更改

3、push()

　　函数：在数组末尾添加一个或多个元素，并返回新的长度。

　　var arr=[1，2，3]；

　　console . log(arr . push( hello ))；//4

　　console . log(arr)；//[1，2，3， hello ]-原始数组发生变化

　　console.log(arr.push(a ， b ))；//6

　　console . log(arr)；//[1，2，3，你好， a ， b ]-原始数组改变

4、unshift()

　　函数：在数组的开头添加一个或多个元素，并返回新的长度。

　　var arr=[1，2，3]；

　　console . log(arr . un shift( hello ))；//4

　　console . log(arr)；//[hello ，1，2，3]-原始数组发生变化

　　console.log(arr.unshift(a ， b ))；//6

　　console . log(arr)；//[A ， B ， Hello ，1，2，3]-原始数组发生变化

5、sort()

　　函数：对数组中的元素进行排序，默认为升序。

　　var arr=[6，1，5，2，3]；

　　console . log(arr . sort())；//[1, 2, 3, 5, 6]

　　console . log(arr)；//[1，2，3，5，6]-原始数组被更改

　　注意：默认情况下，sort在排序前将所有元素转换为字符串，字符串根据ASCII码排序。

　　//情况1:看起来正常的结果

　　[谷歌，苹果，微软]。sort()；//[苹果，谷歌，微软]；

　　//案例二：苹果排在最后。

　　[谷歌，苹果，微软]。sort()；//[谷歌，微软，苹果]

　　//案例三：无法理解的结果

　　[10, 20, 1, 2].sort()；//[1, 10, 2, 20]

　　我们可以看到情况2和情况3，我们会发现直接使用sort()是没有办法对复杂数组进行排序的。

　　所以我们可以如下使用。

　　var arr=[10，20，1，2]；

　　arr.sort((x，y)={

　　if (x y) {

　　return-1；

　　}

　　if (x y) {

　　返回1；

　　}

　　返回0；

　　});

　　console . log(arr)；//[1, 2, 10, 20]

6、reverse()

　　函数：反转数组项的顺序。

　　var arr=[13，24，51，3]；

　　console . log(arr . reverse())；//[3, 51, 24, 13]

　　console . log(arr)；//[3，51，24，13](原始数组已更改)

7、splice()

　　函数：一个强大的数组方法，可以用多种方式删除，插入，替换。

　　array.splice(索引，数量，项目1，itemX)

　　Index:必选。Integer，指定添加/删除项的位置，使用负值指定从数组末尾开始的位置。要删除的项目数。如果设置为0，则不会删除任何项目。1，…，itemx:可选。要添加到数组中的新项。splice()方法总是返回一个包含从原始数组中删除的项的数组，如果没有删除项，则返回一个空数组。

　　var arr=[1，3，5，7，9，11]；

　　var arrRemoved=arr.splice(0，2)；

　　console . log(arr)；//[5, 7, 9, 11]

　　console . log(arr removed)；//[1, 3]

　　var arrRemoved2=arr.splice(2，0，4，6)；

　　console . log(arr)；//[5, 7, 4, 6, 9, 11]

　　console . log(arrremoved 2)；//[]

　　var arrRemoved3=arr.splice(1，1，2，4)；

　　console . log(arr)；//[5, 2, 4, 4, 6, 9, 11]

　　console . log(arrremoved 3)；//[7]

1、join()

　　函数：将数组中的所有元素按照指定的分隔符放入一个字符串中，并返回这个字符串。

　　参数：join(str)；可选参数，默认为，，以传入字符作为分隔符。

　　var arr=[1，2，3]；

　　console . log(arr . join())；//1,2,3

　　console . log(arr . join(-))；//1-2-3

　　重复的字符串可以通过join()方法实现，重复的字符串只有通过传入字符串和重复次数才能返回。该功能如下所示：

　　函数repeatString(str，n) {

　　返回新数组(n ^ 1)。join(str)；

　　}

　　console.log(repeatString(abc ，3))；//abcabcabc

　　console.log(repeatString(Hi ，5))；//HiHiHiHiHi

2、concat()

　　功能：给原数组添加参数。该方法首先创建当前数组的副本，然后将收到的参数添加到该副本的末尾，最后返回新构建的数组。没有向concat()方法传递参数，它只是复制当前数组并返回一个副本。

　　const arr1=[1，2，3]；

　　const arr2=[4，5，6]；

　　const arr 3=arr 1 . concat(arr 2)；

　　console . log(arr 3)；//[1,2,3,4,5,6]

3、slice()

　　函数：返回一个新数组，该数组由原始数组中从指定的开始下标到结束下标的项组成。

　　array.slice(开始，结束)

　　slice()方法可以接受一个或两个参数，即要返回的项的开始(start)和结束(end)。

　　只有一个参数，slice()方法返回从参数指定的位置到当前数组结尾的所有项。如果有两个参数，此方法将返回起始位置和结束位置之间的项——使用以下方法不会改变原数据。如果start end的索引为，则返回空数组var arr=[1，3，5，7，9，11]；

　　var arr copy 1=arr . slice(1)；

　　var arrCopy2=arr.slice(1，4)；

　　var arrCopy3=arr.slice(1，-2)；

　　var arrCopy4=arr.slice(-4，-1)；

　　console . log(arr)；//[1，3，5，7，9，11](原数组不变)

　　console . log(arr copy 1)；//[3, 5, 7, 9, 11]

　　console . log(arr copy 2)；//[3, 5, 7]

　　console . log(arr copy 3)；//[3, 5, 7]

　　console . log(arr copy 4)；//[5, 7, 9]

4、toString()

　　函数：转换成字符串，类似于不带参数的join()。当数据被隐式类型化时，该方法将被自动调用，如果手动调用，该方法将被直接转换为字符串。

　　var arr=[1，2，3]；

　　console . log(arr . tostring())；//1,2,3

　　console . log(arr)；//[1，2，3]-原始数组没有改变。

5、valueOf()

　　函数：返回数组的原始值(一般来说，其实就是数组本身)，通常由js在后台调用，不会在代码中显式出现。

　　var arr=[1，2，3]；

　　console . log(arr . value of())；//[1,2,3]

　　console . log(arr)；//[1,2,3]

　　//证明返回的是数组本身

　　console . log(arr . value of()==arr)；//真

6、indexOf()

　　函数：根据指定的数据，从左到右，查询它在数组中出现的位置。如果指定的数据不存在，则返回-1。此方法是查询方法，不会更改数组。

　　indexOf(值，开始)；

　　Value:要查询的数据；Start:可选，表示开始查询的位置。当start为负时，从数组末尾向前计数；如果找不到该值，该方法将返回-1var arr=[h ， e ， l ， l ， o ]；

　　console . log(arr . index of( l ))；//2

　　console.log(arr.indexOf(l ，3))；//3

　　console.log(arr.indexOf(l ，4))；//-1

　　console.log(arr.indexOf(l ，-1))；//-1

　　console.log(arr.indexOf(l ，-3))；//2

7、lastIndexOf()

　　函数：根据指定的数据，从右到左，查询它在数组中出现的位置。如果指定的数据不存在，它将返回-1。此方法是查询方法，不会更改数组。

　　lastIndexOf(值，开始)；

　　Value:要查询的数据；Start:可选，表示开始查询的位置。当start为负时，从数组末尾向前计数；如果找不到该值，该方法将返回-1var arr=[h ， e ， l ， l ， o ]；

　　console . log(arr . lastindexof( l ))；//3

　　console.log(arr.lastIndexOf(l ，3))；//3

　　console.log(arr.lastIndexOf(l ，1))；//-1

　　console.log(arr.lastIndexOf(l ，-3))；//2

　　console.log(arr.lastIndexOf(l ，-4))；//-1

8、forEach()

　　函数：遍历数组，并对数组中的每一项运行给定的函数。此方法没有返回值。

　　参数：都是函数类型，默认传递。参数是：遍历的数组内容；对应的数组索引，数组本身。

　　var arr=[1，2，3，4，5]；

　　arr.forEach((item，index，a)={

　　console . log(item index (a===arr))；

　　});

　　//输出是：

　　//10true

　　//21true

　　//32true

　　//43true

　　//54true

9、map()

　　函数：对数组中的每一项运行给定的函数，并返回由每个函数调用的结果组成的数组。

　　如果希望数组中的每个值都改变，请使用map。

　　设arr=[10，30，50，60，120，230，340，450]

　　let newArr=arr.map(item={

　　退货项目* 2

　　})

　　console . log(new arr)；//[20, 60, 100, 120, 240, 460, 680, 900]

　　console . log(arr)；//[10, 30, 50, 60, 120, 230, 340, 450]

10、filter()

　　函数：Filter，数组中的每一项运行一个给定的函数，返回一个满足过滤条件的数组。

　　//过滤掉索引为3的倍数或值大于8的元素

　　var arr=[1，2，3，4，5，6，7，8，9，10]；

　　var arr2=arr.filter((item，index)={

　　返回索引% 3===0 item=8；

　　});

　　console . log(arr 2)；//[1, 4, 7, 8, 9, 10]

11、every()

　　函数：判断数组中的每一项是否满足条件，只有所有项都满足条件才会返回true。

　　var arr=[1，2，3，4，5]；

　　var arr2=arr.every((x)={

　　返回x 10

　　});

　　console . log(arr 2)；//真

　　var arr3=arr.every((x)={

　　返回x ^ 3；

　　});

　　console . log(arr 3)；//假

12、some()

　　函数：确定数组中是否有满足条件的项。只要有一项满足条件，就返回true。

　　var arr=[1，2，3，4，5]；

　　var arr2=arr.some((x)={

　　返回x ^ 3；

　　});

　　console . log(arr 2)；//真

　　var arr3=arr.some((x)={

　　返回x1；

　　});

　　console . log(arr 3)；//假

13、reduce()

　　函数：从数组的第一项开始，逐一迭代数组的所有项，然后构建最终返回值。

　　array.reduce(function(total，currentValue，currentIndex，arr)，initialValue)

　　参数：

　　Total是当前的聚合值，即合并值。它可以是任何类型。currentValue是数组循环时的当前元素。currentIndex是数组元素的索引值。arr是数组本身的initialValue。一般前两个参数常用，后两个参数不常用。常见的使用场景是数组的求和。

　　//函数：至少要传递两个值来汇总数组中的所有内容。

　　设arr=[10，30，50，60，120，230，340，450]

　　设newArr=arr.reduce((pre，n)={

　　返回前n

　　}, 0)

　　console . log(new arr)；

14、reduceRight()

　　函数：(类似于reduce)从数组的最后一项开始，逐个向前遍历到第一处，遍历数组的所有项，然后构建一个最终的返回值。

　　array . reduce right(function(total，currentValue，currentIndex，arr)，initialValue)

　　参数：与reduce相同。

　　var arr=[1，2，3，4，5]；

　　var sum=arr . reduce right(function(pre，cur，index，array){

　　返回当前值；

　　},10);

　　console . log(sum)；//25

15、findIndex()

　　函数：返回满足提供的测试函数的数组中但不包括结束位置的项的索引。如果不是，返回-1。

　　设arr=[10，2，9，17，22]；

　　let index=arr . find index((item)=item 13)

　　console.log(索引)；//3

四、实战

　　有些算法可以用这种方法实现，这里我只写一些简单可实现的方法。

4.1、实现数组排序（升序 降序）

　　我们可以使用sort with reverse快速排序，但也可以使用冒泡排序、快速排序等方法。

　　第一个元素

　　递升序列

　　var arr=[6，1，5，2，3]；

　　console . log(arr . sort())；//[1, 2, 3, 5, 6]

　　降序

　　var arr=[6，1，5，2，3]；

　　console.log(arr.sort((a，b)={ return b-a }))；//[6,5,4,3,2,1]

　　降序

　　var arr=[6，1，5，2，3]；

　　console.log(arr.sort()。反向())；//[6,5,4,3,2,1]

4.2、数组去重

　　indexOf和push的实现是适用的

　　函数uniqueArray(arr) {

　　var temp=[]；

　　for(var I=0；长度；i ) {

　　if (temp.indexOf(arr[i])==-1) {

　　temp . push(arr[I])；

　　}

　　}

　　返回温度；

　　}

　　使用过滤器进行重复数据删除。

　　var r=[]，

　　arr=[苹果，草莓，香蕉，梨，苹果，橘子，橙子，草莓]；

　　r=arr.filter(function (element，index，self) {

　　return self . index of(element)===index；

　　});

　　consolo.log(r)//[苹果，草莓，香蕉，梨，橘子]

　　使用reduce实现数组对象的重复数据删除

　　//重复数组的名称。

　　var资源=[

　　{姓名：张三，年龄： 18}，

　　{姓名：张三，年龄： 19}，

　　{姓名：张三，年龄： 20}，

　　{姓名：李四，年龄： 19}，

　　{姓名：王武，年龄： 20}，

　　{姓名：刘钊，年龄： 21}

　　]

　　var temp={ }；

　　resources=resources . reduce((prev，curv)={

　　如果(！Temp[curv.name]) {//如果没有临时对象，则添加此名称并将当前对象添加到prev。

　　temp[curv . name]=true；

　　prev.push(曲线)；

　　}

　　返回上一个

　　}, []);

　　console.log(参考资料)；

　　//[

　　//{姓名：张三，年龄： 18}，

　　//{姓名：李四，年龄： 19}，

　　//{姓名：王五，年龄： 20}，

　　//{姓名：刘钊，年龄： 21}

　　//]

4.3、找数组元素

　　数组中重复次数最多的元素。

　　var arr=[1，1，1，2，2，2，2，2，2，3，3，3，4，4，5，6，7，7，8]；

　　var maxNum=0；

　　var maxName=“”；

　　var obj={ }；

　　arr.forEach((ele，index)={

　　obj[ele]？obj[ele]=1:obj[ele]=1；

　　})

　　for(let r in obj) {

　　if(obj[r]maxNum){

　　maxNum=obj[r]

　　maxName=r

　　}

　　}

　　Console.log(`最大重复次数为${maxName}，重复次数为${maxNum}`) //最大重复次数为2，重复次数为：7。

　　更多关于sort的原理本身就是冒泡排序的一种写法，JJS创建数组，S数组排序的信息，请看下面的相关链接。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。