数组常用api

1.push() 从数组尾部插入一个或者多个元素（会修改原数组，并返回新数组的长度）

    let arr = ['a','b','c','d']
    
//插入一个元素
    let result = arr.push('e')
    console.log(arr) //['a', 'b', 'c', 'd', 'e']
    console.log(result) //5
    
//插入多个元素
    let result2 = arr.push('f','g')
    console.log(arr) //['a', 'b', 'c', 'd', 'e', 'f', 'g']
    console.log(result2) //7

2.pop() 从数组的尾部删除一个元素（会修改原数组，并且返回被删除的元素）

    let arr = ['a','b','c','d']
    let result = arr.pop()//不可以带参数
    console.log(arr) //['a', 'b', 'c']
    console.log(result) //d

3.unshift() 从数组的头部插入一个或多个元素（会修改原数组，返回新数组长度）

    let arr = ['a','b','c','d']
    
//从头部插入一个元素
    let result = arr.unshift('A') 
    console.log(arr) //['A', 'a', 'b', 'c', 'd'] 
    console.log(result) //5 
    
//从头部插入多个元素
    let result2 = arr.unshift('1','2','3') 
    console.log(arr) //['1', '2', '3', 'A', 'a', 'b', 'c', 'd']
    console.log(result2) //8

  4.shift() 从数组的头部删除一个元素（会修改原数组，并且返回被删除的元素）

    let arr = ['a','b','c','d']
    let result = arr.shift()
    console.log(arr) //['b', 'c', 'd']
    console.log(result) //a

5、slice(start, end)  start:开始裁切的下标, end:结束裁切的下标 end切不到，实际上裁切的范围是 下标start到end-1 （不会修改原数组，并且返回裁切出来的数组）

    let arr = ['a','b','c','d']
     
//如果传递两个参数, 则从0下标开始裁切, 裁切到3下标, 3裁切不到
    let result = arr.slice(0,3)
    console.log(arr) //['a', 'b', 'c', 'd']
    console.log(result) //['a', 'b', 'c']

   
//如果只有一个参数, 则作为开始裁切的下标, 裁切到数组尾部
    let result2 = arr.slice(1)
    console.log(arr) //['a', 'b', 'c', 'd']
    console.log(result2) //['b', 'c', 'd']

    
//如果传递负数参数, 则从数组的尾部往前数 (或者直接使用 数组的长度+负数参数 )
    let result3 = arr.slice(-4, -1)
    console.log(arr) //['a', 'b', 'c', 'd']
    console.log(result3) //['a', 'b', 'c']

  6.splice(start, length, [可选参数列表])  start:开始裁切的下标, length:要裁切多少个（会改变原数组，返回裁切出来的数组）

    
let arr = ['a','b','c','d','e','f']
    //如果只有一个参数, 则作为开始裁切的下标, 裁切到数组尾部
    let result = arr.splice(2)
    console.log(arr) //['a', 'b']
    console.log(result) //['c', 'd', 'e', 'f']

    
let arr2 = ['a','b','c','d','e','f']
    //如果传递两个参数, 则从2下标开始裁切, 裁切4个元素
    let result2 = arr2.splice(2,3)
    console.log(arr2) //['a', 'b', 'f']
    console.log(result2) //['c', 'd', 'e']

    
let arr3 = ['a','b','c','d','e','f']
    //如果传递多个其他参数, 会把其他的参数, 替换数组中被掉裁切的部分
    let result3 = arr3.splice(2,'html','css','javascript','vue')
    console.log(arr3) // ['a', 'b', 'css', 'javascript', 'vue', 'c', 'd', 'e', 'f']
    console.log(result3) //[]

    
let arr4 = ['a','b','c','d','e','f']
    //如果传递多个其他参数, 而裁切长度为0, 把其他的参数插入要裁切的下标之前
    let result4 = arr4.splice(2, 0,'html','css','javascript','vue')
    console.log(arr4) // ['a', 'b', 'html', 'css', 'javascript', 'vue', 'c', 'd', 'e', 'f']
    console.log(result4) //[]

    
let arr5 = ['a','b','c','d','e','f']
    //第一个参数允许传递负数
    let result5 = arr5.splice(-3,2)
    console.log(arr5) // ['a', 'b', 'c', 'f']
    console.log(result5) //['d', 'e']

7.join("连接符");  以特定的连接符, 把数组连接成字符串（不会改变原数组，返回连接成的字符串）

    let arr = ['a','b','c','d','e','f']
    let result = arr.join(',')
    console.log(arr) // ['a', 'b', 'c', 'd', 'e', 'f']
    console.log(result) // a,b,c,d,e,f

8. concat([多个参数]) 连接一个或多个数组（不会改变原数组，返回连接过后的数组）

let arr = ['a','b','c','d','e','f']
    let arr2 = ['html','css','javascript','vue']
    let result = arr.concat(arr2)
    console.log(arr) //['a', 'b', 'c', 'd', 'e', 'f']
    console.log(result) //['a', 'b', 'c', 'd', 'e', 'f', 'html', 'css', 'javascript', 'vue']

9.indexOf( 要查找的元素, [指定的下标] ) 在数组中查找指定元素 如果有就返回下标, 如果没有返回-1    (可选参数: 从指定下标开始往后查找元素)  

let arr = [1,2,3,4,5,4,3,2,1];
 
console.log(arr.indexOf(1)); // 没有填fromIndex所以默认从索引为0的位置开始往后查找
// 0
console.log(arr.indexOf(1,1)); // 表示从索引为1的位置开始往后查找
// 8

10.lastIndexOf(要查找的元素, 指定下标)  如果有就返回下标, 如果没有返回-1

var longStr = ['a','b','c','c','d','e','f'];
//如果有两个参数  第一个参数是要查找的元素, 第二个参数是从指定的下标开始往数组头部查找元素
var lastIndex = longStr.lastIndexOf('c',3)
console.log(lastIndex) //3

11.reverse() 反转数组, 把数组的顺序进行颠倒(改变原数组，并且返回颠倒之后的数组)

var longStr = ['a','b','c','c','d','e','f'];
var lastIndex = longStr.reverse()
console.log(lastIndex) //['f', 'e', 'd', 'c', 'c', 'b', 'a']
console.log(longStr) //['f', 'e', 'd', 'c', 'c', 'b', 'a']

12.sort() 排序（改变原数组，并且返回排好序的数组）

//升序
var points = [40,100,1,5,25,10];
let result =  points.sort(function(a,b){return a-b});
console.log(points) //[1, 5, 10, 25, 40, 100]
console.log(result) //[1, 5, 10, 25, 40, 100]

//降序
var points2 = [40,100,1,5,25,10];
let result2 =  points2.sort(function(a,b){return b-a});
console.log(points2) //[100, 40, 25, 10, 5, 1]
console.log(result2) //[100, 40, 25, 10, 5, 1]

13.some方法的作用：判断数组中至少存在一个元素满足指定条件

let arr = [1, 2, 3, 4, 5]
let range = {min: 3, max: 5}
let result = arr.some( function(item,index){
  if (this.min <= item && item<= this.max) {
    return true
  }
  console.log(item) // 1, 2
},range)
        
console.log(result)  // true

14.every()方法会遍历数组的每一项，如果有有一项不满足条件，则表达式返回false,剩余的项将不会再执行检测；如果遍历完数组后，每一项都符合条，则返回true。

标准用法：

array.every(function(currentValue,index,arr), thisValue)

参数说明：

• 第一个参数为一个回调函数，必传，数组中的每一项都会遍历执行该函数。
  currentValue：必传，当前项的值
  index：选传，当前项的索引值
  arr：选传，当前项所属的数组对象
• 第二个参数thisValue为可选参数，回调函数中的this会指向该参数对象

Tips:

• every() 不会对空数组进行检测
• every() 不会改变原始数组

let arr = [1, 2, 3, 4, 5, 7]
let result = arr.every(function(item, index, arr) {
  return item > 6
})
console.log(result) // false

15.filter是我们经常使用它过滤array的某些元素，返回剩下的元素

let arr = [1, 2, 3, 4, 5, 7]
let result = arr.filter(function(item, index, arr) {
  if (item > 3) {
    return true
  }
})
console.log(result) // 4, 5, 7

16. reduce 用来迭代一个数组，并且把它累积到一个值中。

参数介绍

array.reduce((pre, cur, index, arr)=>{
	...
}, init);

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

例子：基本数据类型求和

let arr2 = [9, 4, 3, 6, 9];
let sum = arr2.reduce((pre, cur) => {
    return pre + cur
},0)
console.log(sum)   //31

例子：二维数组转化为一维

let arr = [[1, 2, 8], [3, 4, 9], [5, 6, 10]];
let res = arr.reduce((pre, cur) => {
    return pre.concat(cur)
},[]);
console.log(res)  //[1, 2, 8, 3, 4, 9, 5, 6, 10]

例子：多维数组转化为一维

let arr = [[1, [2, 8]], [3, 4, 9], [5, [6, 10]]]
function fn(arr) {
  return arr.reduce((pre, cur) => {
    return pre.concat(Array.isArray(cur) ? fn(cur) : cur);
  }, []);
}
const newArr = fn(arr);
console.log(newArr); //[1, 2, 8, 3, 4, 9, 5, 6, 10]

17. map是操作js数组的方法，也可以说是一个函数，作用是遍历整个数组，对里面的每个值做处理再返回一个新的值。

注意，除非使用map数组里面存在嵌套复杂的对象、数组结构，否则map是不会修改原数组的

let a=[1,2,3]
let b= a.map(item => item<2?item*2:item)
console.log(a)//[1,2,3]
console.log(b)//[2,2,3]

例子二：

 const bookList = [
            {"id":10,"title":"Web前端开发","price":99.9},
            {"id":11,"title":"C++","price":80.9},
            {"id":12,"title":"Python","price":100.9}
          ]
         console.log(bookList.map(book =>{
            return {title:book.title,price:book.price}
          })) 

打印结果

includes方法

简介：首先,includes()方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false

语法：includes（searchElement，fromIndex）

searchElement	必须。需要查找的元素值。
fromIndex	可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。

const arr  = [1,2,3,4,5]
const result = arr.includes(1)
const result2 = arr.includes(1,2)
const result3 = arr.includes(1,-1)
console.log(arr, result) //[1,2,3,4,5], true
console.log(arr, result2) //[1,2,3,4,5], false
console.log(arr, result3) //[1,2,3,4,5], false