数组的方法

1.普通for循环

对数组遍历对普通用法

let arr=[1,2,3,4,]
for(let i=0;
i<arr.length;i++){
console.log(arr[i])
}
//1,2,3,4

2，forEach()

//代替普通for循环，无返回值，里面接收两个个参数，后面一样，都可以接受两个参数

一. 函数，可以接收三个参数1：数组的每一项，2：每一项的index，3：数组自身；

let arr=[1,2,3,4,]
arr.forEach((val,index,arr) => {
    console.log(val,index,arr)
});
//1 0 [ 1, 2, 3, 4 ]
//2 1 [ 1, 2, 3, 4 ]
//3 2 [ 1, 2, 3, 4 ]
//4 3 [ 1, 2, 3, 4 ]

二.this

let arr=[1,2,3,4,]
arr.forEach((val,index,arr) => {
    console.log(val,index,arr)
});
//window 1 0 [ 1, 2, 3, 4 ]
//window 2 1 [ 1, 2, 3, 4 ]
//window 3 2 [ 1, 2, 3, 4 ]
//window 4 3 [ 1, 2, 3, 4 ]

** 注意没有返回值

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

3. map()

对数给进行遍历，有返回值，也是接收两个参数，使用map都要有返回值，如果不用返回值就可以直使用forEach 了，返回值是一个新的数组，

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

 //1 0 (4) [1, 2, 3, 4]
 //2 1 (4) [1, 2, 3, 4]
 //3 2 (4) [1, 2, 3, 4]
 //4 3 (4) [1, 2, 3, 4]
 //(4) [undefined, undefined, undefined, undefined]
---------------------------------------------------------------
//有返回值

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

可以重新对数据整理，** 会改变原来的arr值

let arr=[
{name:'foo',age:20},
{name:'bar',age:20},
{name:'tom',age:18},
{name:'boo',age:23}
]

let newArr=arr.map((item)=>{
    let obj={}
    obj.name = item.name;
    obj.age = item.age += 1
});

 console.log(newArr);

//(4) [{…}, {…}, {…}, {…}]
//0: {name: 'foo', age: 21}
//1: {name: 'bar', age: 21}
//2: {name: 'tom', age: 19}
//3: {name: 'boo', age: 24}
//length: 4
//[[Prototype]]: Array(0)

console.log(arr);
//(4) [{…}, {…}, {…}, {…}]
//0: {name: 'foo', age: 21}
//1: {name: 'bar', age: 21}
//2: {name: 'tom', age: 19}
//3: {name: 'boo', age: 24}
//length: 4
//[[Prototype]]: Array(0)

4.filter()

对数组过行筛选过滤，返回满足条件的项，组成一个数组

let arr=[1,2,3,4,5]
let b=arr.filter(item=>{
    return item >3
})
console.log(b)
//(2) [4, 5]
------------------------

let arr = [
        {title:'新闻',read:1000,hot:true},
        {title:'疫情',read:1000,hot:false},
        {title:'aaa',read:1000,hot:true},
        {title:'bbb',read:1000,hot:false},
        {title:'ccc',read:1000,hot:true},
    ]
let b = arr.filter(item => {
        return item.hot
    })
console.log(b)

//(3) [{…}, {…}, {…}]
//0: {title: '新闻', read: 1000, hot: true}
//1: {title: 'aaa', read: 1000, hot: true}
//2: {title: 'ccc', read: 1000, hot: true}
//length: 3
//[[Prototype]]: Array(0)

5.some()

类似查找功能，只用数组里面一个满足条件就返回true

let arr = [
        {title:'新闻',read:1000,hot:true},
        {title:'疫情',read:1000,hot:false},
        {title:'aaa',read:1000,hot:true},
        {title:'bbb',read:1000,hot:false},
        {title:'ccc',read:1000,hot:true},
    ]
    let b = arr.some(item => {
        return item.title==='ccc'
    })
    console.log(b)//true

6.every()

数组的每一项都要符合条件才返回true

let arr = [
        {title:'新闻',read:1000,hot:true},
        {title:'疫情',read:1000,hot:false},
        {title:'aaa',read:1000,hot:true},
        {title:'bbb',read:1000,hot:false},
        {title:'ccc',read:1000,hot:true},
    ]
    let b = arr.some(item => {
        return item.read===1000
    })
    console.log(b)//true

7.reduce()

从左至右求数组的和，类似于阶乘

raduce(prev,cur,index,arr)prev上一次计算的结果，cur当前个，当前index(从1开始的)，arr自身

let arr = [1,2,3,4,5]
    let b=arr.reduce((prv,cur,index,arr)=>{
    console.log(index)
        return prv+cur
    })
    console.log(b)
//1
//2
//3
//4
//15

let arr = [1, 2, 3, 4, 5]
    let b = arr.reduce((prv, cur, index, arr) => {
        return prv * cur
    })
    console.log(b)//120

let arr =[2,2,3]
let b=arr.reduce((prv,cur,index,arr)=>{
        return prv ** cur
})
console.log(b)//64

//prv**cur-->2**3=2^3=8 es2017出现的幂的算法

2 ** 3=2^3=8,新的运算符** 想当于Math.pow(2,3)

8.reduceRight()

从右边至左，顺序是相反的

let arr = [1, 2, 3, 4]
    let b = arr.reduceRight((prv, cur, index, arr) => {
        console.log(prv,cur)
        return prv * cur
    })
    console.log(b)
//5 4
//20 3
//60 2
//120 1
//120

9.for...of...循环

arr.keys()数组的index

arr.entries()数组的某一项的index和value组成的数组

let arr = ['apple','banana','orange','tomato']
    for(let val of arr){
        console.log(val);
    }
//apple
//banana
//orange
//tomato
-------------------------------------------------
 let arr = ['apple','banana','orange','tomato']
    for(let index of arr.keys()){
        console.log(index);
    }
//0
//1
//2
//3
--------------------------------------------------
 let arr = ['apple','banana','orange','tomato']
    for(let item of arr.entries()){
        console.log(item);
    }
//[0, 'apple']
//[1, 'banana']
//[2, 'orange']
//[3, 'tomato']

10.'...'扩展运算符

Array.form()把argument这样的类数组转成数组,有length就基本上就可以转成数组

function show(){
      console.log(arguments)
  }
show(1,2,3,4)


// Arguments(4) [1, 2, 3, 4, callee: ƒ, Symbol(Symbol.iterator): ƒ]
// 0: 1
// 1: 2
// 2: 3
// 3: 4
// callee: ƒ show()
// length: 4
// Symbol(Symbol.iterator): ƒ values()
// [[Prototype]]: Object

---------------------------------------------
function show(){
      console.log(...arguments)
  }
show(1,2,3,4)//1 2 3 4
---------------------------------------------
function show(){
    let args=Array.from(arguments)
      console.log(args)
  }
show(1,2,3,4)//(4) [1, 2, 3, 4]
//也可以写成
----------------------------------
function show() {
        console.log([...arguments])
    }
show(1, 2, 3, 4)//(4) [1, 2, 3, 4]

let arr=[1,2,3,4,5]
let arr2=[...arr]
//[1,2,3,4,5]
--------------------
let arr=[1,2,3,4,5]
let arr2=Array.from(arr)//[1,2,3,4,5]
---------------------
let str="zhang"
    let arr=Array.from(str)
    console.log(arr)// ['z', 'h', 'a', 'n', 'g']

Array.fo():把一组值转成数组

let arr=Array.of('foo','bar','aaa')
    console.log(arr)//(3) ['foo', 'bar', 'aaa']

11.find()

查找第一个满足条件的值并返回，找不到返回undefined

let arr=[1,2,3,4,5,6]
    let b=arr.find((item,index,arr)=>{
        return item>3
    })
    console.log(b)//4
---------------------------
let arr=[1,2,3,4,5,6]
    let b=arr.find((item,index,arr)=>{
        return item>7
    })
    console.log(b)//undefined

12.findIndex()

返回第一个符合条件的位置，没找到返回-1

let arr=[1,2,3,4,5,6]
    let b=arr.findIndex((item)=>{
        return item>3
    })
    console.log(b)//3

13.arr.fill()

填充(填充的东西，开始位置，结束位置）

let arr=[1,2,3,4,5,6]
    arr.fill('a',1,4)
    console.log(arr)
//(6) [1, 'a', 'a', 'a', 5, 6]

14.includes()

str.includes()判断字符串的包含

判断数组里面有没有该值，没有返回false，有返回true

let arr=[1,2,3,4,4,5,4,3,4,6,7,5,6]
    let b=arr.includes(2)
    console.log(b)//true