Chapitre 1 : Comment le multiparadigme étend les langues modernes

1.1 Modèle d'itérateur et fonctions de première classe dans les modèles de conception orientés objet
__1.1.1 Modèle d'itérateur du GoF
__1.1.2 Création d'un itérateur à partir d'un tableau de type
__1.1.3 Création d'un itérateur qui parcourt ArrayLike en ordre inverse
__1.1.4 Fonctions map évaluées paresseusement
__1.1.5 Intersection multiparadigme : Modèles d’itérateurs et fonctions de première classe
1.2 Fonctions génératrices qui créent des itérateurs à l'aide de la programmation impérative
__1.2.1 Générateur de grammaire de base
1.2.2 Fonction inverse écrite avec un générateur
1.3 Exemple du modèle d'itérateur en JavaScript : le protocole d'itération
1.3.1 Itérateurs et itérables
1.3.2 Interaction entre le langage et les itérables
__1.3.3 Les itérateurs créés avec des générateurs sont également itérables
1.4 Programmation fonctionnelle avec itérables
__1.4.1 Fonction forEach
__1.4.2 Fonction map
__1.4.3 Fonction de filtrage
__1.4.4 Combinaison de fonctions d'ordre supérieur
__1.4.5 Filtre amusant
1.5 Pourquoi le protocole itérable a été conçu comme une interface et non comme un héritage
__1.5.1 NodeList dans l'API Web est également itérable
__1.5.2 Pourquoi devrions-nous résoudre ce problème avec des interfaces plutôt qu'avec l'héritage ?
__1.5.3 Interfaces et héritage de classes
1.6 Résumé

Chapitre 2 : Programmation fonctionnelle, systèmes de types et LISP

2.1 Inférence de types, types de fonctions et génériques
__2.1.1 Inférence de type
__2.1.2 Types de fonctions et génériques
2.2 Systèmes de types fonctionnels dans les langages multiparadigmes
__2.2.1 Réexamen du protocole d'itération et des types
2.2.2 Fonctions fonctionnelles d'ordre supérieur et systèmes de types
__2.2.3 Signatures de fonctions et inférence de type des fonctions imbriquées
2.3 Langages multiparadigmes et métaprogrammation - À partir de LISP
__2.3.1 Opérateur de canalisation
2.3.2 Combinaison de classes, de fonctions d'ordre supérieur, d'itérateurs et du système de types
2.3.3 Apprendre de LISP (Clojure) - Le code est des données, les données sont du code
__2.3.4 Lorsque map est exécuté dans une fermeture
__2.3.5 Création d'une liste de code et de classes créés par l'utilisateur dans un langage multi-paradigme
__2.3.6 Extensibilité de LISP - Macros et métaprogrammation
__2.3.7 Extension dynamique des fonctionnalités lors de l'exécution
__2.3.8 Le plaisir d'enrichir la langue
2.4 Résumé

Chapitre 3 Code : Objet : Fonction = Générateur : Itérateur : LISP = IP : POO : FP

3.1 Le code est des données - une liste contenant de la logique
__3.1.1 [for, i++, if, break] - Considérer le code comme une liste
3.1.2 Traitement des listes dans les langages modernes - Clojure, Kotlin, Swift, Scala, C#, Java
3.1.3 Concepts et paradigmes applicables au-delà du langage
3.2 Apprendre de Haskell
__3.2.1 Fonctions et signatures de fonctions Haskell
3.2.2 Assistance à la curryfication au niveau du langage
__3.2.3 Fonction principale et E/S
__3.2.4 Signatures des fonctions head, map, filter et foldl
__3.2.5 Composition de fonctions - .
Opérateur et opérateur $
__3.2.6 Fonction sommeDesCarrésDeNombresImpairs
__3.2.7 Style de pipeline - &
3.2.8 Gestion des erreurs via
3.2.9 Appariement de motifs
3.3 Un examen plus approfondi de l'évaluation différée
__3.3.1 Ordre d'exécution des itérateurs imbriqués - Vérification avec les générateurs
3.3.2 Examinez de plus près
__3.3.3 Examen direct des itérateurs
3.3.4 Simplification de la vue d'ensemble
3.4 Générateur:Itérateur:LISP - Évaluation paresseuse et synthèse sûre
3.4.1 Trouver la signature de la fonction
3.4.2 Composition sûre avec la fonction Find en Haskell
3.4.3 Évaluation paresseuse et traitement de listes avec la fonction find
__3.4.4 Composition sécurisée en TypeScript
__3.4.5 chaque fonction
__3.4.6 une fonction
3.4.7 Intégration d'une logique de rupture basée sur une évaluation paresseuse
3.4.8 Abstraction fonctionnelle de la logique commune des fonctions every et some
3.4.9 Addition avec concaténation
3.5 Résumé

Chapitre 4 Programmation asynchrone

4.1 Gestion asynchrone par valeur
__4.1.1 Promesse __4.1.2 Avez-vous déjà utilisé directement new Promise() ?
__4.1.3 Promise.race
4.1.4 Définition d'un délai d'attente pour les opérations d'E/S
4.1.5 Rendu de l'interface utilisateur avec différentes stratégies en fonction de la vitesse de réponse
__4.1.6 Promesse.tout
__4.1.7 Promesse.allSettled
__4.1.8 Promesse.tout
4.2 Asynchronie avec latence
4.2.1 Retarder l'exécution d'une promesse
4.2.2 Fonctions de gestion de la concurrence implémentées sous forme impérative par ChatGPT
4.2.3 Fonction de gestion de la concurrence implémentée de manière fonctionnelle
4.2.4 Étapes pour une gestion asynchrone efficace - Latence
4.3 Gestion asynchrone avec types
__4.3.1 Protocoles AsyncIterator, AsyncIterable et AsyncGenerator
__4.3.2 Fonctions d'ordre supérieur pour la gestion des AsyncIterable
4.3.3 Convention pour la création d'une fonction prenant en charge les comportements synchrone et asynchrone - toAsync
4.3.4 Système de types + fonctions fonctionnelles asynchrones + classes
4.4 Gestion asynchrone des erreurs
4.4.1 Chargement de plusieurs images et calcul de leur hauteur
__4.4.2 Logique asynchrone améliorée
__4.4.3 Il est crucial de veiller à ce que les erreurs se produisent correctement.
4.4.4 Logiciels stables et programmation asynchrone
4.5 Résumé

Chapitre 5 : Programmation fonctionnelle pratique

5.1 Traitement des données du monde réel
__5.1.1 Manipulation des nombres dans des tableaux bidimensionnels
5.1.2 Gestion des données des équipes de basketball
5.1.3 Gestion des données commerciales
5.1.4 Gestion des données commerciales 2
5.1.5 Résolution de problèmes avec une approche cohérente
5.2 Application à d'autres problèmes
__5.2.1 Fonction pipe
5.2.2 Composition de fonctions asynchrones avec des pipes
Fonction zip __5.2.3
5.2.4 Lorsqu'un index est nécessaire comme valeur
__5.2.5 Conjecture de Collatz - Compter jusqu'à 1
__5.2.6 take, takeWhile et takeUntilInclusive remplacent break
5.2.7 Logique créée par la combinaison de fonctions
5.3 Programmation asynchrone du backend
5.3.1 Problèmes liés au processus de paiement sur les plateformes de commerce
__5.3.2 Création d'un planificateur de synchronisation de l'historique des paiements
5.3.3 Optimisation de la complexité temporelle avec une approche basée sur le hachage
5.3.4 Maintien d'un intervalle de travail asynchrone stable
__5.3.5 Gestion efficace des limites de taille maximale des requêtes
5.3.6 Amélioration de l'efficacité grâce au précomptage
5.3.7 Améliorer l'efficacité grâce au parallélisme
5.3.8 Programmation asynchrone/concurrente basée sur le traitement de listes
5.4 Modèles de traitement de listes
5.4.1 Modèle cumulatif de variantes
5.4.2 Modèle à variables imbriquées
5.4.3 Modèle à effet d'itérateur
__5.4.4 Motif d'arrêt du filtre
__5.4.5 Motif de rupture infinie
__5.4.6 Patron à plat fendu
5.4.7 Déformation - Modèle à plat
5.4.8 Modèle combiné-accumulé
__5.4.9 Modèles de correspondance de hachage
5.4.10 Fonction de traitement de listes : résumé du concept par type
5.5 Résumé

Chapitre 6 Programmation multiparadigme

6.1 Création d'un moteur de modèles HTML
__6.1.1 Modèles balisés
6.1.2 Implémentation avec traitement de listes
__6.1.3 pousser vers concaténer
6.1.4 Prévention des attaques XSS
6.1.5 Prise en charge du développement par composants avec traitement de données imbriqué
__6.1.6 Les problèmes structurels sont résolus avec une orientation objet, et les problèmes logiques sont résolus avec une orientation fonctionnelle.
6.1.7 Création d'une chaîne HTML à partir d'un tableau
6.1.8 Ajout fonctionnel d'objets
6.1.9 Déplacement du traitement des tableaux à l'intérieur de la classe pour plus de commodité
__6.1.10 Abstraction avec des fonctions d'ordre supérieur
__6.1.11 Création d'une petite bibliothèque de développement front-end
__6.1.12 Opportunités offertes par les langages multiparadigmes
6.2 Gestion de la concurrence à l'aide de plusieurs paradigmes
6.2.1 Revoir executeWithLimit
6.2.2 Fonctions de gestion de la concurrence implémentées sous forme impérative par ChatGPT
6.2.3 Fonction de gestion de la concurrence implémentée en multi-paradigme
6.2.4 Mise à l'échelle pour modifier dynamiquement la taille de la concurrence (charge)
6.2.5 Équilibrage de charge des tâches répétitives à l'infini
__6.2.6 Ajouter runAllSettled
6.3 Résumé

Chapitre 7 Développement front-end orienté objet et approche multi-paradigme et application

7.1 Création d'une application de paramètres
__7.1.1 SwitchView
__7.1.2 SettingItemView
__7.1.3 Paramètres de la vue de liste
__7.1.4 Page de paramètres
__7.1.5 Ajout d'une fonction de bascule complète
__7.1.6 Communication inter-objets et distribution d'événements personnalisés
__7.1.7 Pourquoi les événements se retrouvent-ils bloqués dans une boucle et provoquent-ils des effets secondaires ?
__7.1.8 Modèles de communication d'événements personnalisés à typage statique
__7.1.9 Composant réutilisable SwitchView
__7.1.10 Code réactif créé par Paradigm
7.2 Création d'une application de tâches
__7.2.1 CheckView
7.2.2 Classes abstraites et héritage
__7.2.3 Interface utilisateur sans interface graphique
__7.2.4 Vue des éléments à faire
7.2.5 Gestion des incohérences de dénomination du domaine et de l'interface utilisateur par encapsulation hiérarchique
__7.2.6 Vue de liste de tâches
7.2.7 Abstraction avec des classes génériques
__7.2.8 Page de tâches
7.2.9 Élimination des doublons grâce à la communication objet-à-objet basée sur une interface
7.2.10 Du point de vue des patrons de conception du GoF - Patron de stratégie
7.2.11 Communication inter-objets à l'aide de fonctions de première classe - modèle d'injection de rappel
__7.2.12 Conception de code multiparadigme
7.3 Création d'une application de tâches 2
7.3.1 Simplification du code avec des décorateurs
__7.3.2 TextSubmitView
__7.3.3 Ajout d'une méthode d'assistance à ListView
7.3.4 Création d'une nouvelle tâche
__7.3.5 SegmentControlView
__7.3.6 Optimisation des mises à jour du DOM avec des différences basées sur l'heuristique
7.4 Création d'une application de tâches 3
7.4.1 Rendre le modèle flexible grâce à l'état
7.4.2 Avantages de l'application du modèle d'état
7.4.3 Code et comportement du logiciel pouvant être modifiés lors de l'exécution
__7.4.4 Extension supplémentaire avec des objets d'état
7.4.5 Conception orientée objet multiparadigme
7.5 Asynchrone et interface utilisateur, promesses et classes
7.5.1 Alerte et confirmation à l'aide de la promesse
7.5.2 La promesse comme valeur, un moyen de communication entre les composants
7.5.3 Sélection d'amis pour rejoindre une conversation de groupe

Orienté objet, fonctionnel, impératif — ce n'est plus un choix, c'est une combinaison !
Dès que vous comprenez différents paradigmes, votre vision du code s'élargit.

Les concepts orientés objet, fonctionnels et impératifs ne sont plus opposés ou concurrents.
Les langages modernes intègrent de multiples paradigmes et évoluent vers des outils de plus en plus flexibles et puissants.
Mais le simple fait qu'un langage prenne en charge le multiparadigme ne signifie pas que les développeurs exploiteront naturellement son potentiel.
À l'avenir, il sera plus important encore de savoir gérer harmonieusement différents paradigmes.
Ce livre propose des réponses pratiques à ce défi.

Nous démontrons, à l'aide d'un code concret, comment penser de manière multi-paradigmatique et résoudre les problèmes complexes rencontrés dans les services du monde réel.
Il intègre et explique des concepts avancés orientés objet et fonctionnels tels que les modèles d'itérateurs, les fonctions d'ordre supérieur et les générateurs dans un contexte unique, et relie naturellement les philosophies de LISP, Haskell et Java avec TypeScript comme élément central.

La programmation multiparadigme ne se limite pas aux langages.
Les développeurs front-end apprendront les fondamentaux de JavaScript et une nouvelle sensibilité en matière de conception, tandis que les développeurs back-end apprendront à gérer efficacement la programmation asynchrone et les méthodes de traitement des données efficaces et sécurisées.


★Contenu principal

● Avantages et aspect pratique des langages de programmation multi-paradigmes
● Programmation fonctionnelle, systèmes de types et LISP
● Programmation orientée objet pratique
● Évaluation paresseuse et programmation asynchrone
● Programmation fonctionnelle pratique
● Comment combiner plusieurs paradigmes pour s'adapter à la situation

★Lecteurs cibles

● Ceux qui souhaitent écrire du code plus efficace et plus robuste
● Ceux qui souhaitent ajouter des concepts avancés à une base solide
● Ceux qui souhaitent évoluer vers un poste de développeur de niveau intermédiaire ou supérieur
Développeur front-end utilisant TypeScript et JavaScript
● Développeur backend utilisant Node.js, Express.js, NestJS, etc.
● Ceux qui souhaitent étendre la pensée multiparadigme à leur propre langue sans se limiter à une langue spécifique

★Un mot des bêta-lecteurs qui l'ont lu en premier

● Après avoir lu ce livre, j'ai été surpris de constater que le multiparadigme était déjà établi parmi les grammaires et les codes que j'utilisais sans y penser.
Kim Na-young (Développeuse front-end de l'équipe Bank Salad Health)
● Nous avons beaucoup réfléchi à la maintenance du code.
Pour résoudre ces problèmes, le paradigme de la programmation s'est avéré être une étape essentielle, et ce livre a élargi mon horizon.
_Kim Man-kyung (développeur du serveur de jeu Nine Ark)
● Il s'agit d'un ouvrage de développement pratique qui va au-delà de la simple explication de différents paradigmes de programmation tels que l'orienté objet, le fonctionnel et l'impératif, et vous aide à combiner et à utiliser librement plusieurs paradigmes.
_Kim Young-eun (Développeuse backend)
● J'ai appris que les paradigmes orientés objet et fonctionnels peuvent coexister harmonieusement, et j'ai pu le comprendre rapidement grâce à des exemples de code.
Park So-ye (développeur front-end)
● Il fournit une explication solide des concepts fonctionnels souvent négligés dans la pratique et montre précisément comment ils peuvent être appliqués à du code et à des projets réels.
Seo Jae-wan (développeur front-end)
● Ce livre est également très utile pour consolider les fondamentaux de JavaScript, qui peuvent facilement être négligés à mesure que l'on se familiarise avec le framework.
Seonghyeonje (développeur front-end)
● C'est un livre que je recommande vivement à tout développeur backend de lire au moins une fois.
Cela est d'une grande aide pour comprendre en profondeur l'essence d'une technique, plutôt que de simplement l'apprendre superficiellement.
Shin Yun-su (développeur backend Node.js)
● Vous pouvez apprendre à concevoir en distinguant clairement l'utilisation des paradigmes de programmation sans être limité à un langage spécifique.
Yoon Su-hyeok (développeur web)
● Ce livre est un excellent moyen de faire d'une pierre deux coups : il vous aide à comprendre en profondeur le langage JavaScript et à comprendre et appliquer les paradigmes fonctionnels et orientés objet.
_Yoon Young-seon (Développeur backend)
● Il vous aide à traiter les données de manière plus lisible et plus efficace, quel que soit le paradigme que vous adoptez.
_Lee Ki-woong (développeur front-end)
● Voici un livre que je recommande vivement et qui vous fera imaginer jusqu'où peut s'étendre la pensée multi-paradigme.
_Im Hyuk (Développeur backend)
● Ce livre comble avec brio le fossé entre la théorie et la pratique.
J'avais l'impression que quelqu'un me l'expliquait tout en codant en direct juste à côté de moi.
_Jeong Dong-hwan (développeur front-end)