<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>Artisan Numérique</title>
  <link rel="alternate" type="text/html" href="http://artisan.karma-lab.net/node/1275"/>
  <link rel="self" type="application/atom+xml" href="http://artisan.karma-lab.net/node/1275/atom/feed"/>
  <id>http://artisan.karma-lab.net/node/1275/atom/feed</id>
  <updated>2008-07-30T15:45:27+02:00</updated>
  <entry>
    <title>JQuery, petite introduction</title>
    <link rel="alternate" type="text/html" href="http://artisan.karma-lab.net/node/1275" />
    <id>http://artisan.karma-lab.net/node/1275</id>
    <published>2007-11-25T21:55:36+01:00</published>
    <updated>2008-07-30T15:45:27+02:00</updated>
    <author>
      <name>Ulhume</name>
    </author>
    <category term="jQuery" />
    <category term="OK" />
    <category term="Planet Libre" />
    <category term="Tutoriel" />
    <summary type="html"><![CDATA[<p>
  JQuery, pour faire simple, est une boite à outils javascript ultra-compacte permettant de faire abstraction du type de navigateur pour manipuler la structure dynamique d'une page WEB, le 
  <a target='_blank' href='http://fr.wikipedia.org/wiki/DOM'>
  DOM
  </a>, et ceci avec une aisance déconcertante. Il existe plusieurs autres plates-formes du même genre (Scriptaculous, Prototype, etc.) mais JQuery a l'avantage de faire aujourd'hui parti du cœur de Drupal. Il serait donc dommage de ne pas en connaître les possibilités. 
</p>
    ]]></summary>
    <content type="html"><![CDATA[<p>
  JQuery, pour faire simple, est une boite à outils javascript ultra-compacte permettant de faire abstraction du type de navigateur pour manipuler la structure dynamique d'une page WEB, le 
  <a target='_blank' href='http://fr.wikipedia.org/wiki/DOM'>
  DOM
  </a>, et ceci avec une aisance déconcertante. Il existe plusieurs autres plates-formes du même genre (Scriptaculous, Prototype, etc.) mais JQuery a l'avantage de faire aujourd'hui parti du cœur de Drupal. Il serait donc dommage de ne pas en connaître les possibilités. 
</p>
<!--break-->

	<a name='chapter_1'></a>
  <h2>Installation</h2>
	
<p>
  JQuery se télécharge sur le site <a class='external' target='_blank' href='http://docs.jquery.com/Downloading_jQuery' >http://docs.jquery.com</a> et il existe 2 parfums différents pour chaque version : <kbd>Packed</kbd> et <kbd>Uncompressed</kbd>. Téléchargez plutôt la première qui prend moins de place. Renommez le fichier téléchargé en <kbd>jquery.js</kbd> et posez-le dans un dossier accessible par apache. Dans la suite de ce tutorial, tous les exemples seront considérés comme étant des fichiers php stockés au même endroit que ce jquery.js et lisible par apache.
</p>
<p>
  Une fois que vous avez posez <kbd>jquery.js</kbd>, commençons par écrire un exemple simple pour vérifier que tout fonctionne. 
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="sy0">&lt;</span>html<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;</span>head<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>script type<span class="sy0">=</span><span class="st0">&quot;text/javascript&quot;</span> src<span class="sy0">=</span><span class="st0">&quot;jquery.js&quot;</span><span class="sy0">&gt;&lt;/</span>script<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>style<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; &nbsp; body <span class="br0">&#123;</span> <br />
&nbsp; &nbsp; &nbsp; &nbsp; background<span class="sy0">-</span>color<span class="sy0">:</span>black<span class="sy0">;</span> <br />
&nbsp; &nbsp; &nbsp; &nbsp; color<span class="sy0">:</span>white<span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
&nbsp; &nbsp; &nbsp; A <span class="br0">&#123;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; color<span class="sy0">:</span>white<span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;/</span>style<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;/</span>head<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;</span>body<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>a href<span class="sy0">=</span><span class="st0">&quot;#&quot;</span> onclick<span class="sy0">=</span><span class="st0">'alert(&quot;Hello World. La version de votre moteur HTML est &quot;+jQuery.browser.version); return false'</span><span class="sy0">&gt;</span>Cliquez ici <span class="sy0">!&lt;/</span>a<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;/</span>body<span class="sy0">&gt;</span><br />
<span class="sy0">&lt;/</span>html<span class="sy0">&gt;</span>
  </div>
  
  </div>
</p>
<p>
  Si tout est bien installé, vous pourrez afficher cette page via une url du genre <kbd>http://mon.serveur.com/jquery/exemple.php</kbd>. Et en cliquant sur le lien proposé, devrait s'afficher un message de bienvenue suivi de la version du moteur de rendu de votre navigateur. Si tel est le cas, nous pouvons poursuivre. 
</p>
  

	<a name='chapter_2'></a>
  <h2>Mise en œuvre</h2>
	
<p>
  Pour mieux comprendre ce que permet jQuery, prenons directement un exemple, et imaginons que nous voulions désactiver pour tous les liens d'une page, le rectangle en pointillés grisâtres et disgracieux qui apparaît lorsque l'utilisateur vient de clique dessus : le "focus". Ce rectangle n'est pas gênant sur un fond blanc, mais devient très laid sur un fond sombre. Vous pouvez vous en rendre compte sur l'exemple précédant. 
</p>
<p>
  En programmation "standard", la solution consistait à modifier chaque balise <kbd>&lt;A href=...&gt;</kbd> en ajoutant un attribut <kbd>onfocus="this.blur();"</kbd>. Le rôle de cette modification est de retirer le focus (fonction <kbd>blur()</kbd>) à tout élément DOM de type "hyperlien", et ce au moment même où celui-ci le gagne (évènement <kbd>onfocus</kbd>). Ce type de "hack" est le genre de magouille peu élégante (car rendant le code difficile à lire) et fastidieuse au possible que JQuery traite avec simplicité. Pour s'en rendre compte, après le bloc <kbd>style</kbd> de notre exemple, rajoutez le script suivant :
  
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="sy0">&lt;</span>script<span class="sy0">&gt;</span><br />
&nbsp; <span class="kw2">function</span> initializePage<span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span><br />
&nbsp; &nbsp; $<span class="br0">&#40;</span><span class="st0">&quot;A&quot;</span><span class="br0">&#41;</span>.<span class="kw3">focus</span><span class="br0">&#40;</span><span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span> <span class="kw1">this</span>.<span class="kw3">blur</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span> <span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; <span class="br0">&#125;</span><br />
&nbsp; $<span class="br0">&#40;</span>initializePage<span class="br0">&#41;</span><span class="sy0">;</span><br />
<span class="sy0">&lt;/</span>script<span class="sy0">&gt;</span>
  </div>
  
  </div>
</p>
<p>
  Au rechargement de la page, cliquez sur le lien, validez le dialogue, et vous constaterez que le focus a disparu. 
</p>
<p>
  Pour comprendre ce premeir exemple, il faut commenser par se diriger vers la dernière ligne. Elle indique à jQuery d'exécuter la fonction <kbd>initializePage</kbd> lorsque le document sera complètement chargée par le navigateur. Généralement tous les scripts manipulant le DOM utilisent cette technique pour être bien sur que tout est en place avant de jouer avec la structure document. 
</p>

<p>
  Donc une fois le document correctement chargé, est lancé la fonction <kbd>initializePage</kbd>. La seule ligne de cette fonction est du pur jQuery. La fonction <kbd>$("A").</kbd> permet de rechercher tous les éléments du DOM ayant pour type <kbd>balise A</kbd>. Son résultat est un <strong>objet jQuery</strong> qui <u>contient</u> la collection d'éléments DOM trouvés. Nous demandons ensuite à cet objet d'ajouter, à chacun de ses éléments, l'attribut <kbd>onfocus</kbd>, qui va bien. Cela semble simple, non ? En tout cas l'important ici est de comprendre l'esprit... les détails vont venir. 
</p>

<div class='inline-box attention'>
  jQuery n'est pas le seul à utiliser la notation <kbd>$(...)</kbd>. Scriptaculous par exemple le fait aussi, et si l'on est amené à utiliser ensemble les deux librairies, il est possible d'éviter les conflits en revenant à la notation longue, c'est à dire en replaçant <kbd>$(...)</kbd> par <kbd>jQuery(...)</kbd>. 
</div>


	<a name='chapter_3'></a>
  <h2>Rechercher dans le DOM</h2>
	
<p>
  le DOM est, de manière simplifiée, une arborescence d'objets dont chaque noeud correspond à un balise HTML. Le navigateur fabrique le DOM au fur et à mesure de l'arrivée des données du site web. Et c'est ce DOM qui est ensuite représenté visuellement pour former ce que voit l'utilisateur.
</p>
<p>
  La première force de jQuery est donc de proposer un moyen simple et directe de sélectionner des éléments du DOM pour y appliquer des modifications. Et quoi de plus simple que d'utiliser comme syntaxe de recherche, quelque chose de vraiment conçu pour cela, la notation des descripteurs 
  <a target='_blank' href='http://fr.wikipedia.org/wiki/CSS'>
  CSS
  </a>. 
</p>
<p>
  Dans l'exemple précédent nous avons sélectionné toutes les balises <kbd>A</kbd> et y avons attachées un événement <kbd>focus</kbd>. Même si c'est une recherche très basique,  en réalité, ce simple "A" est le même type de descripteur CSS que dans une notation que tout le monde connait bien :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  A <span class="br0">&#123;</span> <br />
&nbsp; <span class="kw1">color</span> <span class="sy0">:</span> <span class="kw1">blue</span><span class="sy0">;</span><br />
<span class="br0">&#125;</span>
  </div>
  
  </div>
</p>
<p>
  Ainsi, une chaîne de recherche pour sélectionner l'ensemble des éléments <kbd>A</kbd> de classe <kbd>ma_classe</kbd> cette fois, peut donc s'écrire :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="co1">// Sélection des éléments A de classe ma_classe</span><br />
$<span class="br0">&#40;</span><span class="st0">&quot;A.ma_classe&quot;</span><span class="br0">&#41;</span>. ...
  </div>
  
  </div>
</p>
<p>
  De la même manière, pour sélectionner le div d'id <kbd>mon_id</kbd> :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="co1">// Sélection des éléments A d'id mon_id</span><br />
$<span class="br0">&#40;</span><span class="st0">&quot;DIV#mon_id&quot;</span><span class="br0">&#41;</span>. ...
  </div>
  
  </div>
</p>
<p>
  Et comme quasiment tous les descripteurs CSS sont supportés, pour sélectionner l'ensemble des balises <kbd>LI</kbd> de classe <kbd>item</kbd> contenues directement dans une balise <kbd>UL</kbd> de classe <kbd>menu</kbd>, cela donne très logiquement :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="co1">// Sélection des éléments LI.item contenus dans des UL.menu</span><br />
$<span class="br0">&#40;</span><span class="st0">&quot;UL.menu&gt;IL.item&quot;</span><span class="br0">&#41;</span>. ...
  </div>
  
  </div>  
</p>


	<a name='chapter_4'></a>
  <h2>L'objet jQuery</h2>
	
<p>
  La bonne question est maintenant de savoir ce que renvoie exactement la fonction <kbd>$("...")</kbd>. Et bien la réponse est.. la librairie jQuery elle-même. En effet, toutes les fonctions de la librairie sont en réalité les méthodes d'un <strong>objet jQuery</strong>. Et cet objet contient une liste d'éléments du DOM sur laquelle il va travailler. Ainsi lorsque l'on regarde le code suivant :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  $<span class="br0">&#40;</span><span class="st0">&quot;.ma_classe&quot;</span><span class="br0">&#41;</span>.<span class="me1">css</span><span class="br0">&#40;</span><span class="st0">&quot;background&quot;</span><span class="sy0">,</span> <span class="st0">&quot;black&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
  </div>
  
  </div>
</p>
<p>
  L'appel <kbd>$(".ma_classe")</kbd> renvois en réalité un objet jQuery contenant la liste de tous les éléments DOM de la classe <kbd>ma_classe</kbd>. L'appel <kbd>css(...)</kbd> modifie donc la couleur de fond de tous les éléments connus de l'objet jQuery. 
<p>
<p>
  De la même manière un appel de la forme <kbd>$(document.body)</kbd> va renvoyer un nouvel objet jQuery contenant cette fois une seule référence, celle de l'élément DOM <kbd>body</kbd>. Il est donc non seulement possible de créer un objet jQuery à partir d'un sélecteur CSS (liste d'élements DOM) mais aussi d'injecter n'importe quel élement DOM dans un objet jQuery. 
</p>
<p>
  A l'inverse, il peut être interessant de récupérer les éléménts DOM sélectionnées dans l'objet jQuery, et cela se fait de manière très simple, comme si l'objet en question était un tableau :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="co1">// Création d'un objet jQuery contenant une séléction de lien de class &quot;ma_classe&quot;</span><br />
<span class="kw2">var</span> mesLiens <span class="sy0">=</span> $<span class="br0">&#40;</span><span class="st0">&quot;A.ma_classe&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
<br />
<span class="co1">// obtention du nombre d'élements sélectionnés</span><br />
<span class="kw3">alert</span> <span class="br0">&#40;</span><span class="st0">&quot;Nous avons &quot;</span><span class="sy0">+</span>mesLiens.<span class="me1">length</span><span class="sy0">+</span><span class="st0">&quot; éléments sélectionnés&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
<br />
<span class="co1">// obtention du premier élément DOM de la sélection</span><br />
<span class="kw3">alert</span> <span class="br0">&#40;</span><span class="st0">&quot;Le premier élément DOM est &quot;</span><span class="sy0">+</span>mesLiens<span class="br0">&#91;</span><span class="nu0">0</span><span class="br0">&#93;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
<br />
<span class="co1">// ajout d'un attribut CSS au premier élément DOM en repassant par jQuery</span><br />
$<span class="br0">&#40;</span>mesLiens<span class="br0">&#91;</span><span class="nu0">0</span><span class="br0">&#93;</span><span class="br0">&#41;</span>.<span class="me1">css</span><span class="br0">&#40;</span><span class="st0">&quot;color&quot;</span><span class="sy0">,</span> <span class="st0">&quot;red&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
  </div>
  
  </div>
</p>
<p>
  Plus "fort" encore, nombre des fonctions de l'objet jQuery renvoient l'objet jQuery qui les a appelé... Du coup nous pouvons partir du code suivant :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="co1">// Objet jQuery représentant les éléments DOM de classe ma_classe</span><br />
<span class="kw2">var</span> objet_jquery<span class="sy0">=</span>$<span class="br0">&#40;</span><span class="st0">&quot;.ma_classe&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
<br />
<span class="co1">// Changement du fond et de la couleur de tous les éléments DOM sélectionnés dans l'objet jQuery</span><br />
objet_jquery.<span class="me1">css</span><span class="br0">&#40;</span><span class="st0">&quot;background&quot;</span><span class="sy0">,</span> <span class="st0">&quot;red&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
objet_jquery.<span class="me1">css</span><span class="br0">&#40;</span><span class="st0">&quot;color&quot;</span><span class="sy0">,</span> <span class="st0">&quot;green&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
  </div>
  
  </div>
</p>
<p>
  Pour arriver à une version beaucoup plus compacte :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  objet_jquery<span class="sy0">=</span>$<span class="br0">&#40;</span><span class="st0">&quot;.ma_classe&quot;</span><span class="br0">&#41;</span><br />
&nbsp; .<span class="me1">css</span><span class="br0">&#40;</span><span class="st0">&quot;background&quot;</span><span class="sy0">,</span> <span class="st0">&quot;red&quot;</span><span class="br0">&#41;</span><br />
&nbsp; .<span class="me1">css</span><span class="br0">&#40;</span><span class="st0">&quot;color&quot;</span><span class="sy0">,</span> <span class="st0">&quot;green&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span>
  </div>
  
  </div>
</p>


	<a name='chapter_5'></a>
  <h2>Les évènements</h2>
	
<p>
  Un autre grand domaine où jQuery nous simplifie beaucoup la tâche, est la gestion des évènements. Il est en effet possible de connecter tous les types d'évènements connus du DOM à une fonction javaScript, et ceci de manière dynamique, c'est à dire à l'exécution du script sur le client. 
</p>
<p>
  Pour gérer les évènements, jQuery dispose de deux fonctions <kbd>bind</kbd> et <kbd>unbind</kbd>. L'une permet de lier, sur un élément donné du DOM, un type d'évènement (click, mouseover, keydown, etc..) à une fonction de votre choix. La seconde permet quant à elle de rompre le lien qui existait entre un type d'évènement et une fonction. Cela nous donne un code ressemblant à cela :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  $<span class="br0">&#40;</span><span class="st0">&quot;DIV#mon_id&quot;</span><span class="br0">&#41;</span>.<span class="me1">bind</span><span class="br0">&#40;</span><span class="st0">'click'</span><span class="sy0">,</span> maFonction<span class="br0">&#41;</span><span class="sy0">;</span><br />
...<br />
$<span class="br0">&#40;</span><span class="st0">&quot;DIV#mon_id&quot;</span><span class="br0">&#41;</span>.<span class="me1">unbind</span><span class="br0">&#40;</span><span class="st0">'click'</span><span class="sy0">,</span> maFonction<span class="br0">&#41;</span><span class="sy0">;</span>
  </div>
  
  </div>
</p>
<p>
  Mais pour simplifier la syntaxe du lien, jQuery propose une batterie de fonction toute faite dédiées à un type d'évènement donnée :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  $<span class="br0">&#40;</span><span class="st0">&quot;DIV#mon_id&quot;</span><span class="br0">&#41;</span>.<span class="me1">click</span><span class="br0">&#40;</span>maFonction<span class="br0">&#41;</span><span class="sy0">;</span><br />
$<span class="br0">&#40;</span><span class="st0">&quot;DIV#mon_id&quot;</span><span class="br0">&#41;</span>.<span class="me1">mouseover</span><span class="br0">&#40;</span>maFonction<span class="br0">&#41;</span><span class="sy0">;</span><br />
$<span class="br0">&#40;</span><span class="st0">&quot;DIV#mon_id&quot;</span><span class="br0">&#41;</span>.<span class="me1">keydown</span><span class="br0">&#40;</span>maFonction<span class="br0">&#41;</span><span class="sy0">;</span><br />
etc..
  </div>
  
  </div>
</p>
<p>
  Comme vous le voyez la mise en oeuvre des évènements est on ne peut plus simple. Pour un exemple plus concret, imaginons une zone (div) qui affiche un message lorsque la souris passe au dessus. Cela nous donnerait :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="sy0">&lt;</span>html<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;</span>head<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>script type<span class="sy0">=</span><span class="st0">&quot;text/javascript&quot;</span> src<span class="sy0">=</span><span class="st0">&quot;jquery.js&quot;</span><span class="sy0">&gt;&lt;/</span>script<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>script<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; &nbsp; <span class="kw2">function</span> afficherMessage<span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;<span class="kw3">alert</span><span class="br0">&#40;</span><span class="st0">&quot;Vous me roulez dessus !!&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span> <br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
<br />
&nbsp; &nbsp; &nbsp; <span class="kw2">function</span> initializePage<span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; $<span class="br0">&#40;</span><span class="st0">&quot;#mon_div&quot;</span><span class="br0">&#41;</span>.<span class="me1">mouseover</span><span class="br0">&#40;</span>afficherMessage<span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
&nbsp; &nbsp; &nbsp; $<span class="br0">&#40;</span>initializePage<span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;/</span>script<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;/</span>head<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;</span>body<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>div id<span class="sy0">=</span><span class="st0">&quot;mon_div&quot;</span><span class="sy0">&gt;</span>Survolez<span class="sy0">-</span>moi <span class="sy0">!&lt;/</span>div<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;/</span>body<span class="sy0">&gt;</span><br />
<span class="sy0">&lt;/</span>html<span class="sy0">&gt;</span> &nbsp;
  </div>
  
  </div>
</p>

<p>
  Au premier regard, à la syntaxe près, tout ceci ressemble beaucoup à ce qu'il était déjà possible de faire avec l'attribut <kbd>onmouseover</kbd>. Il y a en revanche une grosse différence. Dans le mode "classique", on ne peut ajouter un type d'évènement donné qu'une seule et unique fois sur un élément. En jQuery, il est possible liée plusieurs fonctions différents à un élément donnée, et pour le même type d'évènement. La raison de ce comportement est que jQuery ajoute la fonction liée à une liste par type d'évènement. Ainsi lorsque l'évènement est déclenché, la liste est parcourue, et toutes les fonctions de la liste sont exécutée. 
</p>
<p>
  Cet aspect est important à assimiler car si par erreur vous liez plusieurs fois de suite une même fonction sur un même type d'évènement à un même objet, la fonction sera exécutée autant de fois de suite... En revanche, cet aspect est une réelle force car cela nous permet de séparer proprement les différents travaux à effectuer dans différentes fonctions, et ceci même si elle sont déclenchées sur le même type d'évènement. 
</p>

<div class='inline-box note'>
  Certains doutent de l'intérêt de câbler les évènements avec jQuery, du côté client, plutôt que directement sur la page. Le premier intérêt de l'approche dynamique est la lisibilité. En effet, avec cette technique, le code HTML n'est plus "pollué" par des attributs (onmouseover, onclick, etc...) qui n'ont rien à voir avec le contenu. Il s'agit du même type de séparation déjà effectué avec le formatage des pages HTML déplacé dans des feuilles de style. Ici, c'est le comportement qui est ainsi séparé du HTML et placé dans un script aux frontières clairement définies. Ce code devient dés lors facile à faire évoluer et à maintenir. 
  <br>
  Autre avantage de cet approche, construire un site à l'ancienne, fonctionnel et respectant l'accessibilité. Et le pimenter dynamiquement, au besoin, de fonctions plus "sexy" mais néanmoins optionnelles. 
</div>

<p>
  Voilà, c'est à peu prés tout ce qu'il y a à savoir sur les événements en jQuery, la liste complète des fonctions correspondant à cet aspect est disponible <a class='external' target='_blank' href='http://docs.jquery.com/Events' >ici</a>. 
</p>


	<a name='chapter_6'></a>
  <h2>Modification du DOM</h2>
	
<p>
  Une fois que nous savons rechercher des éléments, accrocher des événements, il devient intéressant de savoir modifier dynamiquement le DOM pour créer des affichages dynamiques. jQuery fournit dans ce sens une batterie de fonctions dédiées à cet usage qu'il serait difficile de couvrir dans ce tutorial. Nous allons donc limiter notre découverte à la modification dynamique du code HTML contenu dans un div. 

  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="sy0">&lt;</span>html<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;</span>head<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>script type<span class="sy0">=</span><span class="st0">&quot;text/javascript&quot;</span> src<span class="sy0">=</span><span class="st0">&quot;jquery.js&quot;</span><span class="sy0">&gt;&lt;/</span>script<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>script<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; &nbsp; <span class="kw2">function</span> initializePage<span class="br0">&#40;</span><span class="br0">&#41;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#123;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; $<span class="br0">&#40;</span><span class="st0">&quot;#mon_div&quot;</span><span class="br0">&#41;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; .<span class="me1">mouseover</span><span class="br0">&#40;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span> <br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; $<span class="br0">&#40;</span><span class="kw1">this</span><span class="br0">&#41;</span>.<span class="me1">html</span><span class="br0">&#40;</span><span class="st0">&quot;Je suis dedans&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span> <span class="br0">&#125;</span><span class="br0">&#41;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; .<span class="me1">mouseout</span><span class="br0">&#40;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span> <span class="br0">&#123;</span> <br />
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; $<span class="br0">&#40;</span><span class="kw1">this</span><span class="br0">&#41;</span>.<span class="me1">html</span><span class="br0">&#40;</span><span class="st0">&quot;Je suis dehors&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span> <span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
&nbsp; &nbsp; &nbsp; $<span class="br0">&#40;</span>initializePage<span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;/</span>script<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;/</span>head<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;</span>body<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>div id<span class="sy0">=</span><span class="st0">&quot;mon_div&quot;</span><span class="sy0">&gt;</span>Survolez<span class="sy0">-</span>moi <span class="sy0">!&lt;/</span>div<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;/</span>body<span class="sy0">&gt;</span><br />
<span class="sy0">&lt;/</span>html<span class="sy0">&gt;</span>
  </div>
  
  </div>  
</p>
<p>
  D'un point de vue utilisateur, une fois l'exemple chargé dans le navigateur, il suffit que l'utilisateur survole le texte affiché pour que son contenu change, et qu'il change encore lorsque l'utilisateur sort de la zone. 
</p>
<p>
  Je ne reviens pas sur l'ajout des deux événements à l'élément <kbd>#mon_div</kbd>. La seule chose nouvelle la fonction <kbd>html(...)</kbd>. Cette fonction permet de remplacer le contenu HTML de l'élément DOM par un autre contenu. Attention, il s'agit du <i>contenu</i> HTML, pas du code HTML de l'élément lui-même. En d'autre terme, cette fonction change ce qu'il y a à l'intérieur de la balise, mais pas la balise lui-même. 
</p>
<p>
  Une autre manière de modifier le DOM est de manipuler les attributs des éléments. Que ce soit les attributs standards ou les attributs de style CSS.
</p>

  <div class='code-block code-block-fragment'>
  <div class='container'>
  $<span class="br0">&#40;</span><span class="st0">&quot;A&quot;</span><span class="br0">&#41;</span>.<span class="me1">attr</span><span class="br0">&#40;</span><span class="st0">&quot;title&quot;</span><span class="sy0">,</span> <span class="st0">&quot;Nouveau titre pour tous les liens&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
<br />
<span class="co1">// Changement de la couleur de tous les liens</span><br />
$<span class="br0">&#40;</span><span class="st0">&quot;A&quot;</span><span class="br0">&#41;</span>.<span class="me1">css</span><span class="br0">&#40;</span><span class="st0">&quot;color&quot;</span><span class="sy0">,</span> #FF00FF<span class="br0">&#41;</span><span class="sy0">;</span>
  </div>
  
  </div>
<div class='inline-box note'>
  Un aspect souvent oublié du DOM est que l'on peut mettre sur une balise HTML des attributs "non-standards". Il est ainsi possible de charger, sans impacte visuel, une balise en informations nouvelles qui seront stockés dans les éléments du DOM correspondant. Par exemple, vous pouvez déclarer un balise lien comme suit :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  &lt;a id=&quot;mon_lien&quot; href=&quot;http://quelquepart.com/&quot; monMessage=&quot;Un message personnel&quot;&gt;Un lien&lt;/a&gt;
  </div>
  
  </div>
  Comme vous l'avez remarqué, <kbd>monMessage</kbd> est tout sauf un attribut de la balise <kbd>A</kbd>. Et pourtant, cet attribut personnalisé est parfaitement lisible dans le DOM, du côté client :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  $<span class="br0">&#40;</span><span class="st0">&quot;#mon_lien&quot;</span><span class="br0">&#41;</span>.<span class="me1">mouseover</span><span class="br0">&#40;</span><span class="kw2">function</span><span class="br0">&#40;</span><span class="br0">&#41;</span><span class="br0">&#123;</span><br />
<span class="kw3">alert</span> <span class="br0">&#40;</span>$<span class="br0">&#40;</span><span class="kw1">this</span><span class="br0">&#41;</span>.<span class="me1">attr</span><span class="br0">&#40;</span><span class="st0">&quot;monMessage&quot;</span><span class="br0">&#41;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
<span class="br0">&#125;</span><span class="br0">&#41;</span><span class="sy0">;</span>
  </div>
  
  </div>  
</div>


	<a name='chapter_7'></a>
  <h2>JQuery et AJAX</h2>
	
<p>
  Le dernier aspect de jQuery que nous allons aborder, est sa capacité à gérer les requêtes asynchrones, plus connues sous le nom de requêtes AJAX. AJAX, en deux mots, c'est la possibilité offerte en javascript de faire une requête sur un serveur distant et de récupérer dans le script appelant les données que le serveur à renvoyées. Et tout ceci sans qu'une action utilisateur ne soit nécessaire, d'où la dénomination<em> d'asynchrone</em>. 
</p>
<p>
  Pour rapidement comprendre ce qu'est une requête AJAX et sa mise en oeuvre dans jQuery, un petit exemple simple. Tout d'abord créons une page PHP, nommée <kbd>getTime.php</kbd>, renvoyant simplement l'heure courante :
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <a target="blank" href="http://www.php.net/?"><span class="kw2">&lt;?</span></a><br />
&nbsp; &nbsp;<a target="blank" href="http://www.php.net/print"><span class="kw3">print</span></a> <a target="blank" href="http://www.php.net/date"><span class="kw3">date</span></a><span class="br0">&#40;</span><span class="st0">'h:i:s'</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
<a target="blank" href="http://www.php.net/?"><span class="kw2">?&gt;</span></a>
  </div>
  
  </div>
</p>
<p>
  Rien de bien sorcier dans ce code, mis à part qu'il ne contient aucune balise, et c'est normal car notre requête AJAX va s'attendre à recevoir des données, pas une page WEB. Il est possible de tester cette fonction avec votre navigateur pour vérifier qu'il affiche bien l'heure. 
</p>
<p>
  Maintenant nous allons fabriquer une page <kbd>horloge.php</kbd> dont le but est, toutes les secondes, de faire une requête AJAX et de mettre à jour le contenu d'un <kbd>div</kbd> avec le résultat de la requête. 
  
  <div class='code-block code-block-fragment'>
  <div class='container'>
  <span class="sy0">&lt;</span>html<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;</span>head<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>style<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; &nbsp; body <span class="br0">&#123;</span> <br />
&nbsp; &nbsp; &nbsp; &nbsp; background<span class="sy0">-</span>color<span class="sy0">:</span>black<span class="sy0">;</span> <br />
&nbsp; &nbsp; &nbsp; &nbsp; color<span class="sy0">:</span>white<span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
&nbsp; &nbsp; &nbsp; A <span class="br0">&#123;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; color<span class="sy0">:</span>white<span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
&nbsp; &nbsp; &nbsp; span<span class="co2">#heure {</span><br />
&nbsp; &nbsp; &nbsp; &nbsp;background<span class="sy0">-</span>color<span class="sy0">:</span>white<span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp;color<span class="sy0">:</span>black<span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;/</span>style<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>script type<span class="sy0">=</span><span class="st0">&quot;text/javascript&quot;</span> src<span class="sy0">=</span><span class="st0">&quot;jquery.js&quot;</span><span class="sy0">&gt;&lt;/</span>script<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; <span class="sy0">&lt;</span>script<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; &nbsp; <a target="blank" href="http://www.php.net/function"><span class="kw2">function</span></a> changeHeure<span class="br0">&#40;</span><span class="br0">&#41;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#123;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; jQuery<span class="sy0">.</span>get<span class="br0">&#40;</span><span class="st0">&quot;getTime.php&quot;</span><span class="sy0">,</span> <span class="br0">&#123;</span><span class="br0">&#125;</span><span class="sy0">,</span> reponseServeur<span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
<br />
&nbsp; &nbsp; &nbsp; <a target="blank" href="http://www.php.net/function"><span class="kw2">function</span></a> reponseServeur<span class="br0">&#40;</span>texte<span class="sy0">,</span> erreur<span class="sy0">,</span> requête<span class="br0">&#41;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#123;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; $<span class="br0">&#40;</span><span class="st0">'#heure'</span><span class="br0">&#41;</span><span class="sy0">.</span>html<span class="br0">&#40;</span>texte<span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; setTimeout<span class="br0">&#40;</span>changeHeure<span class="sy0">,</span> <span class="nu0">1000</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
&nbsp; &nbsp; &nbsp; <a target="blank" href="http://www.php.net/function"><span class="kw2">function</span></a> initializePage<span class="br0">&#40;</span><span class="br0">&#41;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#123;</span><br />
&nbsp; &nbsp; &nbsp; &nbsp; changeHeure<span class="br0">&#40;</span><span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><br />
&nbsp; &nbsp; &nbsp; $<span class="br0">&#40;</span>initializePage<span class="br0">&#41;</span><span class="sy0">;</span><br />
&nbsp; &nbsp; <span class="kw2">&lt;/script&gt;</span><br />
&nbsp; <span class="sy0">&lt;/</span>head<span class="sy0">&gt;</span><br />
&nbsp; <span class="sy0">&lt;</span>body<span class="sy0">&gt;</span><br />
&nbsp; &nbsp; Bienvenue sur l<span class="st0">'Horloge AJAX/PHP. Il est actuellement <br />
&nbsp; &nbsp; &lt;span id=&quot;heure&quot;/&gt;<br />
&nbsp; &lt;/body&gt;<br />
&lt;/html&gt;<br />
</span
  </div>
  
  </div>
</p>
<p>
  Tout commence, comme toujours, par la commande jQuery <kbd>$(initializePage)</kbd> et l'appel à la fonction <kbd>initializePage</kbd> lorsque la page a finie d'être chargée par le navigateur. Cette fonction fait un appel à <kbd>changeHeure</kbd>. 
</p>
<p>
  Cette fonction contient notre appel AJAX, avec la commande jQuery <kbd>jQuery.get(...)</kbd>. Son but est de faire une requête sur l'url passée en paramètre ("getTime.php") et lorsque le serveur a répondu, appeler la fonction passée en dernier paramètre (<kbd>reponseServeur</kbd>). Cette fonction est asynchrone, c'est à dire qu'elle ne bloque pas le script. 
</p>
<p>
  Lorsque jQuery reçoit la réponse du serveur (ici l'heure), il fait donc appel à notre fonction <kbd>reponseServeur</kbd>, en lui passant en premier paramètre le texte renvoyé (ex. "12:11:13"). Nous allons alors utiliser les techniques vues plus haut pour rechercher le div ayant pour id <kbd>heure</kbd> et changer le contenu HTML de cet élément avec l'heure reçue de notre serveur. Voilà, fin de la magie AJAX, ce n'est rien de plus que cela même si cela révolutionne beaucoup la manière dont nous concevons les sites web aujourd'hui. 
</p>
<p>
  La dernière instruction de la fonction est un classique "setTimeout" qui va indiquer à javascript de refaire un appel à la fonction <kbd>changeHeure</kbd> dans une seconde. Et ainsi de suite.
</p>

<p>
  Comme vous le voyez, jQuery cache ici beaucoup de la complexité d'AJAX, complexité qui réside surtout dans le fait de devoir prendre en compte les manières diverses dont chaque navigateur gère les appels asynchrone. Vous voyez aussi qu'AJAX peut être utilisé dans plein de situation différentes. Pour récupérer des données à traiter, pour récupérer des valeurs à insérer dans une liste, pour lancer une commande sur le serveur, et aussi pour changer, comme ici, une portion du DOM. Et comme ce dernier usage est très commun, pour simplifier encore le code, jQuery propose une fonction permettant de réaliser le <kbd>get</kbd> et l'injection de code HTML dans le DOM, sans fonction <kbd>reponseServeur</kbd> et en un seule passe. Le script devient alors :
    <script>
      function changeHeure()
      {
        ${'#heure'}.load("getTime.php", {}, function ()
        {
          setTimeout('changeHeure', 1000);
        });
      }
      
      function initializePage()
      {
        changeHeure();
      }
      $(initializePage);
    </script>  
</p>
<p>
  Comme vous le voyez, la fonction <kbd>load</kbd> va effectuer un <kbd>get</kbd>, mais va aussi directement renvoyer la réponse du serveur dans l'élément d'id <kbd>#heure</kbd>. Le dernier paramètre n'est plus là que pour réarmer le timer pour le prochain appel. 
</p>

	<a name='chapter_8'></a>
  <h2>Conclusion</h2>
	
<p>
  Cette introduction ne couvre pas, loin de là, tous les possibles de cette petite mais puissante librairie. jQuery dispose de fonctions d'effets visuels, peut aussi utiliser XPath pour sélectionner les éléments du DOM, peut être étendu par l'ajout de plugins. Bref, la bonne source d'information est <a class='external' target='_blank' href='http://docs.jquery.com' >ici</a> et il vous reste encore beaucoup à découvrir <img src="http://artisan.karma-lab.net/sites/all/modules/contrib/smileys/packs/crystal/smile.gif" title="Smiling" alt="Smiling" class="smiley-content"/>
</p>    ]]></content>
  </entry>
</feed>
