Programmation fonctionnelle en JavaScript: The ARITY et TULLES

annonces

Nous retournons à la série postale dédiée à la programmation fonctionnelle en JavaScript. Nous expliquions l’importance de l’utilisation de méthodes chaînées pour obtenir un code plus expressif.

Dans la publication d’aujourd’hui, nous allons parler des inconvénients qui nous apportent l’utilisation de méthodes chaînées. Nous apprendrons une nouvelle façon de moduler notre code et de prendre beaucoup plus partie à la réutilisation du code via le concept de tuyaux pouvant être utilisé dans la programmation fonctionnelle.

Nous expliquerons ce que les tuyaux sont et le Caractéristiques Nous avons besoin qu’ils répondent aux fonctions pour pouvoir réaliser cette sensation de code qui circule au moyen d’un tuyau connecté. Nous expliquerons ce que l’arité est et la façon dont la touche ou le programme peut nous aider à gérer la complexité des prérominations élevées.

Comme toujours, vous m’avez à votre disposition dans les commentaires au cas où cela pourrait résoudre tous vos doutes . Commençons:

Le problème des méthodes chaînées

Les méthodes chaînées nous aident beaucoup à écrire un meilleur code. Nous pourrions le voir dans le chapitre précédent. Cela ne change pas. Cependant, nous trouvons un gros problème aux méthodes chaînées.

Si nous nous souvenons, par exemple, la méthode « Filtre » de ES5, la méthode renvoie un nouvel objet de tableau contenant à nouveau les méthodes. D’où la magie de pouvoir concaténer. Malheureusement, le modèle est une arme à double tranchant puisque les méthodes sont tellement couplées au type d’objet qui nous confonde nous donne très peu de flexibilité de la réutilisation.

avec des méthodes concatérées Nous sommes obligés d’utiliser uniquement l’ensemble des opérations qui fournissent l’objet lui-même. Il serait idéal que nous puissions briser cette chaîne et dans l’assemblée, nous pourrions organiser des fonctions à notre envie. Les méthodes chaînées ne sont pas la solution, nous devrons donc nous chercher une autre alternative.

Les tuyaux

et l’alternative se présente sous la forme d’un tuyau. Si, avec les méthodes enchaînées, nous avons perdu l’expressivité et gagnez trop de couples, avec l’organisation de fonctions dans un tuyau que nous aurions pu avoir le contraire.

La clé pour organiser des fonctions dans des pipelines est celle de pouvoir avoir une L’arsenal des fonctions non couplées qui peuvent être exécutées de manière séquentielle. Comme dans un tuyau, nos fonctions dépenseraient des états d’une fonction à une autre. Les paramètres de sortie d’une fonction supposeront les paramètres d’entrée des éléments suivants.

De cette manière, je peux créer des pièces de code très indépendantes, qui sont conformes à une fonction spécifique et que par la composition de ses entrées et de leurs départs Peut créer un programme majeur.

Si nous utilisons la notation utilisée à Haskell, nous pouvons mieux expliquer cela. Nous pouvons définir des fonctions de cette manière:

<nombre_funcion> :: <entradas> -> <salidas>

À la fin, il est très similaire à la définition de Lambdas, que dans ce cas, nous sommes plus intéressés par la connaissance de savoir quoi Les types de données entrent et ils laissent une fonction. C’est la spécification d’une boîte noire.

J’ai vu cela, voyons un exemple. Je peux composer à l’aide de pipelines les fonctions suivantes:

f :: A -> Bg :: B -> C

où F et G sont le nom d’une fonction et A, B et C sont des types différents. Dans ce cas car la sortie de F correspond au type de B. Je pouvais les exécuter comme s’il s’agissait d’une tuyau:

g(f(A)); // donde se devuelve C

Ceci qu’au premier regard semble évident, vous pouvez nous aider beaucoup. Il ne sera pas facile de l’obtenir dans des environnements plus complexes, car il y aura des fonctions qui renvoient des objets qui ne peuvent pas être réutilisés.

Cependant, c’est quelque chose que nous devons prendre en compte lors de la conception de fonctions. Il est important de voir que nous devons faire des fonctions compatibles les unes avec les autres. À la sensibilisation à cela dans le processus de conception, il est important que nous considérons deux facteurs: la compatibilité des types d’entrées et de sorties et de l’aridation des fonctions.

Compatibilité de type

Nous disons que la compatibilité de type fait référence aux types de sortie de fonction concerne les types des paramètres d’entrée d’un autre. Ce n’est pas un problème que nous devons nous inquiéter beaucoup en JavaScript, car à la fin lors de la réunion avec une langue faiblement typique, nous pouvons avoir beaucoup plus de flexibilité.

à la fin, c’est ce qu’on appelle généralement des «types de canards», je ne suis pas tellement intéressé par les tuyaux JavaScript que les types sont identiques et que l’objet qui renvoie une fonction, se comporte comme le type de Le paramètre d’entrée en attente de ma prochaine fonction. C’est-à-dire que si cela va comme un canard et un grazna comme un canard, c’est un canard. Si un objet se comporte un type spécifique et que les attributs que j’attends dans ce type, c’est ce que c’est ce gars. C’est la bonne chose et la mauvaise chose à propos de JavaScript.

Si nous voulions faire de nos fonctions strictement compatibles, une bonne idée serait d’utiliser des documents. Je laisse à nouveau la discussion de Micael Galicic ici au cas où vous êtes intéressé par cette alternative.

Par conséquent, lorsque nous conçons des fonctions, nous devons avoir très clairement les gars avec lesquels nos fonctions jouent. Imaginez que nous voulons créer un système qui compte tenu d’un numéro d’identité, nous supprimons les espaces et les scripts pour mieux fonctionner avec elle. Nous concevons deux fonctions comme celles-ci:

trim :: String -> Stringnormalize :: String -> String

Nous avons créé deux fonctions compatibles pour la composition depuis l’entrée de l’une correspondant au type de l’autre. Ils sont également commutatifs car si je manquez de la garniture, puis normaliser, je reçois le même résultat que si j’exécute d’abord « normaliser » puis « couper ». Voyons la mise en œuvre.

Vale, l’exemple est très stupide, mais il est important que nous enissons au courant à l’avenir. Nous aurons plus de problèmes dans JavaScript avec le nombre de paramètres pouvant permettre une fonction.

l’arité et les tuples

Nous connaissons par ARITY au nombre de paramètres d’entrée qui acceptent une fonction . Il est courant de l’indiquer comme une longueur d’une fonction.

L’arité d’une fonction peut faire gagner une fonction en complexité. Qu’une fonction accepte plusieurs paramètres rend tous les arguments à calculer en premier, cela les fait perdre de polyvalence.

En outre, il est possible que la complexité interne d’une fonction soit supérieure (ce qui est une grande aridité Ne comporte pas toujours une complexité plus élevée, cela peut simplement être un symptôme de celui-ci).

ayant des arrêts élevés en outre, cela nous fait avoir des fonctions moins flexibles. Les fonctions avec un paramètre (ou des unarais) sont généralement plus flexibles car, en général, ils n’ont qu’une seule responsabilité unique, effectuent un certain type de fonctionnement ou calculer sur le paramètre d’entrée et renvoient le résultat.

Malheureusement, Dans la vie réelle, il est compliqué de ne rencontrer que des unis. Cependant, nous pouvons faire une fonction renvoie une tuple, de cette manière la fonction suivante serait une unarry et j’aurais déjà tout l’état dont vous avez besoin.

Un tupla est une liste de valeurs finie et ordonnée des valeurs Qui sont représentés comme suit (A, B, C). Les tuples sont un ensemble de valeurs immuables, qui ont une relation et qui peuvent être utilisés pour renvoyer plusieurs valeurs à d’autres fonctions.

Nous pouvons simuler ce comportement avec un objet JSON ou avec des objets de réseau, dès que possible. Comme on voit alors avec les tuples, nous avons plus d’avantages:

• sont immuables.
• Évitez la création de nouveaux types. Plusieurs fois pour créer des cours pour une seule utilisation spécifique peuvent être assez peu coûteux pour le développeur.
• Évitez de créer des tableaux hétérogènes: Travailler avec ces matrices hétérogènes suppose beaucoup de vérifications de type. Les matrices sont mieux les utiliser lorsque vous travaillez avec des collections d’objets avec le même type.

Le problème que nous avons, c’est que bien que les TUPES soient un élément dans la plupart des langages de programmation fonctionnelle comme Scala, dans JavaScript, il n’y a rien qui soutient les tuples. La meilleure option pour cela est que nous croyons une petite librairie qui prend en charge les tuples. L’option que l’attention de Luis propose dans votre livre est la suivante:

const Tuple = function () { const typeInfo = Array.prototype.slice.call(arguments, 0); const _T = function () { const values = Array.prototype.slice.call(arguments, 0); if (values.some((val) => val === null || val === undefined) { throw new ReferenceError('Tuples may not have any null values'); } if (values.length !== typeInfo.length) { throw new TypeErro('Tuple arity does not match its prototype'); } values.map(function (val, index) { this = checkType(typeInfo)(val); }, this); Object.freeze(this); }; _T.prototype.values = function () { return Object.keys(this).map(function (k) { return this; } } return _T;}

uf, oui, beaucoup de chiha à couper. Si nous réalisons que c’est une fonction tuple qui retournera une classe. La fonction sert de manière à indiquer la taille et les types des éléments de la tupla. Par conséquent, nous pouvons le faire, par exemple:

const Status = Tuple(Number, String);

« statut » est une classe. Si vous vous donnez à Tubble, il retourne _t. Au moyen d’un clouser, une classe préconfigurée est renvoyée avec ce dont nous avons besoin. Magique. Maintenant, nous pouvons définir un nouveau tuple de cette manière:

const status = new Status(401, 'No Authorize');

lorsque nous avons instancié « statut », il fait un chèque que les valeurs null ne se produisent pas et que La taille de la tuple créée correspond à la taille de la tupla prédéfinie. Il vérifie également que le type qui s’est passé est attendu.

Enfin, il a une méthode afin que nous puissions obtenir les valeurs du format de tableau.Il est très utile car si nous utilisons la destruction de la destruction, nous pouvons obtenir les valeurs de la tuupes de cette manière:

const = status.values();

Good … ils Ne sont pas les plus confortables des tuples du monde en JavaScript, mais nous avons des moyens de le simuler. Et si nous n’avions pas à les simuler? Et si JS et Seriale leur apportaient-ils? Et bien, TholyScript nous aide à cela. Je pourrais faire ceci:

let status: ; status = ; // OK status = ; // Error

beaucoup mieux :). Je répète, gardez à l’esprit dockscript, est venu de rester.

Les tuples sont un bon mécanisme pour éviter l’arrestation de fonctions. Cependant, il existe une autre méthode appelée curricorie, qui nous aidera non seulement à l’arité, mais c’est un bon mécanisme d’améliorer la modularité et la réutilisabilité, mais … je pense que nous allons partir ici pour aujourd’hui

Conclusion

Comprendre les tuyaux et leurs moyens de les utiliser, nous aidera à développer un code plus lisible. Nous continuerons à parler de techniques nécessaires pour couvrir tous les concepts présents dans les tuyaux.

Pour l’instant, je pense que c’est une bonne étape sachant que cette conception fonctionne de manière à avoir une arité réduite et de connaître la Types des paramètres d’entrée et de sortie de nos fonctions, nous nous aiderons à faire un code beaucoup plus maintenu, modulable et réutilisable.

Nous lisons 🙂

PD: Je laisse le conceptuel Carte de cette entrée:

Postes de programmation fonctionnelle JavaScript précédente:

Introduction

1. Programmation fonctionnelle en JavaScript
2. Programmation fonctionnelle en JavaScript: Les objets
3. fonctionnaire Programmation en JavaScript: Fonctions

Contrôle du débit fonctionnel

1. Programmation fonctionnelle en JavaScript: Méthodes fonctionnelles
2. Programmation fonctionnelle en JavaScript: Le Récursion

Modularité fonctionnelle

1. Programmation fonctionnelle en JavaScript: ARITY ET TULLES
2. Programmation fonctionnelle en JavaScript: Le programme

Couverture Image | Flickr