数组常用的Api

创建数组的基本方式如下：

1.new Array(),当参数是一个数值时，代表的是创建了一个长度为该数值的数组，当参数是除了数值的其他类型的值的时候，则会创建一个只包含该特定值的数组

    let fruit = new Array(20)
    console.log(fruit);

    let fruit = new Array(undefined)
    console.log(fruit);

 2.字面量

    let fruit = ['apple','orange','banana']
    let personal = []
    let values = [1,3,4,6]

3Array.from() ES6新增的创建数组的静态方法，第一个参数是一个类数组对象

   // 字符串会被拆分成单字符数组   
   console.log(Array.from('hahahaha'));

对现有数组进行浅复制

    let one = [1,3,5,7]
    let two = Array.from(one)
    console.log(two); //  [1,3,5,7]

4 Array.of() 定义数组，可以把一组参数转换为数组

    console.log(Array.of(1,2,3,4));  // [1,2,3,4]
    console.log(Array.of(undefined)); // [undefined]

 数组的排序方法

reverse()反向排序

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

sort() 可用于升降序 参数是一个函数

    let values = [1,7,5,3,4,9,2]
        values.sort((a,b) =>{
          return a - b
    })
    console.log(values); // [1, 2, 3, 4, 5, 7, 9]

    let values = [1,7,5,3,4,9,2]
      values.sort((a,b) =>{
        return b - a
    })
    console.log(values); // [9, 7, 5, 4, 3, 2, 1]

forEach:数组遍历 会改变原数组

    let arr = [
      {
        id:1,
        content:'车厘子'
      },
      {
        id:2,
        content:'草莓'
      },
      {
        id:3,
        content:'苹果'
      },
      {
        id:4,
        content:'葡萄'
      },
    ]
    arr.forEach(item => {
      console.log(item.content); //  车厘子 草莓 苹果 葡萄
    })

map:将数组映射成另一个数组

    let arr = [
      {
        id:1,
        content:'车厘子'
      },
      {
        id:2,
        content:'草莓'
      },
      {
        id:3,
        content:'苹果'
      },
      {
        id:4,
        content:'葡萄'
      },
    ]
   let newArr = arr.map(item => item.content)
   console.log(newArr); //["车厘子", "草莓", "苹果", "葡萄"]

filter:把符合条件的元素过滤到新的数组

    let arr = [
      {
        id:1,
        content:'车厘子',
        cost:46
      },
      {
        id:2,
        content:'草莓',
        cost:78
      },
      {
        id:3,
        content:'苹果',
        cost:23
      },
      {
        id:4,
        content:'葡萄',
        cost:15
      },
    ]
   let newArr = arr.filter(item => item.cost >= 46 )
   console.log(newArr); 

 

 假定有两个数组(A,B),根据A中id值,过滤掉B数组不符合的数据

let single = [{id:4,title:'fruit'}]
    let content = [
      {
        conId:1,
        category:'葡萄'
      },
      {
        conId:4,
        category:'贵宾'
      },
      {
        conId:4,
        category:'中华田园犬'
      },
      {
        conId:3,
        category:'草莓'
      },
    ]
    function singleContent(single,content){
      return content.filter(item => item.conId === single.id)
    }
    console.log(singleContent(...single,content));

 

 find:断言函数 接收3个参数：元素 索引 数组本身  find() 返回符合条件的第一个匹配的元素

    let people = [
        {
          name: "mt",
          age: 22,
        },
        {
          name: "haha",
          age: 55,
        },
        {
          name: "ss",
          age: 33,
        },
      ];
      let arr = people.find((item) => item.age > 22);
      console.log(arr);

 

 every 和 some  every() 当数组元素每个都符合条件，some()当数组元素是否有符合条件

    let people = [
        {
          name: "mt",
          age: 22,
        },
        {
          name: "haha",
          age: 55,
        },
        {
          name: "ss",
          age: 33,
        },
      ];
      let arr = people.every((item) => item.age > 20);
      let arr2 = people.some(item => item.age > 33)
      console.log(arr); // true
      console.log(arr2); // true

reduce:归并方法 接收4个参数： 上一个归并的值、当前项，当前项的索引、数组本身

    let arr = [10,20,30,40]
      let count = arr.reduceRight(function(prve,curr){
        return prve + curr 
      },0) // prve 的初始值为0
      console.log(count); // 100

数组的其他方法：

push(): 尾增，返回数组的新的长度

pop(): 尾删，返回被删的元素

unshift(): 头增，返回数组新的长度

shift(): 头删，返回被删的元素

concat(): 合并生成一个新的数组

splice(): 数组删除/添加元素  3个参数时，从第1个参数位置开始，删除第2个参数个数元素，增加第3个参数元素 (该方法直接修改元素组)

slice() 截取，生成新的数组

 join()：用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的

includes() 方法返回一个布尔值，表示某个数组是否包含给定的值