函数式编程

高阶函数

---

JavaScript 的函数其实都指向某个变量。既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。高阶函数可以用来抽象通用的问题，让我们可以只关注于我们需要实现的目标。

函数作为参数

function forEach (array, fn) {
  for (let i = 0; i < array.length; i++) {
    fn(array[i])
  }
}

function filter (array, fn) {
  const res = []
  for (let i = 0; i < array.length; i++) {
    if(fn(array[i])) {
      res.push(array[i])
    }
  }
  return res
}

const arr = [1, 2, 4, 5, 2]

forEach(arr, console.log)
console.log(filter(arr, function (item) {
  return item % 2 === 0
}))

函数作为返回值

function makeFn () {
  let msg = 'hello function'
  return function () {
    console.log(msg)
  }
}

const fn = makeFn()
fn() // hello function

makeFn()() // hello function

应用

once函数，即只执行一次的函数，比如说支付情况，无论用户点多少次，这个函数都只执行一次。

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

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

pay(1) // 支付了1元
pay(2)
pay(3)

常用的高阶函数

// forEach()
function forEach(arr, fn) {
    for(let i = 0; i < arr.length; i++) {
        fn(arr[i])
    }
}
// test
let arr = [1, 5, 3, 7, 6, 8];
forEach(arr, (item) => {
    // do something for each item
    console.log(item)
})



// filter()
function filter(arr, fn) {
    let results = []
    for(let i = 0; i < arr.length; i++) {
        if (fn(arr[i])) {
            result.push(arr[i])
        }
    }
    return results
}
// test
let arr = [1, 5, 3, 7, 6, 8];
filter(arr, item => {
    return item % 2 === 0;
})



// map()
const map = (arr, fn) => {
    let results = []
    for (let value of arr) {
        result.push(fn(value))
    }
    return results
}
// test
arr = map(arr, v => v * v)



// every()
const every = (arr, fn) => {
    let result = true
    for (let value of result) {
        result = fn(value)
        if(!result) {
            break
        }
    }
    return result
}
// test
let res = every(arr, v => v > 10)



// some()
const some = (arr, fn) => {
    let result = false
    for (let value of result) {
        result = fn(value)
        if(result) {
            break
        }
    }
    return result
}
// test
let res = some(arr, v => v > 10)

 

闭包

---

概念

一个函数内包含有另一个函数，而被包含内部函数调用了其外部（父级）函数中的参数，此时，即使函数执行结束，被调用到的参数也无法释放，也即形成了闭包。

 

本质

函数在执行的时候，会放到一个执行栈上，当函数执行完毕之后便会从执行栈上移除。但是，如果作用域中的成员参数被外部引用，则不能释放，因此内部函数依然可以访问外部函数的成员。

案例

function makePower(power) {
    return function(number) {
        return Math.power(number, power)
    }
}

//test
let power2 = makePower(2)
let power3 = makePower(3)

console.log(power2(4))
console.log(power3(4))
console.log(power2(5))

 

 

 

本文地址：https://blog.csdn.net/qq_37750365/article/details/107532170