JS数组方法

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)

- **`tostring()`**

console.log(ary1)//
console.log(ary1.toString())//
console.log(ary1)