高阶函数 map filter foreach every some once

高阶函数：

使代码更加简单灵活，我们调用函数时，只要关注实现的目标

高阶函数：有哪些 forEach filter map every some
我们一个一个来说

1.foreach 它是一个循环数组；
 

// 调用高阶函数  forEach
let arr = [1, 2, 3, 4]

arr.forEach(item => {
    console.log(item);
})
console.log("====分割线====");
// 结果 1 2 3 4
// forEach 它是一个循环数组
// forEach 内部代码 模仿一个
// 取名为getForEach

function getForEach(arr, fn) {
    for (let i = 0; i < arr.length; i++) {
        fn(arr[i])
    }
}
getForEach(arr, item => {
    console.log(item);
});
// 结果 也是 1 2 3 4

2.filter:它是一个条件判断是否满足，返回一个新的数组

// 调用高阶函数  filter
let arr = [1, 2, 3, 4]

arr = arr.filter(item => {
    return item > 2
})
console.log(arr);
console.log("====分割线====");
// 结果  3 4
// fitler 它是一个条件判断是否满足，返回一个新的数组
// filter 内部代码 模仿一个
// 取名为getFilter
function getFilter(arr, fn) {
    let list = []
    for (let i = 0; i < arr.length; i++) {
        if (fn(arr[i])) {
            list.push(arr[i])
        }
    }
    return list
}
console.log(getFilter(arr, item => item > 2));

// 结果 也是  3 4

3.map 它是每个元素都输出，可以对数组操作组成新的数组

// 调用高阶函数 map
let arr = [1, 2, 3, 4]

arr = arr.map(item => item * 2)

console.log(arr);
// 结果  2 4 6 8
console.log("====分割线====");

// map 它是每个元素都输出，可以对数组操作组成新的数组
// map 内部代码 模仿一个
// 取名为getMap

let array = [1, 2, 3, 4]
function getMap(arr, fn) {
    let list = []
    for (let item of arr) {
        list.push(fn(item))
    }
    return list
}
let list = getMap(array, item => item * 2)

console.log(list);

// 结果 也是 2 4 6 8

4.every 它是判断类型，一个条件不满足就为false，否则全部为true

// 调用高阶函数 every
let arr = [1, 2, 3, 4]

arr = arr.every(item => item > 1)

console.log(arr);
// 结果  false 
console.log("====分割线====");

// every 它是判断类型，一个条件不满足就为false，否则全部为true
// every 内部代码 模仿一个
// 取名为getEvery

let array = [1, 2, 3, 4]
function getEvery(arr, fn) {
    let falg = true;
    for (let item of arr) {
        falg = fn(item);
        if (!falg) {
            break
        }
    }
    return falg
}
let list = getEvery(array, item => item > 1)
console.log(list); //false
console.log(getEvery(array, item => item > 0)); //true

5.some 它也是判断类型，一个条件满足就为true，和every对立

// 调用高阶函数 some
let arr = [1, 2, 3, 4]

arr = arr.some(item => item > 5)

console.log(arr);
// 结果  false 
console.log("====分割线====");

// some 它也是判断类型，一个条件满足就为true，和every对立
// some 内部代码 模仿一个
// 取名为getSome

let array = [1, 2, 3, 4]
function getSome(arr, fn) {
    let falg = false;
    for (let item of arr) {
        falg = fn(item);
        if (falg) {
            break
        }
    }
    return falg
}
let list = getSome(array, item => item == 5)
console.log(list); //false
console.log(getSome(array, item => item == 4)); //true

6. once 函数只执行一次

   function once(fn){
      let flag = false;
      return function(){
        if(!flag){
          flag  = true;
          return  fn.apply(this, arguments)
        }
      }
    }

    let getOnce = once(function(money){
      console.log(`支付了${money}元`)
    })
    getOnce(5)
    getOnce(5)
    getOnce(5)