Démarrer l'essai gratuit
Tendances Nouveau Genres Auteurs
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Recherche en cours...
SoBrief
Functional JavaScript

Functional JavaScript

Rendez JavaScript plus facile à tester et à faire évoluer grâce à des fonctions qui transforment des données simples.
par Michael Fogus 2013 258 pages
4.07
429 évaluations
Écouter
Immersif
V2.3
Amazon Kindle Audible
Essayez l'accès complet pendant 3 jours
Débloquez l'écoute et bien plus !
Continuer

Points clés

Considérez les programmes JavaScript comme des transformations de données, et non comme des réseaux d’objets changeants

Les fonctions deviennent des briques de base. Fogus présente la programmation fonctionnelle comme l’art d’utiliser des fonctions pour transformer des valeurs en abstractions utiles, puis de combiner ces abstractions afin de produire des comportements plus complexes. La conception orientée objet organise souvent un système autour d’entités qui interagissent; la conception fonctionnelle met l’accent sur les opérations qui transforment les données. JavaScript se prête aux deux approches, car les fonctions sont des valeurs, mais ses réglages par défaut très souples facilitent aussi les modifications accidentelles de l’état.

On circonscrit les changements, on ne les nie pas. Une approche fonctionnelle pratique n’exige pas d’éliminer toute mutation. Elle vise à rendre les transformations prévisibles et à limiter les changements à de petites frontières bien contrôlées. Underscore fournit des outils pratiques pour travailler ainsi, mais l’accent est mis sur les idées, et non sur l’adoption d’une bibliothèque particulière. On suit ainsi moins d’états lorsqu’on modifie ou teste une application en pleine croissance.

Analyse

Ce qui est intéressant, c’est le déplacement de l’unité de conception : au lieu de se demander quel objet possède tel comportement, on se demande quelle transformation convertit les données actuelles en celles qui sont requises. Cette perspective rappelle la distinction entre une requête de base de données et les enregistrements stockés qu’elle consulte. On peut examiner et recombiner la requête sans modifier la source. L’analogie a ses limites : les applications réelles doivent communiquer avec les navigateurs, les serveurs et les utilisateurs, et les effets ne peuvent donc pas disparaître. Le bon critère n’est donc pas la pureté partout, mais des frontières nettes entre les transformations prévisibles et les actions qui modifient le monde extérieur.

Passez le comportement comme donnée pour qu’une même opération serve à de nombreux problèmes

Les fonctions circulent comme des valeurs. Une Fonction de première classe peut être stockée, transmise comme argument ou renvoyée, tout comme un nombre. Une Fonction d’ordre supérieur prend une fonction, en renvoie une, ou fait les deux. Ainsi, une opération générale peut répondre à de nombreuses tâches particulières: `map` applique une fonction donnée à chaque élément, `filter` conserve ceux qui satisfont un prédicat, et `reduce` combine les éléments pour produire un résultat.

Les collections deviennent un langage commun. Underscore applique ces opérations aux tableaux et aux objets, encourageant la réutilisation au lieu d’écrire une boucle sur mesure pour chaque forme de données. Par exemple, la même opération de mappage peut extraire un champ de chaque enregistrement ou transformer chaque valeur. Un prédicat peut définir ce qui constitue un enregistrement acceptable, sans qu’il soit nécessaire de modifier le mécanisme de traitement de la collection.

Analyse

Il s’agit d’une manière de séparer la politique du mécanisme. La fonction de collection fournit le mécanisme, tandis que la fonction de rappel définit la politique propre à la tâche. Cette séparation facilite aussi les tests isolés : on peut vérifier une fonction de rappel avec quelques entrées représentatives avant de l’appliquer à une grande collection. Le revers, c’est l’indirection. Un programme qui multiplie les fonctions de rappel peut devenir difficile à suivre si celles-ci ont des noms vagues ou dissimulent des effets de bord. La réutilisation fonctionne mieux lorsque chaque fonction a un contrat précis et explicite.

Utilisez les fermetures pour configurer des fonctions, mais gardez en bride l’état mutable capturé

Une fonction peut transporter son contexte. Une fermeture (closure) est une fonction qui conserve l’accès aux variables de la portée où elle a été créée, même après la fin de la fonction englobante. Par exemple, une fonction peut prendre un facteur d’échelle et renvoyer une autre fonction qui multiplie chaque entrée par ce facteur. Chaque fonction renvoyée conserve sa propre valeur capturée, ce qui fait des fermetures un moyen concis de créer des comportements configurés et de masquer les détails d’implémentation.

Les références capturées ne sont pas figées. Une fermeture qui détient une référence à un objet peut toujours observer les changements effectués sur cet objet par l’intermédiaire d’une autre référence. Un compteur privé peut être protégé des accès extérieurs, mais son résultat dépend tout de même du nombre d’appels de la fonction. `this` présente un risque distinct en JavaScript: `call` et `apply` peuvent en modifier la valeur, tandis que la liaison peut la maintenir stable.

Analyse

Les fermetures offrent un juste milieu entre les variables globales et les hiérarchies d’objets élaborées : le comportement et sa configuration peuvent être regroupés sans exposer chaque détail. C’est particulièrement utile pour les gestionnaires d’événements et les petits adaptateurs réutilisables. Le point subtil, c’est que confidentialité ne signifie pas immutabilité. Une variable cachée peut toujours changer au fil du temps, et un objet capturé peut être partagé ailleurs. Une bonne conception de fermeture pose donc deux questions : qu’a-t-on capturé, et un appelant peut-il le modifier indirectement ?

Composez de petites fonctions et spécialisez-les par application partielle

Construisez des comportements à partir d’autres comportements. La composition de fonctions relie des opérations de sorte que la sortie de l’une devienne l’entrée de la suivante. Fogus l’illustre avec un répartiteur qui essaie des fonctions spécialisées dans un ordre donné, par exemple l’une pour traiter les tableaux et une autre pour les chaînes de caractères. On peut alors assembler un nouveau comportement à partir d’éléments existants, plutôt que de le développer sous la forme d’une vaste conditionnelle.

Fixez des arguments pour créer des variantes. La Curryfication renvoie une suite de fonctions, chacune attendant un argument supplémentaire; l’Application partielle capture certains arguments et renvoie une fonction prête à s’exécuter avec les autres. Le livre privilégie la curryfication de droite à gauche, tandis que ses exemples d’application partielle fixent les arguments initiaux. Comme JavaScript accepte les arguments facultatifs et supplémentaires, la curryfication peut être peu commode; l’application partielle est souvent plus naturelle. Ces techniques permettent aussi de créer des validateurs réutilisables et des valeurs par défaut configurées.

Analyse

L’avantage essentiel n’est pas de raccourcir le code, mais de rendre les décisions visibles sous forme de composants réutilisables. Un validateur assemblé à partir de prédicats nommés explique ses règles plus clairement qu’une conditionnelle dense, et chaque règle peut être testée séparément. La composition rend également l’ordre déterminant : une branche initiale du répartiteur peut prendre en charge un cas avant que les suivantes ne le voient. De telles conceptions exigent des conventions claires pour l’échec et le repli, surtout lorsque undefined signifie qu’une fonction n’a pas traité une entrée. Sans ces conventions, la modularité ne fait que répartir la confusion.

Ne recourez à la récursion que lorsque la structure des données s’y prête

Résolvez une version plus petite du problème. La récursion convient aux problèmes dont les parties reprennent la structure de l’ensemble. Pour compter les éléments d’un tableau, par exemple, on renvoie zéro si le tableau est vide; sinon, on compte le reste du tableau et on ajoute un. Une bonne conception récursive identifie un cas d’arrêt, une étape unique et un problème de taille réduite. Le livre emploie cette approche pour parcourir des tableaux imbriqués et explorer un graphe des influences entre langages de programmation, en transmettant un registre des nœuds déjà visités afin d’éviter les cycles.

Tenez compte de la pile d’appels de JavaScript. Des appels récursifs profonds peuvent dépasser la capacité de la pile d’appels, et les moteurs JavaScript évoqués dans le livre n’optimisent pas de manière fiable les appels terminaux. Un trampoline évite les appels imbriqués en renvoyant la prochaine fonction à exécuter, puis en appelant de telles fonctions dans une boucle. La récursion n’est toutefois pas la réponse par défaut: les opérations existantes sur les collections permettent d’exprimer plus simplement de nombreuses tâches.

Analyse

La récursion rend le raisonnement structurel particulièrement direct : on traite un nœud d’un arbre, puis on applique la même logique à ses enfants. C’est idéal pour les données imbriquées, mais l’élégance sur le papier ne garantit pas une profondeur d’exécution sûre. Le trampoline illustre une distinction importante en ingénierie entre un modèle de calcul et l’environnement d’exécution qui le met en œuvre. Une définition récursive peut être la spécification la plus claire, tandis qu’une implémentation itérative constitue le choix le plus sûr en production. Le choix doit tenir compte de la taille des entrées, des limites de pile et de la lisibilité.

Faites des fonctions pures un cœur facile à tester et confinez les effets inévitables

La pureté rend les résultats prévisibles. Une fonction pure dépend uniquement de ses arguments, ne modifie pas l’état extérieur et renvoie le même résultat pour les mêmes entrées. Les tests ordinaires des entrées et sorties sont donc fiables. Un générateur de chaînes aléatoires ne peut garantir un résultat précis, puisqu’il dépend d’une source aléatoire. Fogus sépare le travail prévisible qui consiste à assembler des caractères en une chaîne de l’étape imprévisible de génération des caractères, ce qui permet de tester le cœur du processus avec une fonction qui renvoie des caractères fixes.

Dissimulez la mutation derrière des frontières. Les tableaux et les objets JavaScript peuvent être modifiés par l’intermédiaire de références partagées; une fonction qui les reçoit doit donc veiller à ne pas les altérer de façon inattendue. Une mutation locale peut néanmoins être raisonnable si la fonction renvoie un nouveau résultat et garde les changements privés. Les copies défensives et les conteneurs d’état soigneusement contrôlés réduisent le nombre d’endroits où des modifications peuvent se produire.

Analyse

La pureté est précieuse parce qu’elle réduit le nombre de faits qu’un test doit maîtriser. Si un résultat dépend uniquement d’entrées explicites, les tests n’ont pas à reconstituer un environnement global ou un historique d’appels particuliers. Cette même propriété facilite le débogage et permet de mettre les fonctions en cache ou de les réorganiser plus facilement. Pourtant, les effets externes font partie des logiciels utiles, et envelopper chaque petite opération dans une abstraction a un coût. L’objectif pratique est un cœur simple et déterministe, entouré de frontières clairement signalées pour l’aléatoire, la journalisation, l’accès réseau et les mises à jour d’état.

Choisissez les pipelines pour les valeurs et des actions explicites lorsque les effets perturbent le flux

Les pipelines rendent visible le parcours des données. Un pipeline fait passer une valeur initiale par une suite de fonctions, le résultat de chacune devenant l’entrée de la suivante. Par exemple, une collection peut être nettoyée, élaguée et réordonnée sans que l’original soit modifié. À l’inverse, le chaînage de méthodes transmet généralement un objet partagé d’un appel de méthode au suivant. Une chaîne paresseuse mémorise les appels pour les exécuter plus tard; un pipeline ordinaire calcule ses transformations au moment où on l’invoque.

Les effets nécessitent un contrat stable. Une fonction de journalisation peut ne rien renvoyer, ce qui interrompt un pipeline qui s’attend à ce que l’étape suivante reçoive une valeur utile. L’abstraction `actions` du livre résout ce problème en transportant un enregistrement cohérent de l’état courant et de la réponse de chaque action. Cela permet de composer des étapes qui, autrement, seraient incompatibles. Les promesses répondent à un autre besoin: coordonner des opérations asynchrones dont l’achèvement se produit au fil du temps.

Analyse

Un pipeline donne à voir le flux des données, tandis qu’une séquence d’effets ressemble davantage à un petit processus. Distinguer ces idées aide à éviter une erreur de conception fréquente : traiter la journalisation, les requêtes réseau et les transformations de valeurs comme des opérations interchangeables au seul motif qu’elles sont toutes des fonctions. Le modèle actions offre de la souplesse en normalisant la valeur renvoyée par chaque étape, mais son suivi peut être plus élaboré que ne le justifie la tâche. Dans les programmes simples, une séquence explicite peut exprimer l’intention plus clairement qu’un cadre général de composition.

Commencez par les tableaux, les objets et les fonctions avant d’inventer une hiérarchie de classes

Représentez les informations simplement. L’Approche centrée sur les données (data thinking) du livre privilégie les tableaux et les objets intégrés à JavaScript lorsqu’ils représentent bien le problème. Un catalogue de livres, par exemple, peut être représenté par un tableau d’enregistrements. Les fonctions peuvent sélectionner des colonnes, renommer des champs ou filtrer des lignes, à la manière des opérations élémentaires d’une base de données relationnelle. Cela évite de créer des classes distinctes pour une table, une ligne et chaque type d’enregistrement avant que ces types n’apportent une réelle valeur.

Faites en sorte que la représentation puisse être remplacée. Les fonctions qui définissent comment accéder aux données peuvent masquer la structure sous-jacente au reste du programme. Il devient alors possible de changer de représentation sans réécrire chaque composant qui utilise ces données. L’auteur reconnaît néanmoins l’utilité de la conception orientée objet, en particulier pour modéliser les entités d’une simulation. L’idée est de choisir des structures de données simples pour traiter l’information et de réserver les types spécialisés aux comportements qui en ont véritablement besoin.

Analyse

Ce conseil fait écho à un principe utile de la conception des bases de données : séparer les faits stockés des nombreuses questions qu’on leur pose. Si les enregistrements restent des données ordinaires, le filtrage et l’agrégation peuvent être réutilisés dans différents domaines plutôt que d’être enfermés dans les méthodes d’une classe. Cette approche est particulièrement efficace lorsque les données sont surtout transmises d’une transformation à l’autre. Elle suffit moins lorsque les entités ont des invariants forts, une identité ou un cycle de vie à faire respecter. Le bon critère est de savoir si un type clarifie ces contraintes, et non si un modèle orienté objet familier est disponible.

Utilisez les mixins pour les comportements particuliers, mais réfléchissez aux mutations et aux choix de performance

Combinez des comportements sans imposer une taxonomie. Un Mixin est un ensemble de méthodes qu’un type peut adopter. Au lieu de placer chaque capacité dans une arborescence d’héritage profonde, un type `Hole` peut combiner des comportements de validation, de notification et de définition de valeur. Le livre présente aussi le comportement « comparer-et-échanger »: mettre à jour une valeur stockée uniquement si elle correspond toujours à l’ancienne valeur attendue. Les mixins conviennent aux types spécialisés, tandis que les simples tableaux et objets restent préférables pour les données ordinaires.

Restez pragmatique dans vos choix d’implémentation. Évitez de modifier les prototypes intégrés, car cela peut affecter du code sans rapport. Les outils fonctionnels peuvent ajouter un surcoût par rapport à une boucle directe, mais le livre déconseille d’optimiser avant d’avoir établi la justesse et la clarté du programme. Une mutation au sein d’une implémentation privée peut être acceptable si les appelants reçoivent un résultat prévisible et que les données d’origine sont protégées. Mesurez les performances là où elles comptent, puis optimisez les points chauds ciblés.

Analyse

Les mixins répondent à une faiblesse réelle des hiérarchies rigides : les nouveaux comportements ne s’inscrivent pas toujours dans une classification parent-enfant unique. Leur souplesse comporte toutefois un autre risque. Des noms de méthodes peuvent entrer en conflit, l’ordre d’extension peut déterminer quelle implémentation l’emporte, et des protocoles implicites peuvent être difficiles à découvrir. Définir explicitement les exigences de chaque mixin aide à rendre ces dépendances visibles. Le conseil sur les performances est tout aussi équilibré : l’abstraction a un coût à l’exécution, mais l’attention des développeurs aussi. Un outil plus lent peut être un bon compromis jusqu’à ce que les mesures révèlent qu’il se trouve sur un chemin critique.

Analyse

Fogus présente JavaScript fonctionnel comme une discipline pratique adaptée à un langage qui autorise de nombreux styles, mais offre peu de garde-fous. L’idée directrice n’est pas que les fonctions seraient moralement supérieures aux objets. C’est que des fonctions opérant sur des données simples peuvent rendre les transformations plus faciles à composer, à tester et à modifier, tout en réduisant les dépendances cachées créées par un état mutable partagé. Underscore sert de boîte à outils concrète, et non de sujet à l’argumentation.

Le livre progresse des principes fondamentaux vers l’architecture. Les fonctions de première classe et les opérations sur les collections rendent les comportements réutilisables. La portée et les fermetures expliquent comment les fonctions conservent leur configuration et où peut se glisser un état caché. Les fonctions d’ordre supérieur, la curryfication, l’application partielle et la composition transforment de petites opérations en opérations plus vastes. La récursion éclaire les données imbriquées, mais se heurte aux limites de la pile d’appels de JavaScript. La pureté et l’immutabilité deviennent ensuite des politiques de conception, et non des absolus. Les pipelines clarifient le flux des valeurs, tandis que les actions prennent en charge les étapes dont les résultats ne s’accordent pas naturellement. Enfin, la conception orientée données et les mixins offrent d’autres possibilités que de commencer par les classes.

La contribution la plus forte du livre est de montrer que le style fonctionnel est accessible dans le JavaScript ordinaire, sans exiger un nouveau langage ni un rejet complet de la programmation orientée objet. Son scepticisme pratique est également important: la mutation peut être masquée en toute sécurité, les boucles impératives peuvent convenir, et les outils fonctionnels peuvent ralentir l’exécution. Une limite tient au fait que de nombreux exemples portent sur des données simples et des abstractions construites pour l’occasion; des enjeux de production tels que la propagation des erreurs, les contrats de types et la coordination asynchrone complexe sont donc moins abordés. La leçon durable est une méthode de jugement: garder les données simples, rendre les transformations explicites, isoler les effets et n’introduire des mécanismes spécialisés que si le problème le justifie. Cette approche est surtout convaincante comme boîte à outils pour gérer la complexité, et non comme doctrine universelle de programmation.

Résumé en 30 secondes
Les fonctions qui ne dépendent que de leurs entrées sont prévisibles et faciles à tester. Passer des fonctions comme des valeurs permet à des opérations telles que le mappage, le filtrage et la réduction de s’appliquer à de nombreuses collections. La composition et l’application partielle permettent de créer des comportements spécialisés à partir de petits éléments. Encadrez clairement l’état partagé et les effets de bord, et recourez à la récursion lorsque la structure des données s’y prête naturellement. Commencez par des tableaux et des objets simples, et ne choisissez des classes ou des mixins que s’ils apportent une réelle valeur.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

4.07 sur 5
Moyenne de 429 évaluations de Goodreads et Amazon.

Functional JavaScript reçoit majoritairement des avis positifs, avec une note moyenne de 4,07 sur 5. Les lecteurs apprécient la clarté de ses explications des concepts de programmation fonctionnelle en JavaScript et saluent son approche directe ainsi que ses exemples pratiques. Beaucoup le trouvent révélateur et utile pour améliorer leurs compétences en programmation. Certains lecteurs le jugent dense et le recommandent aux programmeurs de niveau intermédiaire ou avancé. Si quelques-uns critiquent sa dépendance à Underscore.js et s’interrogent sur son applicabilité dans des situations réelles, la plupart s’accordent à dire qu’il constitue une bonne introduction aux techniques de programmation fonctionnelle en JavaScript.

Votre note :
4.51
208 évaluations
Envie de lire le livre complet ?

Glossaire

Fonction de première classe

Fonction traitée comme une valeur

Une fonction est de première classe lorsqu’elle peut être utilisée à peu près comme les autres valeurs. En JavaScript, elle peut être affectée à une variable, stockée dans un tableau ou un objet, passée à une autre fonction ou renvoyée comme résultat. Cette liberté permet aux fonctions de représenter des comportements réutilisables, qui peuvent être fournis ou assemblés selon les besoins.

Fonction d’ordre supérieur

Fonction qui manipule d’autres fonctions

Une fonction d’ordre supérieur prend une ou plusieurs fonctions comme arguments, renvoie une fonction, ou fait les deux. map, par exemple, accepte une fonction à appliquer à chaque élément d’une collection. Une fonction qui renvoie un prédicat configuré est également une fonction d’ordre supérieur. Ces opérations permettent de réutiliser des comportements sans coder en dur chaque tâche.

Fermeture (closure)

Fonction qui conserve des liaisons

Une fermeture est une fonction qui conserve l’accès aux variables de la portée dans laquelle elle a été créée, même après que la fonction englobante a renvoyé son résultat. Les fermetures peuvent préserver une configuration, comme un facteur d’échelle, ou masquer des données privées. Les objets capturés restent modifiables si d’autres parties du code en détiennent une référence.

Programmation applicative

Appliquer des fonctions à des collections

Dans cet ouvrage, la programmation applicative désigne le fait qu’une fonction en appelle une autre qu’elle a reçue en argument. Les opérations sur les collections comme map, reduce et filter en sont des exemples : chacune reçoit une fonction de rappel et l’applique aux valeurs d’une collection pour les transformer, les combiner ou les sélectionner.

Approche centrée sur les données (data thinking)

Modéliser les données avant d’ajouter des types

L’approche centrée sur les données consiste à représenter les informations au moyen de structures simples, comme des tableaux et des objets, puis à définir des fonctions qui transforment ou interrogent ces structures. Un tableau d’enregistrements de livres permet des opérations analogues à la sélection de champs, au renommage de colonnes et au filtrage de lignes. L’objectif est d’éviter les classes superflues tout en préservant la possibilité de remplacer les représentations.

Curryfication

Fournir les arguments par étapes

La curryfication transforme une fonction qui prend plusieurs arguments logiques en une suite de fonctions, chacune recevant un argument et renvoyant la fonction suivante. Dans les exemples de Fogus, les arguments sont fixés de droite à gauche. Cette technique permet de créer des fonctions spécialisées, même si les conventions de JavaScript concernant les arguments facultatifs et variables peuvent rendre la curryfication moins naturelle.

Application partielle

Préremplir les arguments d’une fonction

L’application partielle consiste à prendre une fonction et certains de ses arguments, puis à renvoyer une nouvelle fonction qui attend les arguments restants. Elle diffère de la curryfication, car la fonction renvoyée peut accepter plusieurs arguments restants à la fois. L’ouvrage l’utilise pour configurer des opérations réutilisables et construire des pipelines de fonctions fluides.

Transparence référentielle

Remplacer les appels par leurs résultats

Une fonction est transparente du point de vue référentiel lorsqu’un appel peut être remplacé par son résultat sans modifier le comportement du programme. C’est plus facile lorsque la fonction ne dépend que de ses arguments et n’a aucun effet externe. Une fonction qui incrémente un compteur caché n’est pas transparente du point de vue référentiel, car sa sortie dépend de l’historique de ses appels.

Trampoline

Exécuter les étapes récursives dans une boucle

Un trampoline remplace les appels récursifs profondément imbriqués par des appels de fonctions répétés dans une boucle. Les étapes récursives renvoient la fonction à exécuter ensuite au lieu de l’appeler immédiatement. Cela évite de consommer un nouveau cadre de pile à chaque étape, ce qui est utile en JavaScript lorsque la profondeur de récursion risque de dépasser les limites de l’environnement d’exécution.

Thunk

Fonction de calcul différé

Un thunk est une fonction qui encapsule un calcul afin de l’exécuter plus tard. Fogus utilise des thunks dans une chaîne paresseuse : les appels de méthodes sont enregistrés au lieu d’être exécutés immédiatement, puis exécutés à la suite lorsque la chaîne est déclenchée. Un thunk peut également capturer les arguments ou la cible nécessaires au calcul ultérieur.

Pipeline

Faire passer des valeurs dans des fonctions

Un pipeline fait passer une valeur initiale dans une suite de fonctions, le résultat de chacune étant transmis à la suivante. Il rend les transformations explicites et peut relier des opérations dont les types de données intermédiaires diffèrent, à condition que leurs entrées et leurs sorties correspondent. Les pipelines sont plus simples lorsque leurs étapes renvoient des valeurs utiles et évitent les effets de bord.

Mixin

Ensemble réutilisable de comportements

Un mixin est un ensemble de méthodes qui peut être combiné à un type pour lui ajouter un comportement particulier sans placer toutes les capacités dans une hiérarchie d’héritage. Les exemples de l’ouvrage combinent des comportements de validation, d’observation et de définition de valeurs. Les mixins nécessitent des protocoles d’extension clairs, car les conflits entre méthodes et leur ordre peuvent influer sur le résultat.

FAQ

De quoi parle Functional JavaScript ?

  • La programmation fonctionnelle au cœur du sujet : Functional JavaScript de Michael Fogus présente les concepts de programmation fonctionnelle à l’aide de JavaScript, en mettant particulièrement l’accent sur la bibliothèque Underscore.js.
  • Principes fondamentaux : L’ouvrage souligne l’importance de traiter les fonctions comme des citoyens de première classe, ce qui permet d’écrire un code plus modulaire et plus facile à maintenir.
  • Applications pratiques : Il aborde des techniques telles que les fonctions d’ordre supérieur, la récursion et la composition de fonctions, et s’adresse ainsi aussi bien aux développeurs débutants qu’aux plus expérimentés.

Pourquoi lire Functional JavaScript ?

  • Améliorer ses compétences en JavaScript : L’ouvrage approfondit la compréhension de JavaScript en explorant les paradigmes de la programmation fonctionnelle, ce qui permet d’écrire un code plus clair et plus efficace.
  • Exemples concrets : Il propose de nombreux exemples et exercices qui montrent comment appliquer les concepts de programmation fonctionnelle dans des situations courantes de programmation.
  • Élargir son éventail de paradigmes : La lecture de cet ouvrage permet d’enrichir sa boîte à outils de programmation et de devenir un développeur plus polyvalent, capable de s’attaquer à des problèmes complexes.

Quels sont les principaux enseignements de Functional JavaScript ?

  • Fonctions de première classe : En JavaScript, les fonctions peuvent être traitées comme n’importe quelle autre valeur, ce qui ouvre la voie à des techniques de programmation puissantes.
  • Fonctions d’ordre supérieur : Il est essentiel de créer et d’utiliser des fonctions d’ordre supérieur, car elles permettent aux fonctions d’accepter d’autres fonctions en arguments ou d’en renvoyer.
  • Récursion et fermetures : L’ouvrage traite de la récursion comme méthode de résolution de problèmes et des fermetures comme moyen de conserver un état dans un contexte de programmation fonctionnelle.

Qu’est-ce qu’une fonction d’ordre supérieur dans Functional JavaScript ?

  • Définition : Une fonction d’ordre supérieur prend une ou plusieurs fonctions comme arguments, ou renvoie une fonction comme résultat.
  • Exemples dans l’ouvrage : Les fonctions telles que _.map, _.filter et _.reduce sont présentées comme des fonctions d’ordre supérieur qui travaillent sur des collections et acceptent des fonctions de rappel.
  • Importance : Les fonctions d’ordre supérieur permettent d’écrire du code plus abstrait et réutilisable, et aident les développeurs à créer des applications plus flexibles et modulaires.

Comment Functional JavaScript explique-t-il la récursion ?

  • Définition récursive : La récursion est définie comme une fonction qui s’appelle elle-même pour résoudre des instances plus petites du même problème, par exemple pour calculer la longueur d’un tableau.
  • Exemple d’implémentation : L’ouvrage présente notamment la fonction myLength, qui utilise la récursion pour déterminer la longueur d’un tableau : elle vérifie si le tableau est vide et ajoute un pour chaque élément.
  • Avantages de la récursion : La récursion peut simplifier des problèmes complexes en les décomposant en parties plus petites et plus faciles à gérer, ce qui rend le code plus facile à lire et à maintenir.

Que sont les fermetures telles qu’elles sont décrites dans Functional JavaScript ?

  • Définition des fermetures : Une fermeture est une fonction qui capture la portée lexicale dans laquelle elle a été définie, ce qui lui permet d’accéder aux variables de cette portée même après la fin de l’exécution de la fonction englobante.
  • Utilisation pratique : L’ouvrage illustre les fermetures au moyen d’exemples comme makeAdder, qui crée des fonctions se souvenant des variables qu’elles ont capturées et permet ainsi d’obtenir un comportement avec état.
  • Importance : Comprendre les fermetures est essentiel pour maîtriser JavaScript : c’est un concept fondamental qui permet l’encapsulation des données et la création de fabriques de fonctions.

Comment Functional JavaScript définit-il la curryfication ?

  • Définition de la curryfication : La curryfication consiste à transformer une fonction qui prend plusieurs arguments en une suite de fonctions qui prennent chacune un seul argument.
  • Exemple dans l’ouvrage : L’ouvrage propose l’exemple d’une fonction curryfiée qui permet l’application partielle d’arguments et facilite ainsi la création de fonctions spécialisées.
  • Avantages de la curryfication : La curryfication améliore la réutilisabilité et la flexibilité du code, en permettant aux développeurs de créer des fonctions plus modulaires et composables.

Quel est le rôle d’Underscore.js dans Functional JavaScript ?

  • Bibliothèque utilitaire : Underscore.js est utilisée tout au long de l’ouvrage comme bibliothèque utilitaire offrant des outils de programmation fonctionnelle en JavaScript, notamment des fonctions comme map, reduce et filter.
  • Un apprentissage facilité : La bibliothèque simplifie la mise en œuvre des concepts de programmation fonctionnelle et permet aux lecteurs de se concentrer sur la compréhension des principes plutôt que de s’enliser dans des détails de bas niveau.
  • Intégration à JavaScript : L’ouvrage montre comment exploiter Underscore.js pour écrire du code JavaScript plus clair et plus fonctionnel, ce qui en fait une ressource pratique pour les développeurs.

Comment Functional JavaScript aborde-t-il l’immuabilité ?

  • Importance de l’immuabilité : L’ouvrage souligne que l’immuabilité est un principe essentiel de la programmation fonctionnelle. En évitant l’état mutable, les développeurs peuvent créer du code plus prévisible et plus facile à maintenir.
  • Techniques d’immuabilité : Fogus aborde diverses techniques pour obtenir l’immuabilité en JavaScript, comme l’utilisation de Object.freeze et la création de copies profondes d’objets.
  • L’immuabilité en pratique : L’auteur donne des exemples de mise en œuvre de l’immuabilité dans des applications concrètes et montre ses avantages en matière de clarté et de fiabilité du code.

Quelles sont les bonnes pratiques proposées dans Functional JavaScript ?

  • Éviter les effets de bord : L’ouvrage préconise d’écrire des fonctions pures qui ne modifient pas l’état externe, ce qui rend le code plus prévisible et plus facile à tester.
  • Utiliser des fonctions d’ordre supérieur : Le recours aux fonctions d’ordre supérieur peut aider à créer du code plus abstrait et réutilisable, et ainsi à mieux gérer la complexité.
  • Adopter la récursion et les fermetures : Comprendre et utiliser efficacement la récursion et les fermetures permet de mieux écrire du JavaScript fonctionnel et de trouver des solutions élégantes à des problèmes complexes.

Quels exemples pratiques trouve-t-on dans Functional JavaScript ?

  • Créer un validateur simple : L’ouvrage comprend une section sur la création d’une fonction de validation simple qui vérifie des valeurs d’entrée et illustre l’application des principes de programmation fonctionnelle à des situations concrètes.
  • Utiliser des fonctions d’ordre supérieur : Fogus propose des exemples de fonctions d’ordre supérieur, telles que map et filter, et montre comment elles peuvent servir à manipuler efficacement des collections de données.
  • Créer une chaîne paresseuse : L’auteur montre comment mettre en œuvre une chaîne paresseuse d’appels de fonctions, qui permet de différer l’exécution des opérations et illustre la souplesse et la puissance des techniques de programmation fonctionnelle.

Quelles sont les meilleures citations de Functional JavaScript et que signifient-elles ?

  • « La programmation fonctionnelle consiste à utiliser des fonctions qui transforment des valeurs en unités d’abstraction, ensuite utilisées pour construire des systèmes logiciels. » : Cette citation résume l’essence de la programmation fonctionnelle telle qu’elle est présentée dans l’ouvrage.
  • « La pureté est la clé de la prévisibilité. » : Elle souligne l’importance d’écrire des fonctions pures en programmation fonctionnelle pour obtenir un comportement plus prévisible.
  • « La composition est l’essence de la programmation fonctionnelle. » : Elle met en avant l’importance de la composition de fonctions, une technique fondamentale qui améliore la réutilisabilité et la clarté du code.

À propos de l'auteur

Michael Fogus est un développeur de logiciels chevronné et un auteur reconnu pour son expertise en programmation fonctionnelle. Il a écrit plusieurs ouvrages sur la programmation, dont « The Joy of Clojure » et « Functional JavaScript ». Fogus est apprécié pour sa capacité à expliquer des concepts complexes de façon claire et concise. Ses travaux portent souvent sur l’application des principes de la programmation fonctionnelle à divers langages, en particulier JavaScript. Il est également connu pour ses contributions à la communauté Clojure et sa participation au développement de langages de programmation. Son style d’écriture, direct et éclairant, rend les sujets difficiles accessibles à des lecteurs de niveaux d’expérience variés.

Télécharger le PDF

Pour garder le résumé de Functional JavaScript pour plus tard, téléchargez gratuitement le PDF. Vous pouvez l’imprimer ou le lire hors ligne quand vous le souhaitez.
Download PDF

Télécharger l'EPUB

Pour lire le résumé de Functional JavaScript sur votre liseuse ou dans une application de lecture, téléchargez gratuitement l’EPUB. Le format numérique .epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.
Download EPUB
Envie de lire le livre complet ?
Suivre
Écouter
Accueil
Swipe
Biblio
Appli
Essayez l'accès complet pendant 3 jours
Écoutez, enregistrez, et plus encore
Comparer les fonctionnalités Gratuit Pro
📖 Lire les résumés
Lisez des résumés illimités. Les utilisateurs gratuits en reçoivent 3 par mois
🎧 Écouter les résumés
Écoutez des résumés illimités dans 40 langues
—
❤️ Favoris illimités
Limité à 4 pour les utilisateurs gratuits
—
📜 Historique illimité
Limité à 4 pour les utilisateurs gratuits
—
📥 Téléchargements illimités
Limité à 1 pour les utilisateurs gratuits
—
Calendrier sans engagement
Aujourd'hui : Accès immédiat
Écoutez les résumés complets de plus de 26 000 livres. Soit plus de 12 000 heures d'audio !
Jour 2 : Rappel d'essai
Nous vous enverrons une notification pour vous informer que votre essai se termine bientôt.
Jour 3 : Votre abonnement commence
Vous serez débité le 24 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
1M+ lecteurs
Trustpilot Rating
TrustPilot
4.6 Excellent
Ce site change tout. Je n'ai jamais lu autant de résumés aussi rapidement. Je recommande vivement.
— Dave G
Ça vaut vraiment le coup en temps et en argent, et c'est très bien fait. Je n'ai jamais vu cette qualité de résumés ailleurs. Très utile !
— Em
Hautement recommandé !! Service fantastique. Parfait pour ceux qui veulent plus qu'un aperçu sans tous les détails d'un livre audio complet.
— Greg M
Économisez 62 %
Annuel
$119.88 $44.99/an/an
$3.75/mois
Mensuel
$9.99/mois
Démarrer un essai gratuit de 3 jours
3 jours gratuits, puis $44.99/an. Annulez à tout moment.
Unlock a world of fiction & nonfiction books
Plus de 26 000 livres pour le prix de 2 livres
Lisez n'importe quel livre en 10 minutes
Découvrez de nouveaux livres comme sur Tinder
Demandez n'importe quel livre s'il n'est pas encore résumé
Lisez plus de livres que quiconque
L'appli n°1 pour les amateurs de livres
Lifelike & immersive summaries
Garantie satisfait ou remboursé 30 jours
Téléchargez les résumés en EPUB ou PDF
Annulez à tout moment en quelques clics

Pourquoi un seul résumé ?

Scanner
Trouvez un code-barres à scanner

⭐
⭐
⭐
Nous avons un cadeau spécial pour vous
Ouvrir
38 % de réduction
RÉDUCTION POUR VOUS
⭐
⭐
⭐
$79.99
$49.99/an
Seulement $4.16 par mois
Continuer
2 touches pour commencer, résiliation ultra simple
Paramètres
Général
Widget
Chargement...