欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

函数式编程

程序员文章站 2022-06-24 10:30:42
纯函数: 函数的返回结果只依赖与它的参数; 函数在执行过程中没有其他副作用; 函数式编程两个最基本运算: 合成:如果一个值要经过多个函数才能变成另一个值,那就可以把中间步骤合并成一个函数; 柯里化:有多个参数的函数转为单个参数的函数; 函数式编程特点: 函数是“第一等公民”; 只用表达式,不用语句; ......

高阶函数


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