JS数组方法

最新推荐文章于 2021-05-27 21:09:02 发布

偏执带点小放纵

最新推荐文章于 2021-05-27 21:09:02 发布

阅读量156

点赞数

分类专栏： JS 文章标签： JS数组方法

本文链接：https://blog.csdn.net/weixin_45562774/article/details/100568127

版权

JS 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

js数组方法

1.有length 有索引

var ary=[12,3,4]

1.pop,想删除两项时，必须使用两次，删完一项在删一项
- 1.删除数组最后一项
- 2.不需要传参
- 3.pop（）返回值是删除的哪一项
- 4.原有数组发生改变

   console.log(ary)
      ary.pop();//删除数组最后一项
      console.log(ary.pop())
      console.log(ary)

push新增
- 像数组末尾新增一项或多项
- 需要传参
- 返回值是新数组的length
- 原有数组发生改变

   ary.push(100,123,57,8)
    console.log(ary.push([1,3]))//不可以新增数组
    console.log(ary)

shift 删除数组第一项
- 不需要传参
- shift（）返回值是删除的哪一项
- 原有数组发生改变

   ary.shift()//删除数组第一项
    console.log(ary.shift())
    console.log(ary)

unshift 像数组开头新增一项或多项
- 需要传参
- 返回值是新数组的length
- 原有数组发生改变

   ary.unshift(59)
    console.log( ary.unshift())
    console.log(ary)

slice 截取
- 参数slice（m，n）从索引m开始，到n索引结束，但不包括索引n
- 参数slice（m）从索引m开始，到最后的索引结束
- 参数slice（）克隆一个一模一样的数组
- 参数slice（-1）支持负数让ary.length和负数相加，在截取，得到的结果就是要截取的开始项
- m>n:[]
- m>n返回值空数组；
- 原有数组不发生改变
- 返回值为截取的新数组

 ary.slice(0,1)
    console.log(ary.slice(-1))

console.log(ary)
var f=[1,3,5,23,5,66]
console.log(f)
console.log(f.slice(3,-1))
//[23, 5]从索引3开始到索引（length+（-1））结束，但不包括（length+（-1））
console.log(f.slice(2,-2))// [5, 23]

console.log(ary)
ary.slice(1,-1);
console.log(ary.slice(1,-1))

splice 删除数组的某几项
- 参数，从索引m开始删除n项[splice（m,n）]
- 3.被删除的几项组成一个新的数组，原有数组发生改变
- splice(m),从索引m开始把m索引后的都删除掉
- splice(0),全部删除
- splice(-m),-m和length相加的的结果就是删除的开始项，到末尾都删除
splice(-m，n),-m和length相加的的结果就是删除的开始项索引，删除n项
splice(m,x,n):从索引m开始，删除x项。用n替换，当x为0时在m前加上n
splice(m,x,n,c):从索引m开始，删除x项。用n,c替换，当x为0时在m前加上n,c

   var ary = [1, 2, 34, 4, "3"];
    console.log(ary)
    console.log(ary.splice(-4,2))//[2, 34]
    console.log(ary.splice(-5,2))//[1, 2]
    console.log(ary)

sort 排序
从小道大

ary.sort(function(a,b){
      //根据函数返回值的正负判断是否进行交换
      return a-b;
  })
  console.log(ary)

从大到小

 ary.sort(function(a,b){
      return b-a;
  })
  console.log(ary)

reverse 将数组成员位置颠倒过来

 ary.reverse()

indexOf
返回值是索引
检测数组成员在数组中第一次出现的位置

  var ary1=[1,2,3,3,4]
    ary1.indexOf(3)
    ary1.indexOf(9)
    ary1.indexOf(3,1) //1:代表索引开始检测的位置
    //indexOf(m,n)//从索引n开始检测m第一次出现的地方
    console.log(ary1.indexOf(3))//2
    console.log(ary1.indexOf(3,1))

lastIndexOf

返回值是索引
检测数组成员在数组中最后一次出现的位置
如果校验的数组成员不存在返回值为-1
原有数组不发生改变

var ary2=[1,2,3,3,4]
    ary2.lastIndexOf(3)
    console.log(ary1.lastIndexOf(3))//3
    console.log(ary1.lastIndexOf(30))//-1
    console.log(ary1.lastIndexOf())//-1

concat:数组的连接
- 放在数组的后面，返回值为数组拼接后的新数组
- 原数组不改变
- 也可以基于空数组拼接，空数组不占据内容的位置

 console.log([].concat(ary,[1,2,3]))
     console.log(ary)//["3", 4, 34]
     console.log(ary.concat())//["3", 4, 34]
    //concat()：克隆一个数组

跟push的区别：
- push不可以新增数组，而concat不仅可以拼接数也可以拼接数组

 ary1.concat([12,13,12,13])
    console.log( ary1.concat([12,13,12,13]))//[1,2,3,3,4,12,13,12,13]
    console.log(ary1)//[1,2,3,3,4]

join
- 需要参数
- 获取到数组的每个成员然后按照给的参数连接到一块，成为一个字符串
- 原数组不改变
- 返回一个连接在一起的字符串

ary1.join("+")
   console.log(ary1.join("+"))//"1+2+3+3+4"
   ary1.join("")
   console.log(ary1.join(""))//"12334"
   ary1.join(" ")
   console.log(ary1.join(" "))//"1 2 3 3 4"
   ary1.join("1")
   console.log(ary1.join("1"))//"112131314"
   ary1.join("爱")
   console.log(ary1.join("爱"))//"1爱2爱3爱3爱4"

map

  ary1.map(function(item,index,all){
       // console.log(item);//代表数组的每一项
       // console.log(index);//数组成员的索引
       // console.log(all);//所有的数组成员，代表原数组，数组成员有几项就执行几次
       // console.log(all===ary1);//true(5)数组成员有几项就执行几次
    
       // all[index]=item+1//每个数组成员都加上1
       all[index]="<li>"+item+"</li>"//        
   })
   console.log(ary1)

   var a=[1,2,3,3];
   a.map(function(item,index,all){
       a[index]=item+1
   })
   console.log(a)

forEach

ary2.forEach(function(item,index,all){
// console.log(item);//代表数组的每一项
// console.log(index);//数组成员的索引
// console.log(all);//所有的数组成员，代表原数组，数组成员有几项就执行几次
return 100; //forEach没有返回值
})
console.log(ary2)