一、静态方法

1.Array.from(); 将类数组对象转换为数组

   一般具有指向对象元素的数字索引下标和length属性的对象为类数组对象；

常见的类数组对象有

• document.getElementsByClassName() 的返回结果（实际上许多DOM方法的返回值都是类数组）；
• 特殊变量 arguments 对象

et arr1 = Array.from('hello')
console.log(arr1);               
// [ 'h', 'e', 'l', 'l', 'o' ]

而在ES5中，我们需要通过  Array.prototype.slice.call('类数组对象') 来转化。

2.Array.of();        将传入的参数转换为数组

Array.of总是返回参数值组成的数组。如果没有参数，就返回一个空数组。

Array.of(3, 11, 8) // [3,11,8]

Array.of(3) // [3]

Array.of(3).length // 1

Array.of() // []

二、实例方法

1.Array.prototype.find()        查找第一个符合条件的元素

     参数是一个回调函数.

 该方法返回第一个满足条件的元素 或者 undefined

let arr=[1,2,3,2,3];

    let result=arr.find((value)=>{

        return item>2

    })

    console.log(result)        //3

2.Array.prototype.findIndex();        查找第一个符合条件的元素的下标

参数回调函数

返回第一个满足条件的元素的索引或者-1

let arr=[1,2,3,2,3];

    let result=arr.findIndex((value)=>{

        return value>2

    })

    console.log(result)        //2   索引

3.Array.prototype.includes();         检查数组是否包含某个元素

      返回true/false

let arr = [1,2,3,4,5];

console.log(arr.includes(8))        //false

4.Array.prototype.fill();         用来填充数组

console.log(new Array(5).fill(8))        //[ 8, 8, 8, 8, 8 ]

5.Array.prototype.keys(); Array.prototype.values(); Array.prototype.entries()

Array.prototype.keys();

Array.prototype.values();

Array.prototype.entries()

let arr   = [2, 3, 4, 5, 6, 2];

let keys=arr.keys();

let values = arr.values();

let entries = arr.entries();

console.log(keys, values, entries);

  //keys,values,entries变量当前是迭代器对象,

 // 迭代器对象实现了Iterator接口，只要有实现了Iterator接口就可以for-of遍历

通过for-of循环，循环出数组的索引

for(let i of keys){

        console.log(i)

}                //0 1 2 3 4 5

for(let v of values){

        console.log(v)

}

同时输出数组的索引和内容

for(let e of entries){

  console.log(e)

}  
//
[ 0, 2 ]
[ 1, 3 ]
[ 2, 4 ]
[ 3, 5 ]
[ 4, 6 ]
[ 5, 2 ]

6.Array.prototype.flat()

flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。

Array.prototype.flat() 用于将嵌套的数组“扁平化”，将二维数组变成一维数组。该方法返回一个新数组，对原数据没有影响。 语法：

var newArray = arr.flat([depth])

参数：depth 可选，指定要提取嵌套数组的结构深度，默认值为 1。

返回值：一个包含数组与子数组中所有元素的新数组。

var arr1 = [    [0, 1],
    [2, 3],
    [4, 5]
]
var arr2 = arr1.flat()
console.log(arr2)   // [0, 1, 2, 3, 4, 5]

var arr = [1, 2, [3, 4, [5, 6]]];
console.log(arr.flat());   // [1, 2, 3, 4, [5, 6]]
console.log(arr.flat(2));  // [1, 2, 3, 4, 5, 6]

使用 Infinity，可展开任意深度的嵌套数组：

var arr3 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
console.log(arr3.flat(Infinity));  // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

flat() 方法会移除数组中的空项：

var arr4 = [1, 2, , 4, 5];
console.log(arr4.flat());   // [1, 2, 4, 5]

flat()方法的替代方案：使用reduce()和concat()

var arr1 = [    [0, 1],
    [2, 3],
    [4, 5]
]
var arr2 = arr1.reduce((arr,item)=>arr.concat(item),[])
console.log(arr2)  // [0, 1, 2, 3, 4, 5]

数组降维

Array.prototype.myFlat = function (num = 1) {

      if (num < 1) {

        return this

      }

      const res = []

      for (let i = 0; i < this.length; i++) {

        if (Array.isArray(this[i])) {

          res.push(...this[i].myFlat(num - 1))

         } else {

          res.push(this[i])

        }

      }

      return res

    }

预测笔试题 可能让你实现这个flat函数

var arr =[[10,20,30],40,50,[[60,70],80,[90,[110],100]]]
Array.prototype.myflat=function(count=Infinity){
    var arr=[]
    for (var i=0;i<this.length;i++){
        if(this.[i].constructor==Array&&count>0){
            var newarr=this[i].myflat(count-1)
            for(var j=0;j<newarr.length;j++){
                arr.push(newarr[j])
            }
        }else{
            arr.push(this[i])
        }
    }
    return arr
}
var re2=arr.myflat(1)
console.log(re2)

数组的类

　　数组的类是Array

数组的定义

　　var arr=[元素]

　　var arr=new Array(3) 数字3，代表有三个元素或者三个空位

　　如果数组定义采用 new 实例，类中跟的是一个数字 n ，代表有 n 个元素

　　var arr=new Array("6") 有一个元素，并且这个元素是6

数组的方法

当然数组的方法还有很多，我这里就收集了一些而已

• of 方法

　　1. Array 类上的方法

　　2. var arr=Array.of(4);console.log(arr); //4 返回一个元素为4的数组

• foreach 方法

　　1. 原型上的一个方法，用于对数组遍历，返回值是undefined

 var arr = ["xiaopang", "xiaohe", "xiaoxin"];

　　arr.forEach((item,index)=>{

　　　　console.log(index)

　　})

　　3. foreach 没有返回值

 

• map 方法

　　1. 遍历数组(原型上的一个方法，返回值是一个数组，所以必须加 return 返回值)，将数组一一映射成一个新的数组，内部一定要使用return

 var arr = ["xiaopang", "xiaohe", "xiaoxin"];

　　var as=arr.map((item,index)=>{

　　return item+"123"

　　})

　　console.log(as)

• filter 方法

　　1. 过滤 从数组中找出所有符合条件的元素，并返回一个新的数组，不改变原有数组

　　2. return true 就保留原来的数组，return false 就不保留

　　3. 当return 的条件成立就是 true ，不成立就是 false

 var arr=[

　　{"name":"xiaopang","age":10},

　　{"name":"xiaohe","age":20},

　　{"name":"xiaoxin","age":25},

　　{"name":"pangpang","age":13}

　　]

　　var as=arr.filter((item,index)=>{

　　　　return item.age>13

　　})

　　console.log(as)

　　5. var as=arr.filter((item,index)=>{

　　　　return item.age>13

　　})

　　console.log(as)

　　数组里有符合条件的，所以是 true ，所以返回符合条件的新数组

• find 方法

　　1. 对数组逐个查找，当返回值为 true 说明查找到，直接返回结果，不再往下查找了

2. var as=arr.find((item,index)=>{

　　　　return item.age>13

　　})

　　console.log(as)

• every 方法

　　1. 看数组中的每个元素是否都满足条件，都满足条件返回的是 true，如果有一个不满足，返回值就是 false

　　2. var arr=[

　　{"name":"xiaopang","age":10},

　　{"name":"xiaohe","age":20},

　　{"name":"xiaoxin","age":25},

　　{"name":"pangpang","age":13}

　　]

　　var as=arr.every((item,index)=>{

　　return item.age<=13

　　})

　　console.log(as)

• some 方法

　　1. 看数组中的元素，是否有满足条件的，有就true ，没有 就是false 　　

2. var arr=[

　　{"name":"xiaopang","age":10},

　　{"name":"xiaohe","age":20},

　　{"name":"xiaoxin","age":25},

　　{"name":"pangpang","age":13}

　　]

　　var as=arr.some((item,index)=>{

　　return item.age<=13

　　})

　　console.log(as)

• reduce 方法

　　1. 迭代执行

　　2. var arr=[1,2,3,4,5,6,7,8,9,10];

　　var as=arr.reduce((prev,item)=>{

　　// prev 航一次返回值

　　// item 数组的元素，从第二个开始 　　

console.log(prev);

　　　　return prev+item;

　　})

　　console.log(as) //55

　　3. 注意: 1.从第二个元素开始执行，因为第一个元素没有上一个

　　2.第一次执行的返回的是第一个元素 reduce() 的参数是一个回调函数，回调函数中可以放三个参数，第一个 prev 代表上一次执行后的返回值，第二个 item 当前元素，第三个 index 索引值

　　3. 如果想让 reduce 从第一个元素开始执行 (默认为第二个)，可以在回调函数之后加一个参数，就可以让初始有个默认值 　　

累加器

let arr = [1,2,3]
// prev为前一个对象
// cur为当前对象
// index为当前序列
// arr为当前数组
let sum = arr.reduce(function(prev,cur,index,arr){
    return prev + cur
},0)
console.log(sum) // 6

获取数组中最大值。

let arr = [1,2,3]
let max = arr.reduce(function(prev,cur){
    Math.max(prev,cur)
})
console.log(max) // 3

数组去重

let arr = [1,2,3,3]
let res = arr.reduce(function(prev,cur){
    prev.indexOf(cur) == -1 && prev.push(cur)
    return prev
},[])
console.log(res) // [1,2,3]

面试题

将一个数组转换成对象，属性是数组的元素，属性值是元素的个数 　　　　

解答；

　　　　　　var arr=["item","tom",,"jack","item","jack"];

　　　　　　var as=arr.reduce((prev,item)=>{

　　　　　　　　if(item in prev){

　　　　　　　　　　prev[item]++

　　　　　　　　}

　　　　　　　　else{

　　　　　　　　　　prev[item]=1;

　　　　　　　　}

　　　　　　　　return prev

　　　　　　},{})

　　　　　　console.log(as);