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;

Allerdings können Sie das Problem mit dem folgenden Codeabschnitt nicht erkennen:

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

Dies ist ein Codeabschnitt, den ich aus „JS Functional Programming Guide“ entnommen habe Tatsächlich können wir mithilfe der obigen Regeln schließen, dass

der Funktion callback

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

entspricht, sodass die Funktion wie folgt vereinfacht werden kann:

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

Vereinfachen Sie weiter :

var getServerStuff = ajaxCall;

Auf diese Weise stellten wir fest, dass ein so langes Programm vergeblich geschrieben wurde.

Funktion kann sowohl als Parameter als auch als Rückgabewert verwendet werden. Es ist ein wichtiges Merkmal von Funktionen höherer Ordnung, aber wenn man nicht aufpasst, kann man leicht ins Schleudern geraten.

2. Funktionscurry (Curry)

Um es auf den Punkt zu bringen: Was ist Funktionscurry? Funktion Curry besteht darin, eine Funktion aufzurufen, indem nur ein Teil ihrer Parameter übergeben wird, und sie eine Funktion zurückgeben zu lassen, die die übrigen Parameter verarbeitet. Es klingt verwirrend, ist aber eigentlich sehr einfach. Tatsächlich bedeutet es, die Variablen der Funktion aufzuteilen und sie aufzurufen:

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

Für das erste Beispiel müssen zwei Parameter übergeben werden. Die aufrufende Methode

ist f1. f1(f,x)

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

Beachten Sie, dass

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

Wir werden

ä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);

In der Tat ist dieses Beispiel unangemessen. Obwohl

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

Hier ist ein sehr klassisches Beispiel:

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

Da

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.

3. Weitere Gedanken zum Funktions-Currying

Wenn wir das Beispiel im vorherigen Abschnitt nehmen, behandeln wir die Funktion

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

gibt die Funktion

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

Tatsächlich wird die Verwendung von

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

anstelle von

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);

Anti-Curring bedeutet, die ursprünglichen festen Parameter oder diesen Kontext als Parameter auf die Zukunft zu verschieben.

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:

Übergeben Sie

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

an

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

Nur die Übergabe eines Teils der Parameter an die Funktion wird normalerweise als Teilanwendung bezeichnet, wodurch der Boilerplate-Code erheblich reduziert werden kann.

Natürlich müssen die beiden von der Funktion

übergebenen Parameter nicht unbedingt Funktion + Nichtfunktion enthalten. Sie können beide Funktionen oder beide Nichtfunktionen sein.

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:

Es ist nicht so, dass „Currying“ für die funktionale Programmierung sinnvoll ist. Vielmehr führt die funktionale Programmierung zwar dazu, dass Funktionen als erstklassige Bürger behandelt werden, sie führt jedoch unweigerlich zu der Verwendung von „Currying“. Es kommt also nicht zustande, weil „es Sinn macht“. Da es existiert, können wir natürlich erforschen, wie wir dieses Phänomen nutzen können.

Übung:

Analyse: Die Funktion der Funktion

// 通过局部调用（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);
};

besteht darin: ein String-Array zu übergeben, die Strings, die „q“ enthalten, herauszufiltern und a zu bilden Ein neues Array wird zurückgegeben.

filterQsWir können die Funktion

durch die folgenden Schritte erhalten:

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!