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
JavaScript Enlightenment

JavaScript Enlightenment

Comprenez les mécanismes cachés de JavaScript et cessez de tâtonner lorsqu’un raccourci de bibliothèque ne fonctionne pas.
par Cody Lindley 2012 164 pages
3.54
189 é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

Regardez sous les bibliothèques JavaScript pour comprendre les objets et les règles qu’elles dissimulent.

Apprenez les mécanismes. Les bibliothèques peuvent aider les développeurs à créer rapidement des interfaces, mais elles peuvent aussi masquer le fonctionnement des valeurs, des fonctions et de l’héritage en JavaScript. Lindley cherche à faire passer les lecteurs d’une utilisation machinale des fonctionnalités des bibliothèques à une compréhension du langage sous-jacent, afin qu’ils puissent raisonner sur le comportement du code lorsqu’un raccourci échoue ou doit être adapté. Le livre porte sur JavaScript 1.5, correspondant à ECMAScript 3, et s’adresse aux débutants avancés, aux développeurs de niveau intermédiaire et aux utilisateurs expérimentés de bibliothèques, et non aux novices en programmation.

Étudiez par petites étapes. L’auteur nomme son approche pédagogique le découpage pédagogique en petites unités (technical thin-slicing): fractionner des notions complexes en explications concises, étayées par du code ciblé que l’on peut exécuter. Les exemples sont destinés à être examinés et testés, et non à servir de simples ornements. Le sujet central est celui des objets JavaScript et des règles qui les régissent.

Analyse

Ce qui frappe, c’est que le livre choisit de faire du comportement des objets la voie d’accès au langage, plutôt que d’en faire un sujet de spécialité. Ce choix porte ses fruits : constructeurs, fonctions, tableaux et même enveloppes des valeurs primitives deviennent les éléments d’un même système cohérent. Cette approche évoque aussi l’apprentissage d’un outil par l’examen de ses mécanismes, plutôt que par la simple mémorisation de son interface. L’abstraction reste toutefois précieuse. Les bibliothèques ne sont pas des boîtes noires qu’il faudrait éviter par principe ; ce sont des couches utiles, dont on reconnaît plus facilement les limites lorsqu’on comprend le modèle sous-jacent. La portée historique du livre compte également, car JavaScript a beaucoup évolué depuis qu’il se concentrait sur ES3.

Privilégiez les chaînes, nombres et booléens primitifs à leurs équivalents enveloppés.

Sachez ce qu’est une valeur. Les valeurs primitives de JavaScript comprennent les chaînes, les nombres, les booléens, `null` et `undefined`. Ce ne sont pas des objets ordinaires, même si les chaînes, les nombres et les booléens peuvent temporairement se comporter comme des objets lorsque le code accède à une méthode ou à une propriété. JavaScript fournit alors une enveloppe pour rendre cet accès possible, puis la supprime. C’est pourquoi `'hello'.length` fonctionne sans transformer la chaîne en objet permanent.

Méfiez-vous des enveloppes trompeuses. Appeler `new String`, `new Number` ou `new Boolean` crée un objet: `typeof` renvoie donc `object`, et non le type primitif. Un booléen faux enveloppé est particulièrement piégeux: c’est un objet, et les objets sont évalués comme vrais. Dans une condition, `new Boolean(false)` se comporte donc comme vrai. Pour les chaînes, nombres et booléens ordinaires, utilisez des littéraux primitifs ou des conversions sans `new`.

Analyse

Cette distinction offre une leçon concise sur la manière dont la syntaxe de surface peut masquer des catégories d’exécution différentes. Une valeur peut permettre des opérations de type objet sans être un objet au sens habituel, un phénomène que l’on retrouve dans de nombreux environnements d’exécution. L’exemple du booléen enveloppé est particulièrement parlant, car il met en évidence l’écart entre le contenu apparent d’une valeur et son comportement dans le contrôle du flux. Le conseil général est judicieux, mais il ne faut pas considérer typeof comme un système de types complet : même dans le cadre du livre, null renvoie object. Les développeurs ont besoin de plusieurs vérifications simples, et non d’un détecteur magique unique.

Déterminez si une affectation copie une valeur ou partage l’accès à un même objet.

Les valeurs primitives se transmettent par valeur. Si une variable contenant la chaîne `'foo'` est affectée à une autre variable, cette dernière reçoit cette valeur. Réaffecter ensuite la première variable ne modifie pas la seconde.

Les objets se transmettent par référence. Affecter un objet à une autre variable copie une référence vers le même objet, et non un objet distinct. Si `a` et `b` pointent vers un seul objet, l’ajout d’une propriété par l’intermédiaire de `a` la rend visible par `b`. L’égalité suit la même distinction: deux objets créés séparément et ayant les mêmes propriétés ne sont pas égaux avec `===`, tandis que deux références vers le même objet le sont. Pour obtenir un objet indépendant, il faut copier son contenu dans un objet nouvellement créé. Une copie superficielle peut toutefois laisser des objets imbriqués partagés.

Analyse

Ce modèle explique une grande partie des bogues qui semblent mystérieux uniquement parce que l’affectation est prise à tort pour une duplication. Il est aussi directement lié à l’aliasage, un enjeu dans de nombreux langages de programmation : deux noms peuvent donner accès à un état mutable partagé. C’est efficace lorsque le partage est voulu, mais problématique lorsqu’une fonction ou un composant modifie un objet sur lequel une autre partie du programme s’appuie. La métaphore de la référence employée dans le livre est utile, à condition de ne pas la prendre pour une description littérale d’une organisation mémoire particulière. La question pratique est plus simple : les modifications effectuées par l’intermédiaire d’une variable sont-elles visibles par l’intermédiaire d’une autre ?

Considérez l’accès à une propriété comme une recherche dans l’objet et sa chaîne d’héritage.

Regardez au-delà de l’instance. Lorsque JavaScript ne trouve pas directement sur un objet la propriété demandée, il parcourt sa chaîne de prototypes. Un tableau peut appeler `join()` même si la méthode n’est pas stockée séparément dans chaque instance de tableau, car elle est accessible par l’intermédiaire de `Array.prototype`. La recherche se poursuit dans les prototypes hérités et finit par atteindre `Object.prototype`; si aucune correspondance n’est trouvée, le résultat est `undefined`.

Choisissez le bon test. L’opérateur `in` vérifie à la fois les propriétés propres d’un objet et celles qu’il hérite. `hasOwnProperty` ne vérifie que les propriétés stockées directement sur cet objet. C’est important lorsqu’on inspecte les propriétés ou qu’on les parcourt: une boucle `for in` peut inclure des propriétés énumérables héritées; utilisez donc `hasOwnProperty` si vous ne voulez que les propriétés propres. La notation entre crochets est également utile lorsque la clé est stockée dans une variable ou ne constitue pas un identifiant valide.

Analyse

La recherche d’une propriété est présentée comme une procédure prévisible, plus utile que de traiter l’héritage comme une vague ressemblance entre objets. La distinction entre propriété propre et propriété héritée est essentielle pour une énumération fiable et pour comprendre d’où vient une méthode. Elle suggère aussi une meilleure habitude de débogage : lorsqu’une propriété apparaît de façon inattendue, inspectez la chaîne plutôt que la seule instance. Étendre les prototypes intégrés peut compliquer cette recherche pour tout le monde, surtout lorsque les propriétés ajoutées se retrouvent dans l’énumération. Les prototypes partagés sont puissants précisément parce que leurs effets sont partagés.

Placez le comportement partagé sur les prototypes et gardez les données propres à chaque instance dans chaque objet.

Utilisez un schéma de construction. Une fonction constructeur est une fonction ordinaire utilisée avec `new` pour créer une instance. Lors de cet appel, `this` désigne le nouvel objet, qui est relié à l’objet `prototype` du constructeur. Un constructeur `Person` peut affecter le nom de chaque personne à l’instance, tandis qu’une méthode placée sur `Person.prototype` peut être réutilisée par toutes les instances de personne au lieu d’être recréée pour chacune.

Tenez compte du lien. Une instance peut voir les changements apportés à l’objet prototype dont elle hérite déjà. Remplacer entièrement le `prototype` du constructeur par un autre objet ne redirige pas les instances existantes et peut aussi supprimer la propriété utile `constructor`, à moins de la rétablir. La chaîne de prototypes est le mécanisme qui sous-tend aussi bien les méthodes natives que l’héritage personnalisé.

Analyse

La distinction entre l’état d’une instance et le comportement partagé est à la fois une technique d’économie de mémoire et une décision de conception. Une méthode de prototype donne accès à une implémentation unique à toutes les instances, tandis qu’une propriété d’instance peut varier d’une personne à l’autre. Ce modèle démystifie aussi l’héritage : les objets accèdent aux propriétés par une suite d’objets reliés entre eux. Il y a un compromis à faire. Des propriétés mutables partagées sur un prototype peuvent surprendre les développeurs qui s’attendent à ce que chaque instance possède une valeur distincte. La réutilisation fondée sur les prototypes fonctionne au mieux lorsque le partage du comportement est intentionnel et que l’état partagé est géré avec précaution.

Déterminez la valeur de `this` à partir du site d’appel, et non de l’endroit où la fonction a été écrite.

L’invocation définit le contexte. Dans le modèle ES3 du livre, une fonction appelée sous la forme `object.method()` reçoit cet objet comme valeur de `this`. Appeler la même fonction sans objet récepteur lui donne un autre contexte: l’objet global dans les exemples de navigateur. Un appel de constructeur avec `new` fait de `this` une référence à la nouvelle instance. Il s’agit de différentes manières d’invoquer une fonction, et non de différentes sortes de fonctions.

Définissez le contexte délibérément. `call` et `apply` invoquent une fonction avec une valeur de `this` choisie. Leur différence tient à la façon de fournir les arguments: `call` les prend individuellement, tandis que `apply` prend une collection assimilable à un tableau. En ES3, une fonction ordinaire imbriquée n’hérite pas du `this` de sa fonction parente; enregistrer la valeur extérieure dans une variable locale, souvent nommée `that`, permet à la fonction interne d’y accéder par la portée lexicale.

Analyse

La règle du site d’appel est un antidote pratique à une intuition fréquente : l’idée qu’une fonction appartiendrait de façon permanente à l’objet où elle apparaît pour la première fois. En réalité, une fonction peut être transmise d’un endroit à l’autre, tandis que son récepteur éventuel change. Cela rend this flexible, mais en fait aussi une source d’erreurs de contexte. La solution de contournement proposée dans le livre pour les fonctions imbriquées illustre clairement la différence entre contexte d’appel dynamique et portée lexicale des variables. Cette explication est propre à une période historique : les versions ultérieures de JavaScript ajoutent d’autres outils et règles ; il ne faut donc pas prendre la description ES3 pour un exposé complet de tous les modes d’exécution modernes.

Utilisez les fermetures pour permettre aux fonctions de conserver l’accès à la portée où elles ont été définies.

Les fonctions créent une portée. Dans le contexte de JavaScript 1.5 décrit par le livre, les variables déclarées avec `var` à l’intérieur d’une fonction appartiennent à cette fonction, et les fonctions imbriquées peuvent lire les variables des fonctions qui les englobent. JavaScript cherche d’abord dans la portée locale, puis dans chacune des portées englobantes, et enfin dans la portée globale. La première variable correspondante l’emporte: un nom local peut donc masquer une variable du même nom située plus loin.

Une fermeture préserve l’accès. Si une fonction renvoie une fonction imbriquée, cette fonction renvoyée peut continuer à utiliser les variables de la portée où elle a été définie, même après la fin de la fonction externe. Le compteur de Lindley s’appuie sur ce mécanisme pour conserver un décompte privé entre les appels. Le livre avertit également que, dans cette version, les instructions `if` et les boucles ne créent pas de portée de bloc, et qu’une affectation à une variable non déclarée peut créer une propriété globale.

Analyse

Les fermetures sont plus faciles à comprendre comme un accès lexical ordinaire qui persiste que comme une astuce particulière. Le compteur montre pourquoi cette persistance importe : la fonction renvoyée conserve son état sans exposer directement la variable. Cela rejoint naturellement l’encapsulation, les fonctions de rappel et la conception modulaire. L’avertissement concernant les affectations à des variables non déclarées est tout aussi important, car les variables globales accidentelles transforment un raisonnement local en couplage à l’échelle du programme. Les règles de portée du chapitre appartiennent toutefois à l’époque d’ES3. JavaScript moderne comprend des déclarations à portée de bloc ; il vaut donc mieux lire cette explication comme un exposé de la version du langage enseignée par le livre, et non comme un guide actuel de la syntaxe.

N’oubliez pas que les tableaux sont des objets dotés d’indices numériques et d’une propriété `length` particulière.

Utilisez les tableaux pour les valeurs ordonnées. Un tableau est un objet conçu pour contenir des valeurs auxquelles on accède par des indices numériques, à partir de zéro. Sa propriété `length` ne correspond pas à l’indice de son dernier élément: dans un tableau à un élément, la valeur se trouve à l’indice `0` et la longueur est de `1`. Les tableaux peuvent contenir n’importe quelle valeur JavaScript, y compris d’autres tableaux, et les littéraux tels que `['blue', 'green']` sont la forme concise la plus courante.

Attention aux espaces clairsemés. Affecter une valeur à l’indice `50` porte la longueur du tableau à `51`, même si les positions intermédiaires ne contiennent pas nécessairement d’éléments réels. Passer un entier unique à `new Array`, par exemple `new Array(100)`, définit la longueur au lieu d’insérer le nombre comme élément. Réduire `length` peut supprimer les éléments situés au-delà du nouvel indice final. Pour des clés nommées, utilisez un objet plutôt qu’un tableau.

Analyse

Considérer les tableaux comme des objets spécialisés aide à comprendre à la fois leur souplesse et leurs bizarreries. La propriété spéciale length dépend de l’indice numérique le plus élevé qui a été affecté, et non du nombre de cases occupées ; les trous peuvent donc rendre cette longueur trompeuse comme mesure des données stockées. La forme du constructeur qui prend un seul nombre illustre également une syntaxe dont le sens change selon le contexte. Ces détails étayent une règle utile : choisissez un tableau pour les collections ordonnées indexées, et un objet pour les associations nommées. Ce choix clarifie l’intention de la structure de données, tant pour l’environnement d’exécution que pour la personne qui lira le code par la suite.

Distinguez les objets intégrés à JavaScript de ceux fournis par son environnement hôte.

Sachez ce qui exécute le code. Le livre distingue les objets natifs fournis par JavaScript des objets hôtes fournis par l’environnement. Dans un navigateur, l’objet `window` est l’objet racine, ou global, dans la description ES3; les fonctionnalités du navigateur, telles que l’interface du document, sont fournies par cet hôte et non par ECMAScript lui-même. D’autres environnements peuvent fournir d’autres objets hôtes.

Ne confondez pas les termes liés au global. L’objet racine est l’environnement de niveau supérieur, tandis qu’une variable ou propriété globale est une valeur particulière accessible depuis cette portée. Le code du navigateur peut souvent utiliser une fonction globale sans écrire `window.`, car la recherche trouve l’objet global. Cette distinction aide à comprendre pourquoi le comportement du langage JavaScript et celui du navigateur sont liés, sans être identiques.

Analyse

Cette frontière reste un modèle mental utile, même si les environnements entourant JavaScript évoluent. Le langage définit un ensemble de valeurs et de règles ; un navigateur ou un autre environnement d’exécution fournit des API qui permettent au code d’interagir avec ce qui l’entoure. Les confondre peut amener les développeurs à supposer qu’une fonctionnalité de navigateur existe partout ou que tous les environnements se comportent comme une page Web. Le vocabulaire du livre autour de window reflète son époque, centrée sur le navigateur, et doit être compris dans ce contexte. La leçon durable ne tient pas au nom de l’objet global, mais à la nécessité d’identifier la couche qui fournit une capacité donnée.

Utilisez `null` pour une absence intentionnelle et laissez `undefined` signaler une valeur manquante.

Distinguez les formes d’absence. Dans l’explication de Lindley, `null` indique explicitement qu’une valeur est attendue, mais indisponible pour le moment. `undefined` indique couramment qu’une variable n’a pas reçu de valeur ou qu’une propriété demandée n’a pas été trouvée, y compris après la recherche dans la chaîne de prototypes. Cette distinction permet de signaler si une valeur vide a été définie délibérément ou si elle n’a tout simplement jamais été fournie.

Effectuez des tests précis. JavaScript renvoie `object` pour `typeof null`, une ancienne incohérence qui fait de `typeof` un mauvais moyen de vérifier la valeur null. Utilisez `value === null` pour identifier spécifiquement `null`; l’égalité souple peut considérer `null` et `undefined` comme équivalents. Le livre recommande également de laisser JavaScript produire `undefined` plutôt que de l’affecter manuellement. Cette pratique préserve son utilité comme signal indiquant qu’une valeur n’a pas été fournie ou trouvée.

Analyse

La distinction est surtout utile lorsqu’elle correspond à une convention délibérée : un état signifie « vide de façon intentionnelle », l’autre « absent ou pas encore initialisé ». Sans cette convention, les deux valeurs risquent de devenir de vagues substituts, et la distinction perd alors son intérêt. Le conseil d’utiliser l’égalité stricte est particulièrement pratique, car il évite une ambiguïté connue des comparaisons souples. Cela dit, les programmes JavaScript ont souvent besoin de plus de deux états d’absence, par exemple pour distinguer un argument omis d’un champ explicitement effacé. L’avantage essentiel n’est pas de choisir une convention universelle, mais de donner à chaque état un sens cohérent et vérifiable.

Analyse

JavaScript Enlightenment est un précis technique concis centré sur les objets, et non une référence exhaustive du langage. Son idée directrice est que les développeurs gagnent en compétence lorsqu’ils comprennent les mécanismes qui se cachent derrière la syntaxe et les bibliothèques familières. Lindley construit cette compréhension à l’aide de courts exemples de code et de contrastes répétés: valeurs primitives et valeurs composites, instance et prototype, définition et invocation d’une fonction, objets natifs du langage et objets fournis par l’hôte. Ces contrastes ne se contentent pas de définir le vocabulaire. Ils apprennent aux lecteurs à se demander où se trouve une valeur, comment une propriété est recherchée et quel contexte reçoit une fonction.

Le meilleur choix pédagogique est l’usage récurrent d’expériences concrètes. Une valeur primitive copiée reste indépendante, tandis que deux variables faisant référence à un même objet rendent visible la même mutation. Une méthode de tableau semble appartenir à une instance, mais se trouve par l’intermédiaire de son prototype. Une fonction renvoyée conserve l’accès à une variable provenant de la fonction qui l’englobait auparavant. Chaque exemple rend observable une règle invisible. Le livre convient donc particulièrement aux lecteurs qui ont appris JavaScript en utilisant des bibliothèques et qui veulent comprendre les relations de cause à effet plutôt que consulter un nouveau catalogue d’API.

Sa principale limite tient à son orientation explicitement historique vers JavaScript 1.5 et ECMAScript 3. Certaines explications s’appuient sur le comportement des anciens navigateurs, et les simplifications du livre à propos des références mémoire ou des enveloppes temporaires doivent être considérées comme des modèles pédagogiques plutôt que comme une spécification complète. JavaScript moderne a apporté de nouvelles syntaxes et modifié les conventions pratiques; le livre ne peut donc pas servir seul de manuel contemporain. Ses distinctions fondamentales restent néanmoins utiles: les valeurs diffèrent des références, les prototypes participent à la recherche des propriétés et le comportement des fonctions dépend à la fois de la portée lexicale et du contexte d’invocation. Lu comme une carte des mécanismes fondamentaux de son époque, et non comme une autorité définitive sur la syntaxe actuelle, il offre toujours un parcours cohérent qui mène de l’utilisation des bibliothèques au raisonnement sur le langage lui-même.

Résumé en 30 secondes
Les valeurs primitives sont copiées, tandis que l’affectation d’objets partage l’accès au même objet ; les modifications peuvent donc être visibles par l’intermédiaire de plusieurs variables. La recherche de propriétés examine d’abord l’objet, puis sa chaîne de prototypes ; les méthodes partagées ont leur place sur les prototypes, tandis que les données propres à chaque instance restent sur l’objet correspondant. L’appel d’une fonction détermine son contexte, tandis que les fermetures préservent l’accès aux variables englobantes. Distinguez les valeurs `null` délibérées des valeurs `undefined` manquantes ou non assignées.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

3.54 sur 5
Moyenne de 189 évaluations de Goodreads et Amazon.

JavaScript Enlightenment reçoit des avis mitigés, avec une note moyenne de 3,55 sur 5. Certains lecteurs apprécient la clarté qu’il apporte aux concepts JavaScript, notamment pour les débutants et les personnes qui passent de l’utilisation de bibliothèques au développement. Les critiques le trouvent répétitif et potentiellement dangereux en raison de la manière dont il présente des anti-modèles. Le livre est salué pour sa simplicité et l’importance qu’il accorde aux objets, mais critiqué pour son contenu dépassé et ses répétitions excessives. Il est généralement recommandé aux personnes qui découvrent JavaScript ou en maîtrisent les bases, même si certains suggèrent de l’associer à d’autres ressources pour acquérir une compréhension complète.

Votre note :
4.17
164 évaluations
Envie de lire le livre complet ?

Les lecteurs ont aussi lu

Glossaire

découpage pédagogique en petites unités (technical thin-slicing)

Courtes leçons accompagnées d’exemples exécutables

L’approche pédagogique de l’auteur, qui consiste à diviser les idées complexes de programmation en explications courtes et digestes, puis à les étayer par des exemples de code ciblés. Au lieu de s’appuyer sur de longs développements théoriques, elle invite les lecteurs à examiner, exécuter et modifier les exemples jusqu’à ce que le comportement sous-jacent devienne clair.

valeurs primitives

Valeurs simples et indivisibles

Valeurs telles que les chaînes de caractères, les nombres, les booléens, null et undefined, qui sont considérées comme simples plutôt que comme des assemblages de propriétés. Dans le modèle du livre, les primitives sont copiées et comparées par valeur. Les chaînes, les nombres et les booléens peuvent temporairement permettre un accès aux propriétés comme s’il s’agissait d’objets, grâce au mécanisme des objets enveloppes, contrairement à null et undefined.

valeurs composites

Valeurs composites fondées sur des références

Objets tels que les tableaux, les fonctions et les objets ordinaires, qui peuvent contenir plusieurs valeurs ou y faire référence. Le livre explique qu’ils sont copiés par référence : affecter une variable à une autre donne aux deux accès au même objet, au lieu de créer une copie indépendante. Des objets créés séparément restent différents selon l’égalité stricte, même si leur contenu est identique.

chaîne de prototypes

Objets liés que l’on parcourt pour rechercher des propriétés

La séquence d’objets prototypes que JavaScript vérifie lorsqu’une propriété demandée n’est pas présente directement sur un objet. Une instance peut hériter de méthodes du prototype de son constructeur, et la recherche se poursuit à travers les prototypes suivants jusqu’à ce qu’une correspondance soit trouvée ou que la chaîne prenne fin. Ce mécanisme permet de partager des comportements hérités sans copier chaque méthode sur chaque instance.

chaîne de portée

Portées imbriquées parcourues pour rechercher des noms

L’ensemble ordonné des portées lexicales que JavaScript examine lorsqu’il résout une référence à une variable. La recherche commence dans la fonction courante, puis passe par les portées des fonctions englobantes et finit par atteindre la portée globale. La première déclaration correspondante fournit la valeur : une variable plus proche peut donc masquer une variable de même nom située plus loin.

fermeture (closure)

Fonction qui conserve l’accès à sa portée de définition

Fonction qui continue d’accéder aux variables de la portée dans laquelle elle a été définie, même lorsqu’elle est appelée après le retour de la fonction englobante. Le livre l’illustre avec un compteur : une fonction externe renvoie une fonction interne, et les appels répétés de cette dernière mettent à jour une valeur conservée dans la portée externe.

objet racine (head object)

Environnement global de niveau supérieur

Terme employé dans le livre pour désigner l’objet de plus haut niveau qui contient ou expose le code global et les fonctionnalités du langage. Dans ses exemples de navigateur, cet objet est window. Ce terme doit être compris dans le cadre de la présentation ES3 du livre : il distingue l’environnement global des variables globales individuelles et des objets fournis par l’hôte.

objets hôtes

Objets fournis par l’environnement d’exécution

Objets fournis par l’environnement dans lequel JavaScript s’exécute, plutôt que par le langage ECMAScript lui-même. Dans le livre, les interfaces window et document d’un navigateur en sont des exemples. Leur disponibilité et leur comportement dépendent de l’hôte ; il ne faut donc pas les confondre avec les objets natifs de JavaScript, tels que Array ou Function.

FAQ

De quoi parle « JavaScript Enlightenment » de Cody Lindley ?

  • Les objets JavaScript au premier plan : le livre propose une étude approfondie des objets natifs de JavaScript, de leurs propriétés et des subtilités du fonctionnement interne du langage.
  • Pas un guide pour débutants : il ne s’adresse ni aux personnes qui débutent en programmation ou en JavaScript, ni à celles qui cherchent un recueil de recettes ou un manuel de patrons de conception.
  • Un résumé accessible d’ECMAScript 3 : le contenu propose une synthèse concise et abordable de la spécification ECMAScript 3 (JavaScript 1.5), axée sur la nature et le comportement des objets.
  • De l’utilisation de bibliothèques au développement : le livre vise à aider les personnes qui ont utilisé des bibliothèques JavaScript (comme jQuery) à devenir de véritables développeurs JavaScript en comprenant le langage lui-même.
  • Une approche centrée sur le code : le livre privilégie l’apprentissage par des exemples de code, les explications venant en complément.

Pourquoi lire « JavaScript Enlightenment » de Cody Lindley ?

  • Comprendre les mécanismes internes de JavaScript : il vous aide à dépasser l’utilisation de bibliothèques et de frameworks pour comprendre le fonctionnement de JavaScript lui-même, en particulier son système d’objets.
  • Éviter l’effet « boîte noire » : en apprenant les fondements du langage, vous serez mieux à même de déboguer, d’optimiser et d’écrire du code JavaScript robuste.
  • Court et ciblé : contrairement aux ouvrages de référence exhaustifs, il propose une exploration concise et ciblée des concepts les plus importants.
  • Du code pratique et concret : le livre s’appuie sur le « découpage pédagogique en petites unités (technical thin-slicing) » : il décompose les sujets complexes en courts éléments digestes, accompagnés de code réel et exécutable.
  • Des bases pour aller plus loin : la maîtrise de ces fondamentaux vous prépare à aborder des sujets JavaScript plus avancés et les futures versions du langage.

Quels sont les principaux enseignements de « JavaScript Enlightenment » de Cody Lindley ?

  • Les objets sont au cœur du langage : presque tout en JavaScript est un objet ou peut se comporter comme tel ; comprendre les objets est essentiel pour maîtriser le langage.
  • Valeurs primitives et valeurs composites : JavaScript distingue les valeurs primitives (comme les nombres, les chaînes et les booléens) des objets composites ; leur stockage, leur copie et leur comparaison obéissent à des règles différentes.
  • Fonctions constructrices et prototypes : JavaScript utilise les fonctions constructrices et la chaîne de prototypes pour créer des objets et gérer l’héritage, aussi bien en natif que dans le code écrit par l’utilisateur.
  • Un langage dynamique et mutable : les objets et leurs propriétés sont dynamiques et mutables, ce qui permet des comportements puissants, mais parfois déroutants.
  • Portée, fermetures et this : le livre clarifie le fonctionnement de la portée, des fermetures et du mot-clé this, qui sont souvent des sources de confusion pour les développeurs.

Comment « JavaScript Enlightenment » de Cody Lindley explique-t-il les objets JavaScript et leur création ?

  • Des objets qui contiennent des propriétés : les objets sont présentés comme des conteneurs de valeurs nommées (les propriétés), qui peuvent être des données ou des fonctions (méthodes).
  • Plusieurs modes de création : le livre traite de la création d’objets à l’aide de constructeurs (par exemple, new Object(), new Person()), de littéraux d’objet ({}) et de fonctions constructrices personnalisées.
  • Constructeurs natifs et constructeurs définis par l’utilisateur : il distingue les neuf constructeurs natifs de JavaScript (comme Object, Array et String) des constructeurs définis par l’utilisateur pour créer des types d’objets personnalisés.
  • La concision des littéraux : le livre montre comment les littéraux d’objet et de tableau offrent des moyens pratiques et concis de créer des objets et des tableaux, souvent privilégiés pour leur lisibilité et leur brièveté.
  • Méthodes et propriétés dynamiques : il explique que les méthodes sont simplement des propriétés contenant des fonctions et que les objets peuvent être étendus dynamiquement à l’exécution.

Quelle est la différence entre les valeurs primitives et les valeurs composites dans « JavaScript Enlightenment » de Cody Lindley ?

  • Valeurs primitives : elles comprennent les nombres, les chaînes, les booléens, null et undefined. Elles sont simples, immuables et stockées ou copiées par valeur.
  • Valeurs composites (par référence) : les objets, les tableaux, les fonctions et les autres types non primitifs sont stockés et copiés par référence, et non par valeur.
  • Tests d’égalité : les primitives sont comparées par valeur (10 === 10 vaut true), tandis que les objets composites sont comparés par référence (deux objets identiques ne sont pas égaux à moins qu’ils ne désignent le même objet).
  • Objets enveloppes : les primitives peuvent temporairement se comporter comme des objets lors de l’accès à des propriétés ou à des méthodes, grâce à la création automatique d’objets enveloppes par JavaScript.
  • Comportement de la copie : copier une primitive crée une valeur nouvelle et indépendante ; copier une valeur composite copie la référence, si bien que les modifications affectent toutes les références.

Comment « JavaScript Enlightenment » de Cody Lindley décrit-il la chaîne de prototypes et l’héritage ?

  • Propriété prototype : chaque fonction JavaScript possède une propriété prototype, qui est un objet utilisé pour l’héritage.
  • Recherche dans la chaîne de prototypes : lors de l’accès à une propriété, JavaScript vérifie d’abord l’objet lui-même, puis le prototype de son constructeur, et poursuit la recherche dans la chaîne jusqu’à Object.prototype.
  • Mécanisme d’héritage : les constructeurs natifs comme ceux définis par l’utilisateur se servent de la chaîne de prototypes pour partager des méthodes et des propriétés entre les instances.
  • Mises à jour dynamiques : les modifications apportées au prototype d’un constructeur sont visibles pour toutes les instances, mais le remplacement de l’objet prototype n’affecte que les instances créées par la suite.
  • Héritage personnalisé : le livre montre comment mettre en place des chaînes d’héritage entre des constructeurs définis par l’utilisateur, selon des modèles proches de l’héritage classique.

Qu’enseigne « JavaScript Enlightenment » de Cody Lindley sur les fonctions, la portée et les fermetures ?

  • Les fonctions comme objets de première classe : les fonctions peuvent être stockées dans des variables, passées en arguments, renvoyées par d’autres fonctions et dotées de propriétés.
  • Portée et portée lexicale : JavaScript utilise une portée de fonction, et non une portée de bloc ; la chaîne de portée est déterminée par l’endroit où les fonctions sont définies, et non par celui où elles sont appelées.
  • Fermetures : les fonctions conservent l’accès à leur portée de définition, même lorsqu’elles sont exécutées en dehors de celle-ci, ce qui permet des modèles de fermeture puissants.
  • Le mot-clé this : la valeur de this dépend de la manière dont une fonction est appelée — globalement, comme méthode, comme constructeur ou via call/apply.
  • Modèles de fonctions : le livre aborde les déclarations de fonction, les expressions de fonction, les constructeurs, les fonctions anonymes, les fonctions auto-invoquées et la récursion.

Comment « JavaScript Enlightenment » de Cody Lindley explique-t-il les propriétés des objets et leur accès ?

  • Notation pointée et notation entre crochets : les propriétés peuvent être consultées et définies au moyen de la notation pointée (obj.prop) ou de la notation entre crochets (obj['prop']), qui permet d’utiliser des noms de propriétés dynamiques ou non standard.
  • Caractère dynamique et mutable : les propriétés peuvent être ajoutées, mises à jour ou supprimées à tout moment, ce qui reflète la nature mutable de JavaScript.
  • Recherche de propriétés et héritage : si une propriété ne se trouve pas sur l’objet, JavaScript la recherche dans la chaîne de prototypes.
  • Énumération des propriétés : la boucle for...in peut énumérer les propriétés, mais elle peut inclure les propriétés héritées si l’on ne filtre pas avec hasOwnProperty.
  • Suppression de propriétés : l’opérateur delete supprime des propriétés des objets, mais pas de la chaîne de prototypes.

Quelles recommandations « JavaScript Enlightenment » de Cody Lindley donne-t-il concernant les objets natifs et les constructeurs ?

  • Neuf constructeurs natifs : JavaScript fournit Object, Array, String, Number, Boolean, Function, Date, RegExp et Error comme constructeurs intégrés.
  • Syntaxe littérale ou syntaxe de constructeur : dans la plupart des cas, il est préférable d’utiliser des littéraux (par exemple, {}, [], '', 42) plutôt que des constructeurs, pour des raisons de clarté et de performance.
  • Math, un objet statique : l’objet Math est particulier : ce n’est pas un constructeur et il ne peut pas être instancié.
  • Prudence avec les objets enveloppes : les constructeurs comme new String() ou new Boolean() créent des objets, et non des primitives, ce qui peut entraîner des comportements inattendus.
  • Extension des objets natifs : bien que ce soit possible, il est déconseillé de modifier les prototypes natifs (comme Array.prototype), en raison des conflits possibles et des difficultés de maintenance.

Comment « JavaScript Enlightenment » de Cody Lindley traite-t-il du mot-clé this et des modes d’appel des fonctions ?

  • La valeur de this dépend du contexte : elle est déterminée par la façon dont une fonction est appelée : comme méthode, comme constructeur ou avec call/apply.
  • Fonctions globales et imbriquées : en mode non strict, this désigne par défaut l’objet global (par exemple, window) lorsqu’une fonction n’est appelée ni comme méthode ni comme constructeur.
  • Perte de this dans les fonctions imbriquées : les fonctions imbriquées n’héritent pas du this de la fonction externe ; une solution courante consiste à affecter var that = this dans la portée externe.
  • call() et apply() : ces méthodes permettent de contrôler explicitement la valeur de this lors de l’appel d’une fonction.
  • Fonctions constructrices : lorsqu’une fonction est appelée avec new, this désigne la nouvelle instance créée.

Que dit « JavaScript Enlightenment » de Cody Lindley sur la portée, les fermetures et la déclaration des variables ?

  • Portée de fonction uniquement : les variables JavaScript ont une portée de fonction, et non de bloc ; if et for ne créent pas de nouvelles portées.
  • Utilisation de var : déclarez toujours les variables avec var à l’intérieur des fonctions afin d’éviter de polluer la portée globale.
  • Chaîne de portée : la recherche d’une variable suit la chaîne de portée, de la portée locale à la portée globale, et s’arrête à la première correspondance.
  • Explication des fermetures : les fonctions conservent l’accès à leur portée de définition, ce qui permet aux fermetures de maintenir un état entre plusieurs appels.
  • Remontée des déclarations : les déclarations de fonction sont remontées, ce qui permet de les appeler avant leur définition ; les expressions de fonction ne le sont pas.

Quelles sont les meilleures citations de « JavaScript Enlightenment » de Cody Lindley et que signifient-elles ?

  • « Les objets règnent : presque tout est un objet ou se comporte comme tel. »
    Cela souligne la place centrale des objets en JavaScript et l’importance de les comprendre pour maîtriser le langage.
  • « Le découpage pédagogique en petites unités… qui réduit les sujets complexes en concepts plus courts et digestes, enseignés avec peu de mots et étayés par des exemples de code complets et ciblés. »
    La philosophie pédagogique de Lindley consiste à rendre les notions complexes abordables au moyen de leçons guidées par le code.
  • « Tout en JavaScript peut se comporter comme un objet. »

À propos de l'auteur

Cody Lindley est un développeur chevronné spécialisé dans le front-end et JavaScript, qui possède plus de 20 ans d’expérience professionnelle en HTML, CSS, JavaScript et techniques d’optimisation des performances côté client. Il a travaillé dans le développement Flash et se concentre sur la conception d’interfaces et d’interactions ainsi que sur l’architecture d’applications front-end. Lindley vit à Meridian, dans l’Idaho, avec son épouse et leurs trois fils. En dehors de ses activités techniques, il aspire à devenir un « apologiste à un dollar » et défend, avec raison et empathie, les éléments en faveur d’une vision chrétienne classique du monde sur c-m-c-a.com.

Télécharger le PDF

Pour garder le résumé de JavaScript Enlightenment 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 JavaScript Enlightenment 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 25 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...