Detaillierte Einführung in einige Gedanken zum Currying von JavaScript-Funktionen

1. Fallstricke von Funktionen höherer Ordnung

Bevor wir Currying lernen, schauen wir uns zunächst den folgenden Code an:

var f1 = function(x){
    return f(x);
};
f1(x);

Viele Schüler können es Es ist ersichtlich, dass diese Schriften sehr albern sind, da die Funktionen f1 und f gleichwertig sind. Es besteht keine Notwendigkeit, sie direkt in eine solche Ebene zu packen. var f1 = f;

var getServerStuff = function(callback){
  return ajaxCall(function(json){
    return callback(json);
  });
};

der Funktion callback

function(json){return callback(json);};

var getServerStuff = function(callback){
  return ajaxCall(callback);
};

var getServerStuff = ajaxCall;

. f(x,y,z) -> f(x)(y)(z)

ist f1. f1(f,x)

var f1 = function(f，x){
    return f(x);
};

zu einer neuen Funktion wird, da f als Funktionsvariable übergeben wird. f1

ändern und den f1-Verschluss verwenden, um es in der folgenden Form zu schreiben. Dann wird die aufrufende Methode zu f1 und die erhaltenen Ergebnisse sind genau die gleichen . Damit ist das Curry von f1(f)(x) abgeschlossen. f1

var f1 = function(f){
    return function(x){
        return f(x);
    }
};
var f2 = f1(f);
f2(x);

eine neue Funktion ist, ist f1 und f2 völlig gleichwertig , oder kam herum. f

['11', '11', '11'].map(parseInt) //[ 11, NaN, 3 ]
['11', '11', '11'].map(f1(parseInt)) //[ 11, 11, 11 ]

zwei Parameter akzeptiert, kommt es beim direkten Aufruf zu Problemen bei der Hexadezimalkonvertierung. Bitte beachten Sie „Unwilling to Be Separated“. Artikel. parseInt

, var f2 = f1(parseInt) bewirkt, dass f2 von der Annahme zweier Parameter zu einer neuen Funktion wechselt, die nur einen Parameter akzeptiert, und löst so dieses Hexadezimalkonvertierungsproblem. Nachdem Sie unser parseInt-Paket bestanden haben, können Sie die korrekten Ergebnisse ausführen. f1

Einige Studenten sind der Meinung, dass dies keine Curry-Bewerbung ist. Ich denke, dass alle Studenten darüber diskutieren sollten.

nicht direkt, sondern als Parameter , was wird das Ergebnis sein? Schauen wir uns das folgende Beispiel an: f(x)f Angenommen,

zurück, der Gültigkeitsbereich von f1 zeigt auf g und die Funktion g dient als Parameter von xs. Schließlich können wir es in der folgenden Form schreiben: fg

var f1 = function(f,xs){
    return g.call(xs,f);
};

als Decurrying bezeichnet. Zum Beispiel: f1g.call(xxx)

var forEach = function(xs,f){
    return Array.prototype.forEach.call(xs,f);
};
var f = function(x){console.log(x);};
var xs = {0:'peng',1:'chen',length:2};
forEach(xs,f);

Es kann Funktionen erheblich vereinfachen, vorausgesetzt, Sie gewöhnen sich daran.

Abgesehen vom Ent-Curry, was wäre, wenn wir Curry machen wollten

f1Mit Hilfe der Schließung können wir es in der folgenden Form schreiben:

var f1 = function(f){
    return function(xs){
        return g.call(xs,f);
    }
};
var f2 = f1(f);
f2(xs);

, und wir können die neue Funktion f erhalten. f1f2

Natürlich müssen die beiden von der Funktion

f1Ich persönlich denke, dass Currying nicht notwendig ist und unbekannte Schüler möglicherweise Schwierigkeiten beim Lesen haben, aber es kann uns helfen, die funktionale Programmierung in JS zu verstehen, und was noch wichtiger ist, wir werden es tun. Sie werden sich beim Lesen ähnlichen Codes nicht fremd fühlen . Luo Chen über Zhihu hat es sehr gut ausgedrückt:

Übung:

// 通过局部调用（partial apply）移除所有参数
var filterQs = function(xs) {
  return filter(function(x){ return match(/q/i, x);  }, xs);
};
//这两个函数原题没有，是我自己加的
var filter = function(f,xs){
    return xs.filter(f);
};
var match = function(what,x){
    return x.match(what);
};

filterQsWir können die Funktion

a. filter传入的两个参数，第一个是回调函数，第二个是数组，filter主要功能是根据回调函数过滤数组。我们首先将filter函数柯里化：

var filter = function(f){
    return function (xs) {
        return xs.filter(f);
    }
};

b. 其次，filter函数传入的回调函数是match，match的主要功能是判断每个字符串是否匹配what这个正则表达式。这里我们将match也柯里化：

var match = function(what){
    return function(x){
        return x.match(what);
    }
};
var match2 = match(/q/i);

创建匹配函数match2，检查字符串中是否包含字母q。

c. 把match2传入filter中，组合在一起，就形成了一个新的函数:

var filterQs =  filter(match2);
var xs = ['q','test1','test2'];
filterQs(xs);

从这个示例中我们也可以体会到函数柯里化的强大。所以，柯里化还有一个重要的功能：封装不同功能的函数，利用已有的函数组成新的函数。

4. 函数柯里化的递归调用

函数柯里化还有一种有趣的形式，就是函数可以在闭包中调用自己，类似于函数递归调用。如下所示:

function add( seed ) {
    function retVal( later ) {
        return add( seed + later );
    }
    retVal.toString = function() {
        return seed;
    };
    return retVal;
}
console.log(add(1)(2)(3).toString()); // 6

add函数返回闭包retVal，在retVal中又继续调用add，最终我们可以写成add(1)(2)(3)(...)这样柯里化的形式。
关于这段代码的解答，知乎上的李宏训同学回答地很好：

每调用一次add函数，都会返回retValue函数；调用retValue函数会调用add函数，然后还是返回retValue函数，所以调用add的结果一定是返回一个retValue函数。add函数的存在意义只是为了提供闭包，这个类似的递归调用每次调用add都会生成一个新的闭包。

5. 函数组合(compose)

函数组合是在柯里化基础上完成的：

var compose = function(f,g) {
  return function(x) {
    return f(g(x));
  };
};
var f1 = compose(f,g);
f1(x);

将传入的函数变成两个，通过组合的方式返回一个新的函数，让代码从右向左运行，而不是从内向外运行。

函数组合和柯里化有一个好处就是pointfree。

pointfree 模式指的是，永远不必说出你的数据。它的意思是说，函数无须提及将要操作的数据是什么样的。一等公民的函数、柯里化（curry）以及组合协作起来非常有助于实现这种模式。

// 非 pointfree，因为提到了数据：name
var initials = function (name) {
  return name.split(' ').map(compose(toUpperCase, head)).join('. ');
};

// pointfree
var initials = compose(join('. '), map(compose(toUpperCase, head)), split(' '));

initials("hunter stockton thompson");
// 'H. S. T'

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in einige Gedanken zum Currying von JavaScript-Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!