Explication détaillée du currying de la fonction JavaScript

Qu'est-ce que le currying

Le currying est un processus de conversion qui transforme une fonction qui accepte plusieurs paramètres Devient une fonction qui accepte un seul paramètre (Annotation : le premier paramètre de la fonction d'origine). Si d'autres paramètres sont nécessaires, renvoie une nouvelle fonction qui accepte les paramètres restants et renvoie le résultat.

Idée de fonction Ke Lihua : une idée de prétraitement js le principe d'utiliser l'exécution de fonction pour former une portée qui n'est pas détruite ; , Stockez tout le contenu qui doit être prétraité dans cette portée qui n'est pas détruit, et renvoyez une petite fonction. Désormais, nous exécuterons de petites fonctions dans la petite fonction, nous pouvons effectuer des opérations pertinentes sur celles précédemment stockées. valeurs ;

La fonction currying joue principalement le rôle de prétraitement

Le rôle de la méthode bind : Pass ; in Ceci dans la méthode de rappel est prétraité en tant que contexte

principe d'implémentation de la méthode bind 1 Le code est le suivant :

/**
* bind方法实现原理1
* @param callback [Function] 回调函数
* @param context [Object] 上下文
* @returns {Function} 改变this指向的函数
*/
function bind(callback,context) {
var outerArg = Array.prototype.slice.call(arguments,2);
// 表示取当前作用域中传的参数中除了fn,context以外后面的参数；
return function (){
var innerArg = Array.prototype.slice.call(arguments,0);//表示取当前作用域中所有的arguments参数；
callback.apply(context,outerArg.concat(innerArg));
}
}

Le morceau de code suivant imite le principe d'implémentation de la liaison sur la chaîne de prototypes

/**
* 模仿在原型链上的bind实现原理(柯理化函数思想)
* @param context [Object] 上下文
* @returns {Function} 改变this指向的函数
*/
Function.prototype.mybind = function mybind (context) {
var _this = this;
var outArg = Array.prototype.slice.call(arguments,1);
// 兼容情况下
if('bind' in Function.prototype) {
return this.bind.apply(this,[context].concat(outArg));
}
// 不兼容情况下
return function () {
var inArg = Array.prototype.slice.call(arguments,0);
inArg.length === 0?inArg[inArg.length]=window.event:null;
var arg = outArg.concat(inArg);
_this.apply(context,arg);
}
}

Fonction currying (Currying)

en informatique, le currying est une technique qui transforme une fonction qui accepte plusieurs paramètres en une fonction qui accepte un seul paramètre (le premier paramètre de la fonction d'origine), et renvoie une nouvelle fonction qui accepte les paramètres restants et renvoie un résultat

Le currying consiste à transmettre certains paramètres à l'avance pour obtenir une fonction simple. Mais les paramètres transmis au préalable sont enregistrés dans la fermeture, il y aura donc des caractéristiques particulières. Par exemple :

Exemple :

var adder = function(num) {
return function(y) {
return num + y;
}
}
var inc = adder(1);
var dec = adder(-1);
//inc, dec现在是两个新的函数，作用是将传入的参数值（+/-）1
alert(inc(99));//100
alert(dec(101));//100
alert(adder(100)(2));//102
alert(adder(2)(100));//102

Ce qui précède est l'explication détaillée du currying de la fonction JavaScript. Pour plus de contenu connexe, veuillez prêter attention au site Web PHP chinois (www.php.cn. )!