Ramda JS NPM (Comment ça marche pour les développeurs)

Immutabilité

L'immutabilité est un principe clé dans Ramda. Les fonctions de Ramda ne modifient pas les données d'entrée mais renvoient de nouvelles structures de données à la place. Cette approche réduit le risque d'effets de bord, rendant le code plus prévisible et plus facile à déboguer.

Style fonctionnel plus pur

La bibliothèque Ramda pour les programmeurs JavaScript encourage l'utilisation de fonctions pures, qui sont des fonctions produisant toujours le même résultat pour les mêmes entrées et n'ayant pas d'effets de bord. Les fonctions pures augmentent la fiabilité du code et le rendent plus facile à tester.

Créer des pipelines fonctionnels

Ramda fournit des outils pour composer des fonctions, permettant aux développeurs de construire des opérations complexes en combinant des fonctions plus simples. Cette composabilité facilite la création d'un code fonctionnel, plus lisible et maintenable.

Currying

Toutes les fonctions de Ramda sont automatiquement curried. Le currying consiste à transformer une fonction qui accepte plusieurs arguments en une séquence de fonctions, chacune prenant un seul argument. Cette fonctionnalité permet l'application partielle, où certains arguments d'une fonction peuvent être fixés, créant une nouvelle fonction qui prend les arguments restants.

Immutabilité

L'exemple suivant illustre les caractéristiques d'immutabilité de Ramda. Il ne mute jamais les données de l'utilisateur ; au lieu de cela, il ajoute à la structure de données originale :

const originalArray = [1, 2, 3, 4];
const newArray = R.append(5, originalArray);

// Log the original array and the new augmented array
console.log(originalArray); // [1, 2, 3, 4]
console.log(newArray);      // [1, 2, 3, 4, 5]

const originalArray = [1, 2, 3, 4];
const newArray = R.append(5, originalArray);

// Log the original array and the new augmented array
console.log(originalArray); // [1, 2, 3, 4]
console.log(newArray);      // [1, 2, 3, 4, 5]

Fonctions Pures

Considérez une fonction qui additionne deux nombres :

const add = R.add;
console.log(add(2, 3)); // 5

const add = R.add;
console.log(add(2, 3)); // 5

Puisque R.add est une fonction pure, elle retournera toujours le même résultat pour les mêmes entrées.

Composition de Fonctions

La composition de fonctions permet de construire des opérations complexes à partir de fonctions plus simples. Ramda fournit R.compose et R.pipe dans ce but :

const multiplyBy2 = R.multiply(2);
const subtract1 = R.subtract(R.__, 1);
const multiplyAndSubtract = R.compose(subtract1, multiplyBy2);

// First multiply by 2, then subtract 1
console.log(multiplyAndSubtract(5)); // 9

const multiplyBy2 = R.multiply(2);
const subtract1 = R.subtract(R.__, 1);
const multiplyAndSubtract = R.compose(subtract1, multiplyBy2);

// First multiply by 2, then subtract 1
console.log(multiplyAndSubtract(5)); // 9

Currying

Le currying transforme une fonction pour qu'elle puisse être appelée avec moins d'arguments que ce qu'elle attend. Ramda applique le currying à toutes ses fonctions par défaut :

// A function to add three numbers
const addThreeNumbers = (a, b, c) => a + b + c;

// Currying the function using Ramda's R.curry
const curriedAddThreeNumbers = R.curry(addThreeNumbers);

// Create a new function by partially applying two arguments
const add5And10 = curriedAddThreeNumbers(5)(10);

// Call the new function with the remaining argument
console.log(add5And10(2)); // 17

// A function to add three numbers
const addThreeNumbers = (a, b, c) => a + b + c;

// Currying the function using Ramda's R.curry
const curriedAddThreeNumbers = R.curry(addThreeNumbers);

// Create a new function by partially applying two arguments
const add5And10 = curriedAddThreeNumbers(5)(10);

// Call the new function with the remaining argument
console.log(add5And10(2)); // 17

Lentilles

Les lentilles de Ramda sont une caractéristique puissante pour la manipulation immuable des données. Elles fournissent un moyen de se concentrer sur une partie spécifique des structures de données de base, permettant des lectures et mises à jour sûres.

const person = { name: 'John', address: { city: 'New York', zip: 10001 } };

// Create a lens that focuses on the 'address' property
const addressLens = R.lensProp('address');

// Create a lens that focuses on the 'city' within the 'address' object
const cityLens = R.lensPath(['address', 'city']);

// Update city to 'Los Angeles' immutably
const updatedPerson = R.set(cityLens, 'Los Angeles', person);

// Retrieve the updated city from the new person object
console.log(R.view(cityLens, updatedPerson)); // Los Angeles

// Verify no mutation occurred on the original object
console.log(person.address.city); // New York

const person = { name: 'John', address: { city: 'New York', zip: 10001 } };

// Create a lens that focuses on the 'address' property
const addressLens = R.lensProp('address');

// Create a lens that focuses on the 'city' within the 'address' object
const cityLens = R.lensPath(['address', 'city']);

// Update city to 'Los Angeles' immutably
const updatedPerson = R.set(cityLens, 'Los Angeles', person);

// Retrieve the updated city from the new person object
console.log(R.view(cityLens, updatedPerson)); // Los Angeles

// Verify no mutation occurred on the original object
console.log(person.address.city); // New York

Transducteurs

Les transducteurs permettent des pipelines de transformation de données efficaces en combinant les étapes de filtrage, de mappage et de réduction en un seul passage sur les données.

const numbers = [1, 2, 3, 4, 5];

// Define functions to identify even numbers and double any number
const isEven = x => x % 2 === 0;
const double = x => x * 2;

// Create a transducer combining filtering and mapping operations
const transducer = R.compose(R.filter(isEven), R.map(double));

// Apply the transducer to transform the list
const result = R.transduce(transducer, R.flip(R.append), [], numbers);

console.log(result); // [4, 8]

const numbers = [1, 2, 3, 4, 5];

// Define functions to identify even numbers and double any number
const isEven = x => x % 2 === 0;
const double = x => x * 2;

// Create a transducer combining filtering and mapping operations
const transducer = R.compose(R.filter(isEven), R.map(double));

// Apply the transducer to transform the list
const result = R.transduce(transducer, R.flip(R.append), [], numbers);

console.log(result); // [4, 8]

Style sans point

Ramda encourage un style de programmation fonctionnelle sans point, dans lequel les fonctions sont définies sans mentionner explicitement leurs arguments. Cela conduit à un code plus propre et plus concis.

// Calculate the sum of elements in a list
const sum = R.reduce(R.add, 0);

// Calculate the average value using sum and length
const average = R.converge(R.divide, [sum, R.length]);

console.log(average([1, 2, 3, 4, 5])); // 3

// Calculate the sum of elements in a list
const sum = R.reduce(R.add, 0);

// Calculate the average value using sum and length
const average = R.converge(R.divide, [sum, R.length]);

console.log(average([1, 2, 3, 4, 5])); // 3

Qu'est-ce qu'IronPDF ?

IronPDF for Node.js, developed by Iron Software, est une bibliothèque puissante qui permet aux développeurs de créer, manipuler et rendre des documents PDF directement dans un environnement Node.js. Elle offre un ensemble complet de fonctionnalités pour générer des PDFs à partir de diverses sources telles que des URLs, des fichiers HTML et des chaînes HTML, rendant le tout très polyvalent pour les applications basées sur le web. La bibliothèque simplifie les opérations complexes de PDF, permettant une conversion et un rendu simples avec un code minimal.

Avec IronPDF, les développeurs peuvent facilement intégrer la génération de PDF dans leurs flux de travail, profitant de sa fonctionnalité robuste et de sa facilité d'utilisation, particulièrement utile pour créer des rapports dynamiques, des factures et d'autres fonctionnalités documentées dans les applications web modernes.

Installation

Tout d'abord, installez le package IronPDF for Node.js en utilisant npm :

 npm i @ironsoftware/ironpdf

Utilisation de base

Pour utiliser IronPDF en combinaison avec Ramda, importez les modules requis :

import { PdfDocument } from "@ironsoftware/ironpdf";
import * as R from "ramda";

import { PdfDocument } from "@ironsoftware/ironpdf";
import * as R from "ramda";