JS---数组的方法

此文中所有的item 为当前数组的每一个数值, index为数组的索引值,arr为当前的数组

增  

unshift     push      concat()

---

unshift     push 

  arr.unshift(5)//在数组的前面添加
  arr.push(1)//在数组的最后添加

concat()   

合并返回一个新数组 原数组不变

    let arr = [1, 2, 3, 4]
let arr2 = arr.concat(2, 3)
    console.log(arr2);//[1, 2, 3, 4, 2, 3]
let arr2 = arr.concat(2, 3,[5,6,7])
    console.log(arr2);// [1, 2, 3, 4, 2, 3, 5, 6, 7]

 删

shift()   pop()     slice()

---

shift()   pop()

arr.shift()//在数组的前面删除
arr.pop()//在数组的最后删除

slice(start,[end])

切割数组,并返回切割后的数组  原数组不变

  let arr = [1, 2, 3, 4]
let arr2= arr.slice(1,2)
   console.log(arr2);//[2]

查

indexof()  find()      includes()    findIndex()    findLastIndex()

---

indexof(item,start)

返回要查找的元素在数组中的位置，如果没找到则返回 -1

let arr = [1, 2, 3, 4]
console.log(arr.indexOf(2));//索引值为1
     console.log(arr.indexOf(5));//-1


console.log(arr.indexOf(2,0)); //1

console.log(arr.indexOf(2,2));-1

find(item, [index], [arr])  查找  

返回第一个匹配的元素,如果没找到则返回-1

    let arr = [1, 2, 3, 4]
let a = arr.find((item, index, arr) => {
      // console.log(item, index, arr);//item数组的值,index索引,arr当前数组
      return item > 2
    })
    console.log(a);//3

 findIndex(item, [index], [arr])

返回要查找的元素在数组中的位置(索引值)，如果没找到则返回-1

    let arr = [1, 2, 3, 4]
let a= arr.findIndex((item,index,arr)=>{
        console.log(item,index,arr);
        return item>2
      });
      console.log(a);//2

includes()   包含  

返回布尔值

    let arr = [1, 2, 3, 4]
console.log(arr.includes(1));//true
    console.log(arr.includes(5));//false

特殊方法:splice(start,[要删除的元素数量],[插入的元素])

返回空数组,原数组改变

增

    let arr = [1, 2, 3, 4]
arr.splice(1, 0, 5)//从索引1开始删除,删0个,插入的元素为5

删

    let arr = [1, 2, 3, 4]
arr.splice(0, 3)//从索引0开始删除,删3个

改

    let arr = [1, 2, 3, 4]
arr.splice(1, 1, 'red')//从索引1开始删除,删1个,在删除那个索引值位置插入red

 

---

 数组转换成字符串:join() 方法

接收一个参数，即字符串分隔符，返回包含所有项的字符串

    let arr = [1, 2, 3, 4]
console.log(arr.join(''));//1234
    console.log(arr.join('|'));//1|2|3|4

---

 排序:

  reverse ( )       sort( )          reduce( )

---

reverse()

返回翻转后的数组

console.log(arr.reverse());// [4, 3, 2, 1]

sort(callback)

sort(callback)     返回值是排序后的数组,并且不进行复制

function compare(a, b) {
        if (a < b) {           // 按某种排序标准进行比较，a 小于 b
          return -1;
        }
        if (a > b) {          // 按某种排序标准进行比较，a  大于 b
          return 1;
        }
        return 0;              // a=b
      }
      console.log(arr.sort(compare));


    let arr1 = [5, 87, 68, 4, 39, 6]
    console.log(arr1.sort((a, b) => b - a));

 reduce() 计算

 array.reduce((pre, cur, index, arr) => {
  	...
 }, init);
     
      pre: 必需。初始值, 或者计算结束后的返回值。
      cur： 必需。当前元素。
      index： 可选。当前元素的索引。
      arr： 可选。当前元素所属的数组对象。
      init: 可选。传递给函数的初始值，相当于pre的初始值。
      reduce里面有一定要return，return出去的值也要注意

查看代码

    let arr = [1, 2, 3, 4]
let a = arr.reduce((pre, item) => {
    console.log(pre);//截止当前的累计和
    console.log(item);//数组的每一个数值
    return pre + item
    }, 0)//传递给函数的初始值，相当于pre的初始值。
     console.log(a);//10

let a = arr.reduce((pre, item) => {
      if (item>3 ) {
        return pre + 2
      } else {
        return pre + 1
      }
  
      return pre + item
    }, 0)//传递给函数的初始值，相当于pre的初始值。
    console.log(a);//5

---

 迭代方法

 some( )     every( )    forEach( )     filter( )     map( )

---

 some(  )  译(一些)

   返回值为布尔值(只要有一个为true,就返回true)

    let arr = [1, 2, 3, 4]
let a= arr.some((item,index,arr)=>item>2)
    console.log(a);//true

 every( )  译(每个)  

 返回值为布尔值(必须全部为true,才返回true,只要一个为false,就返回false)

    let arr = [1, 2, 3, 4]
let a= arr.every((item,index,arr)=>item>2)
    console.log(a);//false

forEach( )循环遍历

  arr.forEach((item,index,arr)=>{
      // 执行某些操作
    })

 filter( )   过滤 

 对数组每一项都运行传入的函数，函数返回 true 的项会组成数组之后返回

    let arr = [1, 2, 3, 4]
let a = arr.filter((item, index, array) => item > 2);
    console.log(a); // 3,4

map( )   映射

对数组每一项都运行传入的函数，返回由每次函数调用的结果构成的数组

    let arr = [1, 2, 3, 4]
let a = arr.map((item, index, array) => item * 2);
    console.log(a) // [2, 4, 6, 8]