Développez en Ajax
325 pages
Français
Obtenez un accès à la bibliothèque pour le consulter en ligne
En savoir plus

Développez en Ajax

-

Obtenez un accès à la bibliothèque pour le consulter en ligne
En savoir plus
325 pages
Français

Description

Des applications Web plus réactives et plus riches

Popularisé par des sites innovants tels que les webmails de Google et Yahoo, Google Maps, Flickr, Writely ou NetVibes, Ajax est un ensemble de technologies permettant de construire des applications Web de nouvelle génération, plus réactives et aux interfaces utilisateur plus riches, comparables en fonctionnalité aux applications natives Windows ou Mac OS.


Maîtriser les technologies sous-jacentes et les frameworks Ajax


Après avoir présenté des exemples typiques d'utilisation d'Ajax, cet ouvrage étudie en profondeur les techniques sous-jacentes (CSS et DOM, JavaScript objet, XMLHttpRequest, JSON, XML et XSLT) en les illustrant d'exemples d'applications variées et de complexité croissante.


Il présente également plusieurs des frameworks qui facilitent le développement d'applications Ajax, notamment prototype, dojo et script.aculo.us.


Acquérir par l'exemple les meilleures pratiques de développement Ajax


L'ouvrage donne des réponses précises aux questions délicates soulevées par Ajax, notamment la gestion des appels asynchrones (parallélisme et mise en cache), le choix des formats d'échange et les actions Page précédente ou Ajouter aux favoris.


L'auteur souligne l'importance du développement par composants en l'illustrant de quinze exemples facilement réutilisables. Il insiste tout particulièrement sur les bonnes pratiques de conception et montre à travers une étude de cas détaillée, un site de vente en ligne "ajaxifié", comment intégrer Ajax dans l'architecture MVC.


Sur le site www.editions-eyrolles.com


Téléchargez le code source des exemples du livre.



  • Remerciements

  • Avant-propos

  • Introduction à Ajax

  • Le HTML dynamique

  • Les composants JavaScript

  • Communication avec le serveur via XMLHttpRequest

  • Echange de données en XML ou JSON

  • Les "frameworks" Ajax

  • Les applications Ajax et Web 2.0

  • Annexe

  • Index

Sujets

Informations

Publié par
Date de parution 07 juillet 2011
Nombre de lectures 238
EAN13 9782212850680
Langue Français
Poids de l'ouvrage 4 Mo

Informations légales : prix de location à la page 0,0195€. Cette information est donnée uniquement à titre indicatif conformément à la législation en vigueur.

Exrait

Développez Ajax en Avec quinze exemples de composants réutilisables et une étude de cas détaillée
M i c h e l P l a s s e
R
e
m
e
rc
i
e
m
e
n
t
s
Mes remerciements vont aux personnes suivantes : Tout d’abord Olivier Salvatori, qui s’est chargé de la relecture de cet ouvrage et de l’important travail d’indexation. Sa relecture constructive et précise, sa réactivité et la qualité de son écoute ont été motivantes et instructives. Eric Pruvost, qui m’a suggéré d’écrire un livre sur Ajax. Nos discussions fréquentes et notre étroite collaboration depuis des années ont alimenté ma réflexion, notamment concernant les architectures Web et les bonnes pratiques de développement. Paul Athanassiadis, qui a suivi de près les investigations sur les différentes questions soulevées par Ajax, tant techniques que conceptuelles ou fonctionnelles, et a examiné les exemples et le code d’une grande partie de l’ouvrage. Benoît Gandon, qui a également examiné les exemples et le code d’une partie de l’ouvrage. Enfin, Emmanuelle Gautier et Joël Rigoult, qui m’ont mis en relation avec les éditions Eyrolles.
Avan
t
-
p
ro
p
o
s
Popularisé par des sites innovants tels que Google Suggest, Google Maps, les webmails de Google et Yahoo, writely, iRows ou netvibes, Ajax (Asynchronous JavaScript And XML) est un ensemble de technologies permettant de construire des applications Web de nouvelle génération, comparables en fonctionnalités aux applications natives Windows ou Mac OS.
Ajax associe le HTML dynamique, qui permet de modifier le contenu ou l’apparence de la page localement (sans redemander une nouvelle page au serveur), avec des appels asynchrones au serveur, qui récupèrent juste les fragments à mettre à jour. Ces technolo-gies existant depuis plusieurs années, Ajax est disponible aujourd’hui dans les naviga-teurs installés, tels Internet Explorer 6, Firefox 1.x,Safari 1.3, Opera 8.5, etc.
Ajax rend les applications Web plus réactives et leurs interfaces utilisateur plus riches. La réactivité tient à trois facteurs : • Fluidité : les échanges avec le serveur sont à la fois plus fréquents et d’un volume plus réduit, ce qui « lisse » la mise à jour dans le temps. De plus, ces mises à jour étant asynchrones, elles peuvent se dérouler en parallèle et ne bloquent pas l’utilisateur. • Rapidité : les échanges étant d’un volume plus réduit, le transfert est plus rapide, de même que le traitement local pour mettre à jour l’affichage. • Sensibilité : les application peuvent réagir à plus d’événements, notamment à ceux liés à la saisie clavier. La richesse d’interface tient aussi à trois facteurs : • Richesse des composants graphiques : en plus des formulaires et des liens, qui sont, en HTML, les principaux éléments réactifs, il est possible de disposer d’onglets, de boîtes flottantes, d’arborescences, de menus, d’info-bulles, de calendriers, etc. • Support du glisser-déposer et, dans une certaine mesure, de mécanismes de défaire/refaire. • Support de l’édition WYSIWYG. Les applications Ajax combinent ainsi la puissance et la qualité de l’interface utilisateur du client lourd avec l’absence de déploiement du client léger, constituant par là ce qu’on appelle aujourd’hui le client riche.
I
V
Développez en Ajax
Objectifs de l’ouvrage Cet ouvrage vise à guider le lecteur dans la réalisation d’applications Ajax. Il couvre trois grands axes : les technologies constitutives d’Ajax, les questions fonctionnelles et techni-ques soulevées, avec les réponses qu’il est possible d’y apporter, et enfin les méthodes et outils qui facilitent et rendent plus sûr le développement. Les technologies comportent : • Le HTML dynamique, c’est-à-dire DOM (Document Object Model), ou modèle objet du document, et les CSS (Cascading Style Sheets), ou feuilles de style en cascade, combinés avec JavaScript. XMLHttpRequest, l’objet JavaScript permettant d’effectuer des requêtes HTTP asyn-chrones vers le serveur. • JSON (JavaScript Object Notation), ou notation objet en JavaScript, ainsi que XML et les technologies associées, notamment XSLT et XPath.
Les questions soulevées concernent la gestion des appels asynchrones, la conception et l’utilisation de composants graphiques (comme la suggestion de saisie) ou fonctionnels (comme un panier dans une application de vente en ligne), la complexité du code JavaScript induite par la richesse des fonctionnalités du client et l’intégration d’Ajax dans les applications Web existantes.
Les solutions à ces problèmes reposent en grande partie sur des méthodes et des frameworks : pour faire face à la complexité du code, celui-ci doit être conçu de façon modulaire, en faisant appel à la programmation objet de JavaScript, à des bibliothèques de composants JavaScript et à une architecture MVC (modèle, vue, contrôleur).
Cette dernière, qui a démontré sa valeur côté serveur ainsi que dans les applications à client lourd, se révèle désormais utile aussi côté client en Web. Elle se prolonge par la séparation nette entre le code HTML, concentré sur la structure et le contenu, le code JavaScript en charge du comportement, et les CSS, qui gouvernent l’apparence.
Les méthodes valant avant tout par l’exemple (« faites ce que je fais » étant en cette matière plus efficace que « faites ce que je dis »), elles sont constamment mises en prati-que dans cet ouvrage.
L’objectif de celui-ci est en effet double : installer chez le lecteur des bases solides et le rendre opérationnel rapidement à travers des réalisations d’ampleur progressive, le dernier chapitre incluant une étude de cas illustrant comment concevoir et réaliser une application « ajaxifiée ».
Organisation de l’ouvrage Dans chaque chapitre, l’ouvrage part du besoin, l’objectif à atteindre, et guide progressi-vement le lecteur vers cet objectif. La succession des chapitres vise également à faciliter cette progression. L’explication des techniques est illustrée par des exemples, que le
Avant-propos
lecteur pourra, dans certains cas, réutiliser dans ses propres projets. L’auteur insiste sur les fondements de chaque technologie et les pratiques conseillées et indique les points délicats, facteurs de bogues fréquents.
Le chapitre 1 examine ce qu’apporte Ajax et liste notamment les cas typiques où il offre un réel avantage. Une grande partie des exemples présentés ici sont développés dans les chapitres suivants. Les fonctions et le code d’un exemple simple sont examinés en détail afin de montrer comment s’imbriquent les différentes composantes du code.
Il n’est pas possible de faire de l’Ajax sans faire du HTML dynamique, qui consiste à modifier le contenu, la structure ou l’apparence d’une page Web sans aucun appel au serveur. La réciproque est fausse. Aussi est-il plus facile de commencer par le HTML dynamique, auquel le chapitre 2 est consacré. Ce chapitre fait un point sur les feuilles de style CSS et sur l’API DOM, qui permet de manipuler la structure, le contenu et l’appa-rence de la page Web et de gérer les événements liés aux actions de l’utilisateur.
Les applications Ajax faisant massivement appel à des composants, le chapitre 3 se penche sur les aspects objet et avancés de JavaScript, qui sont très particuliers et peuvent être déroutants tant pour les développeurs Java ou C# que pour ceux qui n’ont pas une grande habitude de la programmation objet. Le chapitre est illustré par la création de composants graphiques et d’une suggestion de saisie en local (comme sur le site de la RATP). Ce chapitre est fondamental, car tous les exemples des chapitres suivants cons-truisent (ou font appel à) des composants JavaScript.
Le chapitre 4 est dédié à la communication avec le serveurviades requêtesXMLHttpRequest. Après un point sur le protocole HTTP, il examine les questions soulevées par les appels Ajax : gestion du cache, méthodesGETetPOST, requêtes parallèles, cookies, sécurité. Les exemples incluent une suggestion de saisie par appels au serveur et la mise à jour dyna-mique d’une liste déroulante, réalisées sous forme de composants.
Le chapitre 5 traite de l’échange de données XML ou JSON entre le client et le serveur. Il examine et compare les différents formats d’échanges (texte, HTML, XML et JSON). Les spécificités de XML et de son DOM par rapport au HTML y sont indiquées. Il traite aussi de XSLT (transformations XML) et XPath. Les technologies sont illustrées par un lecteur RSS, d’abord dans une version simple faisant appel à DOM, puis dans une version plus élaborée faisant appel à XSLT.
Le chapitre 6 aborde les « frameworks » Ajax. Il commence par différencier bibliothè-ques et frameworks, puis examine les critères de choix à prendre en compte et compare les produits disponibles. Il étudie en particulier dojo et prototype.js, les deux bibliothè-ques les plus anciennes et, semble-t-il, les plus utilisées actuellement. Le chapitre est illustré de nombreux exemples d’utilisation, notamment une mise en œuvre du glisser-déposer et un éditeur WYSIWYG.
Le chapitre 7 et dernier est consacré aux applications Ajax et Web 2.0. C’est le plus important du point de vue de la conception et de l’architecture. Il examine les questions soulevées par Ajax, en particulier l’absence de support des actions Page précédente et Ajouter aux favoris. Il détaille l’impact d’Ajax sur les architectures Web, en particulier le
V
V
I
Développez en Ajax
modèle MVC. Une étude de cas conclut le chapitre et l’ouvrage en montrant qu’au MVC côté serveur s’adjoint dans les cas complexes un MVC côté client.
Chaque chapitre s’appuie sur les connaissances acquises au cours des chapitres précé-dents et les enrichit. À l’issue de ce parcours, le lecteur aura un bagage solide et dispo-sera de composants directement utilisables, lui permettant d’aborder ses projets Ajax en étant opérationnel.
Table des matières
Remerciements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Avant-propos. . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . .  . Objectifs de l’ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Organisation de l’ouvrage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
CHAPITRE 1 Introduction à Ajax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Qu’est-ce qu’Ajax ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mise à jour d’une partie de la page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Communication asynchrone avec le serveur . . . . . . . . . . . . . . . . . . . . . . . . Techniques mises en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exemples typiques où Ajax est utile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Validation et mise à jour d’une partie de la page . . . . . . . . . . . . . . . . . . . . Aide à la saisie, notamment suggestion de saisie . . . . . . . . . . . . . . . . . . . . Lecture de flux RSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tri, filtrage et réorganisation de données côté client . . . . . . . . . . . . . . . . . . Édition WYSIWYG de documents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Diaporamas et autres applications documentaires . . . . . . . . . . . . . . . . . . . . Débranchement dans un scénario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Visualisation graphique avec SVG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rafraîchissement d’une branche d’une arborescence . . . . . . . . . . . . . . . . . Chargement progressif de données volumineuses . . . . . . . . . . . . . . . . . . . . Exemple Ajax simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le code côté serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le code côté client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La requêteXMLHttpRequest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
I
III IV IV
1 1 2 3 4 5 5 7 8 9 10 11 12 13 13 14 14 17 18 22
VIII
Développez en Ajax
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
CHAPITRE 2 Le HTML dynamique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Balises, arbre et boîtes HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les CSS (Cascading Style Sheet) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les règles CSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Boîtes et dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Afficher/masquer un élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les calques et le positionnement des boîtes . . . . . . . . . . . . . . . . . . . . . . . . DOM (Document Object Model) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les interfaces DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Peupler une liste de suggestions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Positionnement de la liste de suggestions . . . . . . . . . . . . . . . . . . . . . . . . . . Récupération de nœuds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . DOM Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Événements reconnus par les navigateurs . . . . . . . . . . . . . . . . . . . . . . . . . . Programmation événementielle mais traitement séquentiel . . . . . . . . . . . . Association d’une réaction à un événement . . . . . . . . . . . . . . . . . . . . . . . . Ordre des événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Propagation des événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les événements clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les événements liés à la souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
CHAPITRE 3 Les composants JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Outils d’aide au développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fonctionnalités objet de JavaScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Différences avec Java, Eiffel et C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les objets JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La notation JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les fonctions anonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le mot-cléthis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
25 26 29 30 32 34 35 40 41 43 44 46 48 49 50 51 53 56 60 63 65 65
67 68 69 70 71 73 74 78 79
Table des matières
Les prototypes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le mécanisme de fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . thiset les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Création de composants JavaScript réutilisables . . . . . . . . . . . . . . . . . . La boîte d’information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les onglets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Suggestion de saisie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
CHAPITRE 4 Communication avec le serveurvia XMLHttpRequest. . . . . . L’objetXMLHttpRequest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rappels sur HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Instanciation d’une requêteXMLHttpRequest. . . . . . . . . . . . . . . . . . . . . . . Requêtes synchrones ou asynchrones ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . Cycle de vie de la requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XMLHttpRequestet la sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Gestion du cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les problèmes d’encodage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les requêtes parallèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Applications exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Suggestion de saisie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mise à jour d’une partie de la page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
CHAPITRE 5 Échange de données en XML ou JSON . . . . . . . . . . . . . . . . . . . . . . XML (eXtensible Markup Language). . . . . . . . . . . . . . . . . . . . . . . . . . . Documents bien formés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Choix de la structure des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le DOM XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La mise à jour partielle avec XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . JSON (JavaScript Object Notation) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Communication JSON entre JavaScript et PHP . . . . . . . . . . . . . . . . . . . . .
81 91 92 94 94 94 105 112 127
129 130 130 135 137 138 143 143 148 152 157 157 157 166 175
177 178 178 182 186 187 189 191
I
X
X
Développez en Ajax
La mise à jour partielle avec JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Comparaison des formats d’échange . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exemple d’application avec les flux RSS . . . . . . . . . . . . . . . . . . . . . . . . . Les formats RSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le serveur comme mandataire HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le composant lecteur de RSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Affichage du flux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XSLT (eXtensible Stylesheet Language Transformations) . . . . . . . . . . XPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fonctionnement de XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La syntaxe XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exemple de transformation XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exemple d’application de lecteur RSS avec XSLT . . . . . . . . . . . . . . . . . Le composantXSLView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La transformation XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La page HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
CHAPITRE 6 Les « frameworks » Ajax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Boîtes à outils, bibliothèques et frameworks . . . . . . . . . . . . . . . . . . . . . . Les bibliothèques JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . prototype.js. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fonctions et objets utilitaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Encapsulation et extensions de DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les appelsXMLHttpRequest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . script.aculo.us . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . rico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . dojo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fonctions et objets utilitaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Encapsulation et extensions de DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les appels Ajax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Les widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
193 195 197 198 200 201 204 207 208 209 211 212 215 216 219 221 224 226 230
233 233 235 236 237 240 242 245 247 249 252 255 256 261
  • Accueil Accueil
  • Univers Univers
  • Ebooks Ebooks
  • Livres audio Livres audio
  • Presse Presse
  • BD BD
  • Documents Documents