javascript函数式编程(函数柯里化,惰性函数,递归,纯函数)

1.函数柯里化:传递给函数一部分参数来调用它,让他返回一个函数去处理剩下的函数。

//柯里化之前
        function add(x, y) {
            return x + y
        }
        add(1, 2)//3
//柯里化之后
        function addX(y) {
            return function (x) {
                return x + y
            }
        }
        addX(2)(1)//3

//利用bind
        function foo(p1, p2) {
            this.val = p1 + p2;
        }
        var bar = foo.bind(null, 'p1');
        var baz = new bar('p2');
        console.log(baz.val)

柯里化是一种“预加载”函数的方法,通过传递较少的参数,得到一个已经记住了这些参数的新函数,某种意义上,这是一种对参数的“缓存”,是一种非常高效的函数编写方法。

2.惰性函数:通过重写函数的方式,在第二次调用该函数时直接返回结果。

        var xhr = null
        function ajax() {
            if (window.XMLHttpRequest) {
                xhr = new XMLHttpRequest();
            } else {
                xhr = new ActiveXObject("Microsoft.XMLHTTP");
            }
            ajax = () => xhr;
            return xhr
        }

这样在第二次调用该函数的时候就不会走if语句了

3.递归(调用函数自身)

        // 1.普通递归,深度过大,会造成堆栈溢出
        // sum(5+sum(4))
        // sum(5+4+sum(3))
        // sum(5+4+3+sum(2))
        // sum(5+4+3+2+sum(1))
        // sum(5+4+3+2+1)
        // sum(5+4+3+3)
        // sum(5+10)
        // 15
        function sum1(x) {
            if (x === 1) return 1;
            return x + sum(x - 1);
        }
        // 2.尾递归
        // sum(5,0)
        // sum(4,5)
        // sum(3,9)
        // sum(2,12)
        // sum(1,14)
        // sum(15)
        function sum2(x, temp) {
            if (x === 1) return x + temp;
            return sum2(x - 1, x + temp);
        }

4.纯函数

  • 如果给定相同的参数,则返回相同的结果(也称为确定性)。
  • 它不会引起任何副作用。

如果给出相同的参数,它返回相同的结果。 想象一下,我们想要实现一个计算圆的面积的函数。

不是纯函数会这样做,接收radius 作为参数,然后计算radius * radius * PI

let PI = 3.14;

const calculateArea = (radius) => radius * radius * PI;

calculateArea(10); // returns 314.0

为什么这是一个不纯函数?原因很简单,因为它使用了一个没有作为参数传递给函数的全局对象。

现在,想象一些数学家认为圆周率的值实际上是42并且修改了全局对象的值。

不纯函数得到10 * 10 * 42 = 4200。对于相同的参数(radius = 10),我们得到了不同的结果。

修复它:

let PI = 3.14;

const calculateArea = (radius, pi) => radius * radius * pi;

calculateArea(10, PI); // returns 314.0

现在把 PI 的值作为参数传递给函数,这样就没有外部对象引入。

  • 对于参数radius = 10PI = 3.14,始终都会得到相同的结果:314.0
  • 对于 radius = 10 和 PI = 42,总是得到相同的结果:4200函数是 JS 中的一级公民

5.函数是 JS 中的一级公民

  • 从常量和变量中引用它。
  • 将其作为参数传递给其他函数。
  • 作为其他函数的结果返回它。

其思想是将函数视为值,并将函数作为数据传递。通过这种方式,我们可以组合不同的函数来创建具有新行为的新函数。

const sum = (a, b) => a + b;
const subtraction = (a, b) => a - b;

const doubleOperator = (f, a, b) => f(a, b) * 2;

doubleOperator(sum, 3, 1); // 8
doubleOperator(subtraction, 3, 1); // 4

6.高阶函数

当我们讨论高阶函数时,通常包括以下几点:

  • 将一个或多个函数作为参数
  • 返回一个函数作为结果
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值