Fluent Streams : une bibliothèque pour la manipulation d'itérables riches

Oeuvre : https://code-art.pictures/

Imaginez une bibliothèque qui :

• Comme Ramda, fournit de nombreuses fonctions utiles pour la manipulation des itérables
• Lit des méthodes familières, comme les méthodes itératives Array standard
• N'essaie pas de remplacer les éléments JavaScript intégrés comme Array, Set ou le protocole d'itération
• Comme Java Streams, inclut facultatif pour distinguer clairement entre « aucune valeur » et « non défini comme valeur »
• Est compact en termes de taille de paquet

Je n'en ai pas trouvé une qui réponde à tous ces besoins, alors j'ai créé ma petite bibliothèque — fluent-streams.

Parler n’est pas cher. Montre-moi le code

Les 3 meilleurs mots dans un texte

const words = ['Lorem', 'ipsum', /* ... */]
stream(words)
  .groupBy(word => word.toLowerCase())
  .map(([word, list]) => [word, list.length])
  .sortBy(([, length])  => -length)
  .take(3)
  .toArray()

// => ['ut', 3], ['in', 3], ['dolor', 2]

Entiers premiers entre eux

// Endless stream of 2..999 integers
const randomInts = continually(() => 
  2 + Math.floor(Math.random() * 998)
)

randomInts
  .zip(randomInts)
  .filter(([a, b]) => gcd(a, b) === 1)
  .distinctBy(pair => stream(pair).sortBy(i => i).join())
  .take(10)

// => [804, 835], [589, 642], [96, 145], ...

• Les flux peuvent être infinis, comme indiqué, mais vous pouvez les limiter aux n premiers éléments en utilisant la méthode take(n)
• Un flux peut être réutilisé plusieurs fois, même en parallèle. En effet, les flux sont sans état et stockent uniquement une référence à l'entrée. L'état est créé uniquement lorsque le flux génère un itérateur.

Générez un jeu de cartes

const deck = streamOf('♠', '♥', '♣', '♦')
  .flatMap(suit =>
    streamOf<string number>(
      'A',
      ...range(2, 11),
      'J',
      'Q',
      'K'
    ).map(rank => `${rank}${suit}`)
  )

// => 'A♠', '2♠', '3♠', ...
</string>

Et jouez au poker Hold'em !

  const playersNum = 2
  const [flop, turn, river, ...hands] = deck
    .takeRandom(3 + 1 + 1 + playersNum * 2)
    .zipWithIndex()
    .splitWhen((_, [, j]) =>
      j === 3            // flop
      || j === 4         // turn
      || j >= 5          // river
         && j % 2 === 1  // ...players' hands
    )
    .map(chunk =>
      // Unzip index
      chunk.map(([card]) => card)
    )

// flop = ['3♦', '9♣', 'J♦']
// turn = ['4♣']
// river = ['7♦']
// hands = ['J♠', '4♥'], ['10♠', '8♥']

Le premier joueur a une paire de valets au flop, tandis que le deuxième joueur obtient une quinte, mais uniquement sur la rivière. Qui va gagner ?

Cela doit être bon marché

Tout ce qui précède peut être réalisé avec uniquement des structures de données natives. Cependant, le code écrit avec Fluent Streams se lit mieux. Bien que rendre le code plus lisible soit un objectif parfaitement valable, le coût pour y parvenir devrait être faible en termes de charge cognitive, de taille de bundle et de performances.

Et c’est exactement le cas avec Fluent Streams ! Voici pourquoi :

• Aucune courbe d'apprentissage : l'API semble familière et ressemble aux méthodes Array standard. C’est facile à ajouter et tout aussi facile à supprimer.
• Pas de réinvention : la bibliothèque ne crée pas de nouvelles structures de données ou de nouveaux protocoles : elle s'appuie sur les fonctionnalités déjà robustes de JavaScript.
• Impact minimal sur le bundle : avec seulement 8,5 Ko minifiés, il est léger. Si votre projet inclut déjà React et ses bibliothèques satellites, qui pèsent des centaines de kilo-octets, cet ajout est à peine perceptible.
• Traitement paresseux : la bibliothèque traite les éléments paresseusement, ce qui peut réduire l'utilisation de la mémoire et améliorer l'efficacité dans les longs pipelines en évitant la copie de données intermédiaires inutiles.

Mises en garde

La bibliothèque est expédiée non transpilée vers ES5. Cette décision est motivée par le désir de conserver une petite taille de bundle, obtenue en tirant parti des fonctionnalités d'ES6 qui permettent des itérations avec un code très concis, notamment des générateurs. Cependant, seules les fonctionnalités linguistiques largement prises en charge sont utilisées.

Si vous êtes toujours en train de transpiler vers ES5, vous pouvez utiliser la bibliothèque en la transpilant vous-même et en ajoutant des polyfills. Sachez cependant que cela augmentera la taille du bundle, ce n’est donc pas recommandé. Au lieu de cela, cela pourrait être l'occasion idéale pour revoir la configuration de votre build et adopter les fonctionnalités JavaScript modernes.

Amusez-vous à coder !

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!