Anti-curry en JS

Anti-currying

Au contraire, le rôle de l'anti-currying est d'élargir l'applicabilité des fonctions, de sorte que les fonctions qui sont à l'origine des fonctions appartenant à un objet spécifique peuvent être utilisé par n'importe quel objet Le utilisé .
consiste à convertir la signature de fonction donnée ci-dessous,

obj.func(arg1, arg2)

, en une fonction formulaire portant la signature suivante :

func(obj, arg1, arg2)

Voici la description formelle du décaissement.

Par exemple, une simple implémentation de ce qui suit :

Function.prototype.uncurrying = function() {    var that = this;    return function() {        return Function.prototype.call.apply(that, arguments);
    }
};function sayHi () {    return "Hello " + this.value +" "+[].slice.call(arguments);
}var sayHiuncurrying=sayHi.uncurrying();
console.log(sayHiuncurrying({value:'world'},"hahaha"));

Explication :

• uncurrying est une méthode définie sur le prototype de Function, cette méthode peut donc être utilisée pour toutes les fonctions. Lors de l'appel : sayHiuncurrying=sayHi.uncurrying(), donc ceci pointe vers la fonction sayHi (généralement, dans la méthode prototype, cela ne pointe pas vers le prototype de l'objet prototype, mais vers l'objet appelant, où l'objet appelant est un autre Les fonctions sont également des objets en javascript)

• call.apply(that, arguments) Définissez cela comme contexte de la méthode d'appel, puis transmettez les arguments à la méthode d'appel, Dans l'exemple précédent, qui pointe en fait vers sayHi, donc appeler sayHiuncurrying(arg1, arg2, ...) équivaut à sayHi.call(arg1, arg2, ...);

• sayHi. call (arg1, arg2, ...), la fonction d'appel traite arg1 comme le contexte de sayHi, puis transmet les paramètres restants tels que arg2,... à sayHi, donc l'équivalent final est arg1.sayHi(arg2,...) ;

• Cela équivaut donc à sayHiuncurrying(obj,args) est égal à obj.sayHi(args).

Enfin, regardons les choses dans l'autre sens. En fait, l'anti-currying équivaut à convertir la forme originale de sayHi(args) en sayHiuncurrying(obj,args), créant ainsi. le champ d'utilisation de sayHi généralisé. Exprimé de manière plus abstraite, l'anti-currying sans currying permet de convertir l'appel x.y(z) d'origine en un appel sous la forme de y(x',z). En supposant que x' est x ou d'autres objets, cela élargit le champ d'utilisation de la fonction.

Fonction de décurrying universelle

Dans l'exemple ci-dessus, le décurrying est écrit dans le prototype, ce qui n'est pas bon. Nous pouvons en fait encapsuler le décurrying dans une fonction distincte

var uncurrying= function (fn) {    return function () {        var args=[].slice.call(arguments,1);        return fn.apply(arguments[0],args);        
    }    
};

Lorsque utilisé, appelez uncurrying et transmettez une fonction fn existante. La fonction decurrying renverra une nouvelle fonction. Le premier paramètre réel accepté par la nouvelle fonction sera lié au contexte de ceci dans fn, et les autres paramètres le seront. Passé à fn comme argument.

var test="a,b,c";
console.log(test.split(","));var split=uncurrying(String.prototype.split);   //[ 'a', 'b', 'c' ]console.log(split(test,','));                   //[ 'a', 'b', 'c' ]

var $ = {};
console.log($.push);                          // undefinedvar pushUncurrying = uncurrying(Array.prototype.push);
$.push = function (obj) {
    pushUncurrying(this,obj);
};
$.push('first');
console.log($.length);                        // 1console.log($[0]);                            // firstconsole.log($.hasOwnProperty('length'));      // true

jqueryBibliothèque" emprunte la méthode push de Array lors de son implémentation. Nous savons que les objets n'ont pas de méthode push, donc console.log(obj.push) renvoie undefined. Array peut être utilisé pour gérer le push. La méthode de tableau native (moteur js) conserve l'attribut length du pseudo-. objet du tableau et membres du tableau.

var indexof=uncurrying(Array.prototype.indexOf);
$.indexOf = function (obj) {    return indexof(this,obj);
};
$.push("second");
console.log($.indexOf('first'));              // 0console.log($.indexOf('second'));             // 1console.log($.indexOf('third'));              // -1

var call= uncurrying(Function.prototype.call);var fn= function (str) {
    console.log(this.value+str);
};var obj={value:"Foo "};
call(fn, obj,"Bar!");                       // Foo Bar!

L'attaque de la fonction générale sans courbure

var uncurrying= function (fn) {    return function () {        var context=[].shift.call(arguments);        return fn.apply(context,arguments);
    }
};

Bien sûr, si vous avez encore besoin d'améliorer la grille B, alors vous pouvez. Cela peut être comme ça :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!