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

La fonction ci-dessus est très claire et simple.

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.

Ainsi, une explication plus populaire de l'anti-currying peut être l'emprunt de fonctions, ce qui signifie que les fonctions peuvent accepter et traiter d'autres objets, et généraliser par emprunt pour élargir le champ d'utilisation de la fonction.

Ainsi, l'utilisation la plus courante du non-curry consiste à emprunter d'autres méthodes intégrées à Javascript sans avoir à toutes les implémenter vous-même.

La description textuelle est un peu alambiquée, alors continuons à regarder le code :

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' ]

split =uncurrying(String.prototype .split) Transmettez un fn spécifique au uncurrying, c'est-à-dire String.prototype.split. La fonction split a la fonction de String.prototype.split. Lorsque la fonction appelle split(test,','. ), le premier paramètre transmis est le contexte d'exécution fractionnée, et les paramètres restants sont équivalents au passage à la fonction String.prototype.split d'origine.

Regardez un autre exemple :

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

Cela imite un "similaire à

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.

Pour la même raison, nous pouvons continuer à avoir :

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

Par exemple, nous mettons en œuvre notre propre classe Lors de l'utilisation d'une bibliothèque, si certaines méthodes sont similaires aux méthodes natives, vous pouvez emprunter les méthodes natives via uncurrying.

On peut également annuler la méthode Function.prototype.call/apply, par exemple :

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!

De cette façon, les fonctions peuvent être utilisées de manière très flexible comme des « données » ordinaires, ce qui est similaire à la programmation fonctionnelle. Cette utilisation peut souvent être observée dans certaines bibliothèques de classes.

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

La fonction sans courbure ci-dessus est une version plus conforme aux habitudes de pensée et facile à comprendre. Ensuite, nous allons attaquer jusqu'au bout et regarder. à plusieurs autres versions :

Tout d'abord, Si la grille B est plus élevée, uncurrying peut aussi s'écrire ainsi :

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!