柯里化

一、装饰器 In [1]: def fn(): ...: '''this is fn''' ...: In [2]: help(fn) Help on function fn in module __main__: fn() this is fn In [4]: fn.__doc__ # 存储函数的文档 Out[4]: 'this is fn' In [5]: fn.__name__ # 存储函数的名字 Out[5]: 'fn' In [6]: dir(fn) # 查看fn 所有的 内嵌方法 Out[6]: ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__

函数柯里化 理解： 指的是将一个接受多个参数的函数 变为 接受一个参数返回一个函数的固定形式，这样便于再次调用，例如f(1)(2) 例如 常见的add函数 function add(a,b){ return a+b } // 变为 function curry(fn){ var firstArgs=Array.prototype.slice.call(arguments,1) //这里，arguments的第一个参数是fn,所以从1开始 var _cur=function(){ var nextArgs=[...arguments] var allArgs=firstArgs.concat(nextArgs) return fn.apply(this,allArgs) } return _cur } var add1=curry(add,10) add1(10) //20 add1(20) //30 当前的柯里化curry接收一个函数，并且返回一个函数用于处理剩下的参数，因此可以连续两次调用，即curr(add,10)(20) 返回30 难度升级 此时一个简单的柯里化完成，但是如果遇到f(1)(2)(3)...等连续调用多次的时候，则会显得无力，此时需要一个更加复杂的柯里化，递归柯里化 function add(){ return [].reduce.call(arguments,

1、有人提问： 　　这段代码是dva的基础代码 import React from 'react'; import { connect } from 'dva'; function IndexPage() { return ( <div> this is a div </div> ); } export default connect()(IndexPage); 　　【请问】最后一行这个 connect()(IndexPage) 怎么理解？ 　　还要请教：这两个括号的在一起的写法是es6语吗？（我在阮一峰的es6指南中没找到这个语法说明，我要看箭头函数一章，还是到哪章去了解这个 ()() ） 　　老司机能提供一个纯js的双括号函数案例吗？ 　　p.s. 　　我思考了一下：之前见过 function(){}() 这样的最后放一个括号表示立即执行。请问和上边的这个有相通的地方吗？ 　　谢谢您前来科普帮助，感谢老司机指路----O(∩_∩)O //▼补充代码， import React from 'react'; import { connect } from 'dva'; import { Table, Pagination, Popconfirm, Button } from 'antd'; import { routerRedux } from 'dva/router';

假设我们现在有一个方法add，参数需要a和b,目前只有参数a，那我们构想，能否先在a存起来 待b出现了我们再放b上去并执行方法？ 　　　这是今天的业务场景描述 下面开始： 　　　　// 材料函数 　　　　function add(a,b) { 　　　　　　return a+b } 　　　　//curry化的方法函数 　　　　function curry(fn){ 　　　　　　var args = Array.prototype.slice.call(arguments,1); //arguments不是真正意义的数组 需要借用数组方法转换成数组 　　　　　　return function(){ 　　　　　　 var args2 = Array.prototype.slice.call(arguments);//这里的arguments指的是当前函数的作用的arguments 　　　　　 　var argsList = args.concat(args2); 　　　　　　　return fn.apply(null, argsList);//这里没有指定函数指针 因此this默认指向全局window 　　} } 　　　　var addFn = curry(add, 1);//我们利用闭包时传入的函数和 argument,得以保存下来 现在我们传入 a值 并不知道 b值 　　　　//。

柯里化函数 -- 期待固定数量参数 //固定参数 function fixedCurryParams(fn) { var _args = [].slice.call(arguments, 1) return function () { var newArgs = _args.concat([].slice.call(arguments, 0)) 　　　return fn.apply(this, newArgs) } }　　//期望参数 参数没给够就一直期望 可以累积参数 function curry(fn, length) { var length = length || fn.length return function () { if (arguments.length < length) { var combined = [fn].concat([].slice.call(arguments, 0)) return curry(fixedCurryParams.apply(this, complay), length - arguments.length) } else { return fn.apply(this, arguments) } } } 测试 function add(a, b, c, d) { return a + b + c + d; } var

// bind 方法原理模拟 // bind 方法的模拟 Function.prototype.bind = function (context) { var self = this; var args = [].slice.call(arguments, 1); return function () { return self.apply(context, args); } } Function.prototype.bind = function(context, ...args){ 　　return () => { 　　　　return this.apply(context, args); 　　} } function add (a, b) { 　　return a + b; } console.log(add.bind(null, 2, 3)()) const curry = (fn, ...arg) => { let all = arg || [], length = fn.length; return (...rest) => { let _args = all.slice(0); _args.push(...rest); if (_args.length < length) { return curry.call(this, fn, ..._args); } else

柯里化函数 什么是柯里化？ 在计算机科学中，柯里化 （Currying） 是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Schnfinkel 和 Gottlob Frege 发明的。 function curry(fn) { function _c(restNum, argsList) { return restNum === 0 ? fn.apply(null, argsList) : function(x) { return _c(restNum - 1, argsList.concat(x)); }; } return _c(fn.length, []); // 递归开始 } function add(a,b){ return function(c){ return a+b+c; } } curry(add)(1)(2)(3); 需求分析 我们需要一个 curry 函数，它接受一个待柯里化的函数为参数，返回一个用于接收一个参数的函数，接收到的参数放到一个列表中，当参数数量足够时，执行原函数并返回结果。 实现方式 简单思考可以知道，柯里化部分配置函数的步骤数等于 fn 的参数个数

柯里化 描述 柯里化算是特殊的偏函数，把一个多参数函数转换成多个单参数函数，也就是说把一个具有n个参数的函数转换成n个一元函数 示例 // 正常写法 function add ( a , b ) { return a + b } const resAdd = add ( 2 , 3 ) console . log ( resAdd ) // 5 // 柯里化 function currieAdd ( a ) { return function ( b ) { return a + b } } const resCurrie = currieAdd ( 2 ) ( 3 ) console . log ( resCurrie ) // 5 通用写法 上面的示例代码比较简单，如果有十几个参数呢？所以需要一个通用柯里化的写发 代码的关键点在于 闭包，调用柯里化函数（currie）返回另外一个函数（_myFn），通过闭包缓存真正执行运算的函数（fn）和参数（args） 通过返回的函数传递参数，并进行判断，如果参数已经传递够了，就执行函数（fn)并返回结果，如果参数还没传递完，则继续返回函数（_myFn）接收参数 // 柯里化一个函数 function currie ( fn ) { // 利用闭包缓存传递进来的参数 const args = [ ] return function _myFn

/* 补充：柯里化(Currying)，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数） 的函数并且返回接受余下的参数而且返回结果的新函数的技术。柯里化的目的是，减少代码冗余，以及增加 代码的可读性，同时在参数复用、延迟运行等方面也有用处。下面看一个与柯里化有关的经典例子： */ // 实现一个add方法，使计算结果能够满足类似如下的预期： // add(1)(2)(3) = 6; // add(1, 2, 3)(4) = 10; // add(1)(2)(3)(4)(5) = 15; var add_currying=function(...rest){ var sum=0; for(let item of rest){ sum+=item; } var add_back = (...rest) => { for(let item of rest){ sum+=item; } return add_back; }; add_back.toString = () => sum; return add_back; } console.log(add_currying(1,2,3)); //6 console.log(add_currying(1,2)(3,4)); //10 console.log(add_currying(1,2)(3)(4,5)); //15

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> 利用了闭包，保存了对各个方法参数的引用，虽然方法出栈了，但是变量对象还保存在内存中 计算体积 function volume(h) { return (h) => { return (l) => { return (w) => { return h * l w; } } } } var result = volume(10)(20)(30); //如果说想计算固定高度的volume function volume100() { } var volume100 = volume(100); //不用每次都传相同的参数100 var result1 = volume100(10)(20); var result2 = volume100(40)(50); 计算折扣 function discount(discount) { return (price) => { return price * discount; } } const tenPercentDiscount = discount(0.1) const twentyPercentDiscount = discount(0.2); 来源： oschina 链接： https://my.oschina.net/u/2285087/blog/3155798