Javascript数组方法

#数组创建

      let arr1 = [1, 2, 3]; // [1, 2, 3]
      let arr2 = Array(); // []
      let arr3 = Array(2); // [undefined, undefined]
      let arr4 = Array(1,2,3);  // [1, 2, 3]

#.将一个对象转换为数组

/*
* 第一个参数：被转化的数组
* 第二个参数：对每个元素进行处理，将处理后的结果返回的数组（类型map）
* 第三个参数：用来绑定this
*/

// 当参数为一个Object类型时，需要有length属性，用来指定数组长度，默认为0
    Array.from({ 2: '2', a: 'a', 0: '0', length: 4})  //  ['0', undefined, 2: undefined]
    Array.from({ 2: '2', a: 'a', 0: '0', length: 2})  //  ['0', undefined]
    Array.from({ 2: '2', a: 'a', 0: '0', length: 2}, v => v || '')   // ['0', '']
    Array.from('hello') //  ['h', 'e', 'l', 'l', 'o']

#.判断数组是否是一个Array类型

     Array.isArray([1,2,3])  // true
     Array.isArray({a: 'a'}) // false
     Array.isArray('hello')  // false
     Array.isArray(Array(3)) // true
     Array.isArray(null)     // false

#.Array.of; (把所有的参数放到一个数组中返回)

    let arr1 = Array.of(1, 2, 3); // [1, 2, 3]
    let arr1 = Array.of();        // []

#, copyWithin: 从数组的指定位置拷贝元素到另一个指定位置

/*
 *  第一个参数：复制的目标位置
 *  第二个参数：复制的开始位置(闭区间)
 *  第三个参数：复制的结束位置(开区间)
 */
    let arr = [1,2,3,4,5,6]
    arr.copyWithin(4, 1, 3) // [1,2,3,4,2,3]

#, entries: 返回一个数组的迭代对象(Iterator)

    let arr = [1,2,3]
    let it = arr.entries()
    console.log(it.next())  // {value: [0,1], done: false}
    console.log(it.next())  // {value: [1,2], done: false}
    console.log(it.next())  // {value: [2,3], done: false}
    console.log(it.next())  // {value: undefined, done: true}

#, every: 对数组中所有的元素进行检查，返回布尔值.

#,some: 和every类似，every是需要所有元素都满足条件，而some只要有满足的就会返回true

  every: 对数组中所有的元素进行检查，返回布尔值
  some: 和every类似，every是需要所有元素都满足条件，而some只要有满足的就会返回true
  let arr = [1,2,3]
  arr.every(v => { console.log(v); return v < 10}) // 1 2 3 true
  arr.every(v => { console.log(v); return v < 2})  // 1 2 false
  arr.some(v => { console.log(v); return v < 2})  // 1 true

#, fill: 用一个固定值替换数组中的元素

/*
 *  第一个参数：填充的值
 *  第二个参数：填充的开始位置(闭区间)
 *  第三个参数：填充的结束位置(开区间)
 */
  let arr = [1,2,3,4,5,6]
  arr.fill(0, 1, 3) // [1,0,0,4,5,6]
  Array(2).fill(0)  // [0,0]

#, filter: 创建一个新数组，返回原数组中满足条件的所有元素

let arr1 = [
  { age: 10, name: '10'},
  { age: 23, name: '23'},
  { age: 16, name: '16'},
  { age: 11, name: '11'},
  { age: 37, name: '37'}
]
arr1.filter(v => v.age < 18)

// 输出
/* [
 *   { age: 10, name: '10'},
 *   { age: 16, name: '16'},
 *   { age: 11, name: '11'}
 * ]
 */

#, find: 返回数组中第一个满足条件的元素。findIndex: 返回数组中第一个满足条件的元素的索引值

 let arr1 = [
    { age: 10, name: '10'},
    { age: 23, name: '23'},
    { age: 16, name: '16'},
    { age: 11, name: '11'},
    { age: 37, name: '37'}
  ]
arr1.find(v => v.age > 18)  // { age: 23, name: '23'}

#, flat: 创建一个新数组，扁平化原嵌套数组，参数为扁平的层数，该方法会移除空项

 let arr1 = [1, , [2, [3, , [4]]]]
  arr.flat()      // [1,2,[3, , [4]]]
  arr.flat(2)     // [1,2,3,[4]]
  arr.flat(3)     // [1,2,3,4]
  arr.toString()  // '1,,2,3,,4'

#,flatMap: 和 map 相近，但是会将返回结果压平一层

  let arr1 = [1,2,3]
  arr1.map(v => [v * 2])    // [[2], [4], [6]]
  arr1.flatMap(v => [v * 2]) // [2, 4, 6]

#,forEach: 遍历数组中的每一个元素

 let arr1 = [1,2,3]
arr1.forEach(v=>{console.log(v)}) // 1,2,3

#,includes: 判断一个数组中是否包含一个元素

let obj = {id: 2, valu
let arr = [
  obj,
  'hello',
  {id: 1, value: '1'}
]

arr.includes({id: 1, value: '1'}) // false
arr.includes(obj) // true
arr.includes('hello') // true

#,indexOf:找到满足条件元素的索引值，从第一个参数开始寻找。lastIndexOf：寻找顺序与indexOf相反。findIndex：查找元素的位置索引，和indexOf不同的是findIndex可以查找对象。而indexOf只可以查找数组

let arr1 = ['a', 'b', 'c','b']
arr1.indexOf('b') // 1
arr1.lastIndexOf('b') // 3

#,join:将元素连接成一个字符串，并用分隔符分割（第一个参数）

let arr = [1, 2,3,4,5]
arr.join(' , ') //  '1,2,3,4,5'

#,map: 返回一个新数组，数组中的元素为原数组经过处理后的值

let arr1 = [{id:1}, {id:2}, {id: 3}]
arr1.map(v => v.id) //  [1, 2, 3]

#,pop: 删除原数组的最后一个元素

let arr = [1,2,3]
arr.pop() // [1,2]

#,push: 在原数组的末尾添加一个元素

let arr = [1,2,3]
arr.push(4) // [1,2,3,4]

#,shift: 删除原数组的第一个元素

let arr = [1,2,3,4]
arr.shift() // [2,3,4]

#,unshift: 在原数组开头添加一个元素

let arr = [1,2,3,4]
arr.unshift(0) // [0,1,2,3,4]

#，reverse: 颠倒原数组中元素的顺序

let arr = [1,2,3]
arr.reverse() // [3,2,1]