Javascript pour le Web 2.0

509 Pages·2006·5.76 MB·French

12009_JavaScript_XP 6/12/06 10:20 Page 1
JavaScript
rn
eo
JavaScript plige
mu
eo
TG

..
Web 2.0 TA Web 2.0
pour le Thierry Templier
Diplômé de l’ESIGETEL, Thierry pour le
Templier est architecte
et expert J2EE au sein
La puissance de JavaScript révélée par Ajax et le Web 2.0 d’une société de services
en informatique à Nantes.
JavaScript est longtemps resté un langage au potentiel sous-estimé, mal aimé et souvent mal
Il travaille actuellement
maîtrisé par les développeurs Web. Jusqu’à l’émergence d’Ajax et du Web 2.0 qui ont mis en Programmation objet, DOM, Ajax,
sur des projets d’entreprise
lumière les possibilités spectaculaires et insoupçonnées offertes par ce langage.
mettant enœuvre des
L’objectif du présent ouvrage est de vous amener bien au-delà de l’utilisation usuelle basique de Prototype, Dojo, Script.aculo.us, Rialto…
frameworks Java/J2EE
JavaScript, en vous montrant comment développer avec efficacité des applications Web 2.0
tels que Spring
performantes et faciles à maintenir. Après un rappel de la syntaxe de base du langage, vous
approfondirez les différents aspects avancés du langage et de son environnement : programmation et Hibernate ainsi que t0
des frameworks JavaScript
orientée objet, utilisation avancée du DOM, échanges HTTP asynchrones à l’aide XMLHttpRequest,
et Ajax tels que Prototype,
interaction avec (X)HTML et CSS, création de composants graphiques, etc. p
Dojo et DWR. .
Les bonnes pratiques du développement Web 2.0 illustrées par une étude de cas 2
Arnaud Gougeon i
Une part importante de l’ouvrage est dédiée aux indispensables bibliothèques JavaScript, grâce
Diplômé de l’ESIEA, Arnaud r
auxquelles vous gagnerez en temps et en qualité de développement, tout en enrichissant vos
Gougeon est architecte
applications de composants graphiques sophistiqués. Vous apprendrez également comment
intégrer via le protocole REST les services Web proposés par des sites tels que Google Maps, en systèmes d’information cb
et spécialiste J2EE pour
Yahoo! ou Amazon.
L’accent est mis tout au long de l’ouvrage sur les bonnes pratiques de développement JavaScript : une société nantaise dans Se
le domaine de la banque
séparation du code (X)HTML, CSS et JavaScript, mise en œuvre de composants, tests unitaires, etc.
Cette démarche est illustrée par une étude de cas détaillée, qui fait appel à la bibliothèque Dojo et et de l’assurance. Depuis W
2001, il a notamment réalisé
aux services Google Maps, et dont le code source est en libre accès sur jsweb2.sourceforge.net.
des applications Web a T h i e r r y T e m p l i e r
de gestion basées sur
Au sommaire les technologies JavaScript
v e
Les fondements de JavaScript. Syntaxe de base •Programmation objet avec JavaScript •Programmation DOM et Ajax.
• Ajax : XMLHttpRequest, échanges de données, contournement des restrictions. Bibliothèques JavaScript l A r n a u d G o u g e o n

généralistes. Prototype: éléments de base, support du DOM et d’Ajax •Dojo: éléments de base, support du a
r
DOM et d’Ajax. Programmation graphique Web. Les fondements: (X)HTML, CSS, interaction avec JavaScript,
u
XML et XSLT •Création de composants graphiques. Bibliothèques graphiques. Bibliothèques graphiques légères:
Prototype, Behaviour, Script.aculo.us • Dojo et ses composants graphiques • Rialto et ses composants J o
graphiques. Utilisation de services externes. Google Maps •Exemples de services REST: Yahoo! et Amazon.
p
Outils de développement. Tests unitaires avec JsUnit •Outils de débogage, de documentation et d’optimisation. 7
Code éditeur:G12009ISBN-10: 2-212-12009-5SBN-13: 978-2-212-12009- 782212120097 Conception: Nord Compo
I 9
42 €
Remerciements
Nous remercions Éric Sulpice, directeur éditorial d’Eyrolles, et Olivier Salvatori pour
leurs multiples relectures et conseils.
Enfin, merci à toutes les personnes qui ont eu la gentillesse de nous soutenir et de nous
relire, notamment Jean-Philippe Retaillé et Stéphane Labbé.
Merci également à Cyril Balit et François Lion, créateurs et développeurs de la biblio-
thèque Rialto, pour leur précieuse aide dans le chapitre relatif à cette bibliothèque.
Arnaud Gougeon:
Merci à ma femme, Anouk, et à ma famille pour m’avoir soutenu tout au long de l’écri-
ture de cet ouvrage.
Thierry Templier:
Merci à ma femme, Séverine, pour son soutien et son aide précieuse tout au long de ce
projet. Merci également à toutes les personnes qui m’ont soutenu tout au long de ce
projet.
LivreGougeon Page V Mardi, 28. novembre 2006 4:23 16
Avant-propos
JavaScript est un langage de script très populaire, utilisé notamment afin d’implémenter
des traitements dans les pages Web. Tout au long de cet ouvrage, nous nous efforçons de
détailler les différents concepts de ce langage ainsi que les mécanismes à mettre en
œuvre afin de l’utiliser dans ce type de pages.
Le langage JavaScript permet de réaliser des traitements évolués dans les pages Web en
offrant la possibilité d’utiliser les différents standards Web supportés par les navigateurs
et d’interagir avec eux. Certaines spécificités de ces derniers restent néanmoins à prendre
en compte afin de garantir leur portabilité.
Longtemps freinée par le support hétérogène de ces standards, l’utilisation du langage
JavaScript a été facilitée par l’apparition de bibliothèques intégrant la prise en compte de
ces spécificités quant à la résolution de problématiques particulières.
De solides connaissances sont nécessaires pour mettre en œuvre ce langage dans des
applications de type Web 2.0, dont l’interface graphique est plus évoluée et interactive.
Heureusement, des bibliothèques JavaScript ont été mises au point afin d’aider au déve-
loppement de ce type d’application Web.
Loin d’être uniquement dédié aux applications de type Web 2.0, JavaScript ouvre d’inté-
ressantes perspectives afin d’améliorer et d’optimiser les interfaces graphiques des appli-
cations Web classiques en se fondant sur les techniques Ajax.
Objectifs de cet ouvrage
Cet ouvrage se veut un guide pratique pour le développement de traitements fondés sur le
langage JavaScript dans les pages Web.
Nous avons voulu le rendre accessible au plus grand nombre afin de permettre à tout
développeur Web d’utiliser ce langage dans différents contextes et de devenir plus
productif dans son utilisation de JavaScript. C’est la raison pour laquelle il détaille aussi
bien les mécanismes de base du langage que son utilisation dans des pages Web. Avant
tout didactique, il vise à rendre le lecteur directement opérationnel dans l’utilisation des
différentes facettes du langage.
LivreGougeon Page VI Mardi, 28. novembre 2006 4:23 16
JavaScript pour le Web 2.0
VI
Tout au long de l’ouvrage, nous mettons en œuvre diverses bibliothèques JavaScript
gratuites et populaires. Ces dernières adressent un ou plusieurs aspects des développements
fondés sur ce langage et intègrent les spécificités des différents navigateurs pour la prise
en compte des standards Web.
Cette volonté d’accessibilité ne signifie pas pour autant que l’ouvrage soit d’une lecture
simple et peu technique. Au contraire, nous y abordons des sujets avancés, tels que les
principes de la programmation orientée objet et d’Ajax, ainsi que des bonnes pratiques
afin de structurer et optimiser les développements fondés sur JavaScript.
Convaincus que l’on apprend mieux par la pratique, nous proposons au lecteur une étude
de cas pratique, sous la forme d’une application de gestion de sites archéologiques. Cette
application s’appuie sur la bibliothèque dojo et sur l’outil Google Maps, dont l’ouvrage
détaille la mise en œuvre conjointe.
Organisation de l’ouvrage
L’ouvrage commence par décrire les concepts et mécanismes de base de JavaScript. Il
aborde ensuite les mécanismes relatifs à la programmation graphique avec ce langage,
conjointement avec les langages HTML, xHTML et CSS.
Diverses bibliothèques facilitant l’utilisation des mécanismes abordés sont présentées et
mises en œuvre.
Nous avons fait l’effort de dégager autant que de besoin les bonnes pratiques d’utilisation
de ce langage.
L’ouvrage comporte les six grandes parties suivantes :
• La première partie introduit les mécanismes de base du langage JavaScript. La manière de
mettre en œuvre la programmation orientée objet ainsi que le support de la technologie
DOM par ce langage y sont décrits et détaillés. Les techniques Ajax sont également
abordées afin de permettre l’échange de données par les pages Web sans les recharger.
• La partie II concerne les bibliothèques JavaScript de base, dont l’objectif est de faci-
liter l’utilisation des divers mécanismes du langage abordés dans la première partie.
Sont ainsi introduites les fondations de prototype, une bibliothèque JavaScript légère
et populaire, et de dojo, une bibliothèque très complète.
• Avec la partie III, l’ouvrage aborde les problématiques graphiques des traitements
JavaScript dans les pages Web. Après avoir rappelé le fonctionnement des langages
HTML, xHTML et CSS, nous montrons comment JavaScript peut interagir avec ces
langages et comment mettre en œuvre des composants graphiques. L’accent est mis
tout au long de cette partie sur la structuration et la séparation des différents langages
et traitements mis en œuvre.
• Afin de développer des applications graphiques avec le langage JavaScript, bien des
aspects doivent être pris en compte et maîtrisés. De nombreuses bibliothèques Java-
Script sont disponibles sur Internet afin de masquer ces problématiques et de mettre à
LivreGougeon Page VII Mardi, 28. novembre 2006 4:23 16
Avant-propos
VII
disposition des mécanismes et des composants graphiques prêts à l’emploi et portables.
La partie IV introduit certaines d’entre elles, notamment prototype, script.aculo.us et
behaviour. Par la suite, sont décrites les bibliothèques dojo et rialto, plus complètes et
offrant des mécanismes de gestion des composants graphiques.
• Dans la philosophie du Web 2.0, où le Web correspond à une véritable plate-forme, la
partie V aborde les problématiques relatives à l’intégration et à l’interaction avec des
services externes dans des pages Web en se fondant sur le langage JavaScript. Y sont
notamment présentés Google Maps, l’outil cartographique de Google, et la manière
d’utiliser des données de services des sites Yahoo! et Amazon, accessibles par le biais
de l’architecture REST.
• La partie VI décrit divers outils connexes au langage JavaScript permettant d’améliorer
la qualité des traitements JavaScript ainsi que la productivité de leur développement.
Sont abordés les tests unitaires avec JsUnit et l’outillage disponible pour l’écriture et la
mise en œuvre de ce type de traitement.
À propos de l’étude de cas
L’étude de cas, une application de gestion de sites archéologiques, est un exemple concret
d’utilisation du langage JavaScript, de la bibliothèque dojo et de l’outil Google Maps.
Elle permet au lecteur de voir concrètement comment les différents mécanismes et tech-
niques abordés tout au long de l’ouvrage peuvent être utilisés conjointement afin de
développer une application Web riche et interactive.
Loin de n’être qu’un simple exemple, cette application correspond à un prototype servant
de fondation à une application de gestion de données archéologiques pour une université
française.
L’étude de cas est accessible en démonstration sur la page du site de SourceForge dédiée
à l’ouvrage, à l’adresse http://jsweb2.sourceforge.net.
À qui s’adresse l’ouvrage ?
Cet ouvrage s’adresse à tout développeur Web souhaitant découvrir ou redécouvrir le
langage JavaScript. L’accent a été mis sur les mécanismes de base du langage ainsi que
sur les possibilités offertes au développement de traitements simples ou évolués dans des
pages Web dans l’esprit du Web 2.0.
Il n’est nul besoin d’être expert dans les technologies présentées. Chaque chapitre
présente clairement chacune d’elles puis montre comment le langage JavaScript la met
en œuvre ou interagit avec. Les différents langages, tels que HTML, xHTML et CSS,
ainsi que les techniques mis en œuvre dans les pages Web sont également détaillés.
Pour toute question concernant l’ouvrage, vous pouvez contacter ses auteurs sur la page Web
dédiée du site d’Eyrolles, à l’adresse www.editions-eyrolles.com, ou sur le site de l’ouvrage, à
l’adresse jsweb2.sourceforge.net.
LivreGougeon Page VIII Mardi, 28. novembre 2006 4:23 16
LivreGougeon Page IX Mardi, 28. novembre 2006 4:23 16
Table des matières
Avant-propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . V
Objectifs de cet ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . V
Organisation de l’ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VI
À propos de l’étude de cas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VII
À qui s’adresse l’ouvrage ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VII
Table des matières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IX
CHAPITRE 1
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Le langage JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Historique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
ECMAScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
JavaScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
JavaScript dans un navigateur Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
JavaScript, fondation du Web 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Enrichissement des interfaces graphiques . . . . . . . . . . . . . . . . . . . . . . . . . 7
Échanges de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Structuration des applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
LivreGougeon Page X Mardi, 28. novembre 2006 4:23 16
JavaScript pour le Web 2.0
X
PARTIE I
Principes de base de JavaScript
CHAPITRE 2
Fondements de JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Exécution de scripts JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Interpréteurs JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Utilisation de JavaScript dans un navigateur . . . . . . . . . . . . . . . . . . . . . . . 15
Principes de base de JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Variables et typage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Opérateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Structures de contrôle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Méthodes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Manipulation des chaînes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Manipulation des nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Manipulation des dates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Structuration des applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Closures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Gestion des exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
CHAPITRE 3
JavaScript et la programmation orientée objet . . . . . . . . . . . . . . . 49
Rappel des principes de la programmation objet . . . . . . . . . . . . . . . . . 49
Classes et objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
L’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Agrégation et composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
LivreGougeon Page XI Mardi, 28. novembre 2006 4:23 16
Table des matières
XI
Classes JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Classes de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Classes pré-instanciées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Classes de l’environnement d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Mise en œuvre de classes personnalisées . . . . . . . . . . . . . . . . . . . . . . . . 64
Mise en œuvre de classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
L’héritage de classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Pour aller plus loin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
CHAPITRE 4
Programmation DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Spécifications du DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Support par les navigateurs Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Structure du DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
La classe Node . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Types des nœuds. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Manipulation des éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Accès direct aux éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Accès aux éléments à partir d’un nœud . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Manipulation des nœuds. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Utilisation des fragments d’arbre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Manipulation des attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Parcours de l’arbre DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
L’attribut innerHTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Utilisation du DOM niveau 0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Modification de l’arbre DOM au chargement . . . . . . . . . . . . . . . . . . . . 100
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
CHAPITRE 5
Mise en œuvre d’Ajax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Ajax et la classe XMLHttpRequest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
La classe XMLHttpRequest. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Gestion des échanges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
LivreGougeon Page XII Mardi, 28. novembre 2006 4:23 16
JavaScript pour le Web 2.0
XII
Échanges de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Données échangées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Structure des données échangées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Contournement des restrictions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Proxy au niveau du serveur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
iframe cachée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Utilisation dynamique de la balise script . . . . . . . . . . . . . . . . . . . . . . . . . . 120
En résumé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
PARTIE II
Fondations des bibliothèques JavaScript
CHAPITRE 6
La bibliothèque prototype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Support des éléments de base de JavaScript . . . . . . . . . . . . . . . . . . . . . 126
Support des classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Essai de fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Support des fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Déclencheur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Support des classes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Gestion des collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Support du DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
Support d’Ajax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Exécution de requêtes Ajax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Mise à jour d’éléments HTML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Raccourcis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146