5 : Bibliothèques JavaScript

Faciliter le JavaScript

Ce cours n’a abordé jusqu’à présent que le JavaScript dit « pur », ou « Vanilla » . Vous avez eu besoin de tout développer par vous-mêmes, ce qui peut rapidement se révéler fastidieux. Un bon exemple de ce qui est nécessaire de développer régulièrement : les animations ! Aussi incroyable que cela puisse paraître, le JavaScript ne fournit aucune fonction capable de nous aider dans nos animations, il nous faut donc les développer par nous-mêmes.

Heureusement, le JavaScript est un langage très utilisé et sa communauté est immense, il est donc très facile de trouver des scripts adaptés à vos besoins. Parmi ces scripts, nous trouvons deux types : les frameworks et les bibliothèques.

Les frameworks

Le terme « framework » est abusivement utilisé en JavaScript. Ce que nous allons vous présenter ne sont pas des frameworks au sens propre du terme, mais il est courant de les nommer de cette manière. Il s’agit en fait aussi de bibliothèques, avec une portée étendue.

Un framework a pour but de fournir une « surcouche » au JavaScript afin de simplifier l’utilisation des domaines les plus utilisés de ce langage tout en facilitant la compatibilité de vos codes entre les navigateurs web. Par exemple, quelques frameworks disposent d’une fonction $() s’utilisant de la même manière que la méthode querySelector(), et ce, sur tous les navigateurs web, facilitant ainsi la sélection d’éléments HTML. Pour faire simple, un framework est une grosse boîte à outils contenant une multitude de fonctions permettant de subvenir aux besoins des développeurs !

L’atout numéro un d’un framework est sa capacité à s’adapter à toutes les utilisations du JavaScript et à fournir un système performant d’extensions (ou plugins) afin qu’il puisse être étendu à des utilisations non envisagées par son système de base. Grâce à ces deux points, un framework permet de simplifier et d’accélérer considérablement le développement d’applications web.

Il existe de nombreux frameworks en JavaScript en raison de la pauvreté de ce langage en terme de fonctions natives, cependant nous n’allons présenter que les plus connus d’entre eux :

  • jQuery : il s’agit du framework JavaScript le plus connu. Réputé pour sa simplicité d’utilisation et sa communauté gigantesque, il est clairement incontournable ! Cependant, il n’est pas toujours apprécié en raison de sa volonté de s’écarter de la syntaxe de base du JavaScript grâce au chaînage de fonctions, que vous pouvez constater dans l’exemple qui suit : $("p.neat").addClass("ohmy").show("slow");.
  • MooTools : un framework puissant et presque tout aussi connu que jQuery, bien qu’énormément moins utilisé. Il est réputé pour sa modularité et son approche différente plus proche de la syntaxe de base du JavaScript. En revanche, bien que ce framework soit « segmentable » (vous ne téléchargez que ce dont vous avez besoin), il reste nettement plus lourd que jQuery.
  • Dojo : connu pour sa capacité à permettre la conception d’interfaces web extrêmement complètes, il possède des atouts indéniables face aux plus grands frameworks et tout particulièrement jQuery UI, une extension de jQuery conçue pour faire des interfaces Web. Ce framework est l’un des plus modulaires que l’on puisse trouver sur Internet, ce qui fera la joie des fans d’optimisation.
  • YUI : La bibliothèque YUI n’est actuellement plus maintenue.. Ce framework est pour le moins complet, ne vous fiez pas aux fausses idées que vous pouvez avoir de Yahoo!, vous pourriez avoir bien des surprises en utilisant ce framework qui est modulable et relativement performant, bien qu’il bénéficie d’une communauté assez restreinte.
  • Prototype : l’un des pionniers des frameworks JavaScript ! Nous le citons seulement en tant qu’exemple, car, malgré ses qualités, il se fait vieux. Son déclin s’explique par le simple fait qu’il étendait les objets natifs liés au DOM, rendant le tout assez lent et peu compatible. Bref, vous ne vous en servirez jamais, mais au moins vous saurez de quoi veulent parler certaines personnes en parlant de « Prototype » avec un P majuscule.

Les bibliothèques

Contrairement aux frameworks, les bibliothèques (libraries en anglais) ont un but bien plus spécialisé.

Quel est l’intérêt si un framework me fournit déjà tout ce dont j’ai besoin ?

L’intérêt se situe à la fois sur le poids du fichier JavaScript à utiliser (une bibliothèque sera généralement plus légère qu’un framework) et sur la spécialisation des bibliothèques. Ces dernières ont souvent tendance à aller plus loin que les frameworks, vu qu’elles n’agissent que sur un domaine bien précis, ce qui simplifie d’autant plus votre développement dans le domaine concerné par la bibliothèque.

Et puis il existe un principe important dans le développement (web ou logiciel) : l’optimisation. Utiliser un framework uniquement pour faire une malheureuse animation n’est vraiment pas conseillé, c’est un peu comme si vous cherchiez à tuer une mouche avec un tank… Préférez alors les bibliothèques, en voici d’ailleurs quelques-unes qui pourraient vous servir :

  • Sizzle, Qwery : deux bibliothèques conçues pour fonctionner de la même manière que la méthode querySelector(), ce type de bibliothèques est d’ailleurs à l’origine de l’implémentation officielle de la méthode en question. La première est le moteur de sélection du framework jQuery mais est relativement lourde, la seconde a l’avantage d’être particulièrement légère et un poil plus rapide en terme d’exécution.
  • Popcorn.js : une bibliothèque permettant une manipulation aisée des balises <audio> et <video>, il devient ainsi très simple d’interagir avec ces balises afin de mettre en place des sous-titres, des commentaires placés à un moment précis de la piste audio ou vidéo, etc.
  • Raphaël, Three.js : trois bibliothèques spécialisées dans le graphisme. La première fonctionne exclusivement avec les images SVG et la deuxième s’est spécialisée dans la 3D et gère à la fois SVG, <canvas> et surtout la bibliothèque WebGL, qui sait tirer parti du moteur OpenGL !
  • Modernizr : comme vous le savez si bien, les langages Web sont plus ou moins bien supportés selon les navigateurs, surtout quand il s’agit de fonctionnalités récentes ! Cette bibliothèque a pour but de vous aider à détecter la présence de telle ou telle fonctionnalité, il ne vous restera alors plus qu’à fournir un script résolvant ce problème (un polyfill) ou exploitant une solution alternative.

Il n’est malheureusement pas possible de vous faire une liste complète de tout ce qui existe en terme de bibliothèques, elles sont bien trop nombreuses.

jQuery

jQuery est une bibliothèque JavaScript gratuite et très pratique, ayant une syntaxe courte et logique, compatible avec tous les navigateurs courants.
jQuery est devenue une référence importante à savoir utiliser : pour preuve, elle est largement répandue sur la toile. Microsoft, Twitter, Mozilla, Google Code, Amazon et WordPress France, pour ne citer qu’eux, l’utilisent.

Présentation

Diversité des implémentations du JavaScript

Si vous faites un peu de JavaScript, alors vous savez que c’est parfois difficile et très long d’obtenir ce que l’on veut, et cela peut paraître répétitif.

Les guerres font rage entre les navigateurs (Firefox, Internet Explorer, Opera, Safari, Chrome etc.) qui se partagent les internautes : de ce fait, il faut adapter votre code à chacun de ces navigateurs qui fournissent des fonctions différentes pour répondre au même usage.

Par exemple, ce code permet de récupérer en nombre en pixels la position de défilement vertical de la page web (scroll) :

function avoirDefilementVertical(){
  if(typeof( window.pageYOffset ) == 'number'){
    // Netscape
    return window.pageYOffset; 
  } else if( document.body && (document.body.scrollTop) || navigator.appName=="Microsoft Internet Explorer") {
    // DOM
    return document.body.scrollTop;  
  } else if( document.documentElement && (document.documentElement.scrollTop) ) {
     // Internet Explorer 6
    return document.documentElement.scrollTop;
  }
}

jQuery

Nous allons donc apprendre dans ce tutoriel à utiliser le framework JavaScript nommée jQuery.

jQuery, un framework JS gratuit, dont la syntaxe est très courte, dont les noms des fonctions sont intuitifs (en anglais bien sûr), simplifiant l’AJAX, permettant de faire des animations, ayant une communauté très active, et contenant à peu près tout ce dont vous rêvez grâce à ses plugins.

Et voici la version jQuery du bout de code :

function avoirDefilementVertical(){
  return $(document).scrollTop();
}

Comme on l’a vu, jQuery n’est pas la seule bibliothèque JS disponible, vous pouvez aussi vous intéresser à d’autres comme Mootools, Scriptaculous, Prototype, Yahoo UI, Mochikit, ExtJS, Dojo, …

Installation

Téléchargement

jQuery est tout simplement un fichier JavaScript. Il vous suffit donc de le télécharger sur le site officiel.

Là, deux choix s’offrent à vous dans l’encadré à droite :

  • « Production » : version compressée du fichier original (incompréhensible mais légère), si vous ne voulez pas regarder le code source et pour la version publique de votre site.
  • « Development » : code source lisible, vous pouvez réduire le poids de jQuery en enlevant ce qui ne vous sert pas, puis en compressant à l’aide de JavaScript Compressor par exemple.

Intégration à une page web

On va supposer que votre fichier jQuery s’appelle jquery.js et qu’il est dans le même répertoire que le fichier qui l’utilise.
jQuery s’intègre comme tout autre fichier JavaScript :

<script type="text/javascript" src="jquery.js"></script>

Hello World

Pour vous montrer la simplicité de jQuery, voici le classique « Hello World » :

<!DOCTYPE html>
<html lang="fr" >
  <head>
    <title>Hello World avec jQuery</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  </head>
  <body>
      Salut tout le monde !
    <script type="text/javascript" src="jquery.js"></script>
    <script type="text/javascript">
       $('body').html('Hello World');
    </script>
  </body>
</html>
Préférez les serveurs Google aux votres

Google héberge lui aussi les fichiers jQuery :
https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js
pour la version de Production (compressée).

On peut donc facilement intégrer jQuery à sa page en mettant dans le <head>:

<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>

Cette solution apporte plusieurs avantages :

  1. Le script de jQuery est centralisé : un internaute visite plein de sites qui sont susceptibles d’intégrer jQuery. Si tous ces sites hébergent leurs propres scripts, l’internaute en question va devoir re-télécharger jQuery plein de fois. Alors qu’avec cette solution, le cache du navigateur peut être optimisé et ainsi éviter de re-télécharger le même script tout le temps.
  2. La bande passante de votre site est allégée, le travail étant transmis aux serveurs de Google.

Pour information, Google héberge plusieurs bibliothèques utilisables, voir la liste des bibliothèques JavaScript hébergées par Google.

Fonction principale

Toute jQuery repose autour d’une fonction : jQuery() (abrégée $() car le dollar est un caractère autorisé pour les noms de fonctions en JavaScript) qui permettra de sélectionner des éléments dans votre page web.
Le premier argument de cette fonction, l’« expression », qu’on lui passe est une chaîne de caractère, représentant un sélecteur CSS, un peu comme dans vos feuilles de styles, mais en plus fort ! 

Sélecteurs basiques

Voici quelques exemples pour que vous vous rappeliez ce que sont les sélecteurs CSS :

ExpressionRetour
#titrela balise ayant pour id “titre”
h1les balises h1
.grasles balises qui ont la classe “gras”
a,h1,h2les balises a, h1 et h2
*toutes les balises

Les méthodes sont des fonctions associées à des objets. Les méthodes jQuery sont donc des fonctions qui ne s’utilisent que sur des objets jQuery.
Il y a différentes méthodes, et certaines méthodes ont elles-mêmes différents arguments afin de répondre à différents usages. Leurs noms sont intuitifs (en anglais).

Quelques méthodes

À titre d’exemple, pour passer à la pratique, la méthode html() permet d’accéder au contenu des éléments si on l’appelle sans aucun argument, et permet de modifier le contenu des éléments si on l’appelle avec comme premier argument une chaîne de caractères (représentant le contenu).

Pour ce code : <div id="titre">J'aime les frites.</div> :

$('#titre'); // Sélectionne notre balise mais ne fait rien.
alert($('#titre').html()); // Affiche le contenu "J'aime les frites."
$('#titre').html('Je mange une pomme'); // Remplace le contenu "J'aime les frites." par "Je mange une pomme".
$('#titre').html($('title').html()); // Remplace le contenu par le titre de la page (contenu dans la balise <title>).

Deux autres méthodes, before() et after() permettent d’ajouter du contenu ou un élément de la page (ça dépend de ce qu’on lui passe en paramètre) respectivement avant et après l’élément en question :

// Ajoute du contenu après chaque balise textarea.
$('textarea').after('<p>Veuillez ne pas poster de commentaires injurieux.</p>');
// Ajoute "Voici le titre :" avant la balise ayant comme id "titre".
$('#titre').before('Voici le titre :');
// Ajoute "! Wahou !" après la balise ayant comme id "titre".
$('#titre').after('! Wahou !');

Chaînage des méthodes

Il faut savoir qu’on peut chaîner les méthodes, c’est-à-dire que si une méthode agit sur un élément (elle n’est pas censée donner une information sur cet élément mais le modifier), on peut rajouter une autre méthode :

// Ajoute du contenu après chaque balise textarea.
$('textarea')
  .after('<p>Veuillez ne pas poster de commentaires injurieux.</p>')
  .after('<p><strong>Merci beaucoup.</strong></p>');
// Ajoute "Voici le titre :" avant et "! Wahou !" après la balise ayant comme id "titre".
$('#titre')
  .before('Voici le titre :')
  .after('! Wahou !');

Chargement du DOM

Quand on fait un appel à la fonction principale, il se peut parfois qu’elle ne retourne rien. On a beau placer son code en fin de body, les éléments de la page web ne sont pas encore placés.
La solution de ce problème en JavaScript est le fameux :

window.onload = function(){
  // Fonctions du genre document.getElementById('balise') qui marchent,
  // on peut accéder aux éléments.
};

jQuery offre une syntaxe à peu près similaire : la fonction doit juste être donnée à la fonction principale jQuery() ou $().

$(function(){
  // On peut accéder aux éléments.
  // $('#balise') marche.
});

Le DOM peut alors être manipulé en toute sûreté car vous pouvez être sûrs que tous les éléments existent. Les feuilles de styles sont aussi chargées si elles ont été incluses avant le script.
On peut utiliser cela plusieurs fois, les fonctions seront appelées chronologiquement à partir du moment où le document est prêt.

Sélecteurs

Sélecteurs CSS “classiques”

ExpressionRetour
*Toutes les balises.
elemLes balises elem.
#idBalise ayant l’id “id”.
.classBalises ayant la classe “class”.
elem[attr]Balises elem dont l’attribut “attr” est spécifié.
elem[attr="val"]Balises elem dont l’attribut “attr” est à la valeur val.
elem balBalises bal contenues dans une balise elem.
elem > balBalises bal directement descendantes de balises elem.
elem + balBalises bal immédiatement précédées d’une balise elem.
elem ~ balBalises bal précédées d’une balise elem.

La liste des sélecteurs CSS 3 est très complète (avec explications en français).

Sélecteurs spécifiques à jQuery

ExpressionRetour
:hiddenÉléments invisibles, cachés.
:visibleÉléments visibles.
:parentÉléments qui ont des éléments enfants.
:headerBalises de titres : h1, h2, h3, h4, h5 et h6.
:not(s)Éléments qui ne sont pas sélectionnés par le sélecteur s.
:has(s)Éléments qui contiennent des éléments sélectionnés par le sélecteur s.
:contains(t)Éléments qui contiennent du texte t.
:emptyÉléments dont le contenu est vide.
:eq(n) et :nth(n)Le n-ième élément, en partant de zéro.
:gt(n) (greater than, signifiant plus grand que)Éléments dont le numéro (on dit l’« index ») est plus grand que n.
:lt(n) (less than, signifiant plus petit que)Éléments dont l’index est plus petit que n.
:firstLe premier élément (équivaut à :eq(0)).
:lastLe dernier élément.
:even (pair)Éléments dont l’index est pair.
:odd (impair)Éléments dont l’index est impair.

Manipuler le contenu

Contenu textuel

Méthode text()

Vous connaissez déjà html(), qui permet de remplacer le contenu d’un élément. Eh bien voici text(), qui manipule le contenu comme du texte et non comme des balises :

  • changer le contenu avec text('contenu') : les chevrons < et > sont convertis en entités HTML : &lt; et &gt; respectivement (les balises ne sont donc plus actives) ;
  • récupérer le contenu avec text() : renvoie le contenu « textuel » (pas les balises), les entités HTML étant converties en caractères.

C’est l’équivalent en JavaScript classique de la propriété textContent.

Comparaison de text() avec html()
Récupérer le contenu
<p id="premier">
  <span class="texte">
    Salut tout le monde
  </span>
  <img src="photo_1.jpg" alt="Premiere Photo !" />
</p>
$('#premier').text()

renvoie “Salut tout le monde” (avec tous les retours à la ligne et les espaces).

Alors que $('#premier').html() renvoie :

<span class="texte">
  Salut tout le monde
</span>
<img src="photo_1.jpg" alt="Premiere Photo !" />
Définir le contenu

Et lorsque l’on passe du texte en paramètre : $('#premier').text('<strong>les pommes</strong>') change le contenu du paragraphe en

<strong>les pommes</strong>

Alors que $('#premier').html('<strong>les pommes</strong>') ajoute une balise <strong>les pommes</strong>.

Remplacer la balise

Les méthodes html() et text() permettent de changer le contenu : replaceWith() est une méthode qui permet de remplacer la balise et son contenu. On peut lui passer du code html ou encore un objet jQuery qui viendra remplacer l’élément en question.

Ainsi faire $('div').replaceWith('<span>Salut!</span>') transformera <div>Bonsoir.. :)</div> en <span>Salut!</span>.

// Remplace les liens <a>...</a> par <em>censuré</em>.
$('a').replaceWith('<em>censuré</em>');
$('h1').replaceWith($('.titre:first'));
$('#titre').replaceWith('<h1>'+$('#titre').html()+'</h1>');
$('.recherche').replaceWith('<a href="http://google.com">Google</a>');

Insertion à l’intérieur et à l’extérieur

Insérer à l’intérieur avec prepend() et append()

Les méthodes html() et text() réécrivent le contenu d’un élément : c’est-à-dire qu’elles les vident dans un premier temps, puis y écrivent.

Les méthodes prepend() et append() permettent d’ajouter du contenu à celui existant : prepend() avant et append() après :

  1. $('span').prepend('balise span » ') transformera <span>Hello World !</span> en <span>balise span » Hello World !</span>.
  2. $('span').append(' « balise span') transformera <span>Hello World !</span> en <span>Hello World ! « balise span</span>.
Insérer à l’extérieur avec before() et after()

Les méthodes append() / prepend() / appendTo() / prependTo() changent le contenu à l’intérieur, c’est à dire que faire $('p').prepend('Paragraphe : ') dans <p>Comment tu vas ?</p>, change le paragraphe en : <p>Paragraphe : Comment tu vas ?</p>.

Les méthodes after() / before() / insertAfter() / insertBefore() sont les équivalents de ces méthodes, à l’exception qu’elles ajoutent à l’extérieur des balises. Elles fonctionnent donc de la même manière : on passe en argument un objet jQuery ou du contenu html à after() / before() et un sélecteur jQuery ou un objet jQuery à insertAfter() / insertBefore().

Donc si on fait :

$('p').before('Paragraphe : ')
<p>Comment tu vas ?</p>

Le code HTML deviendra :

Paragraphe : <p>Comment tu vas ?</p>

Envelopper

Envelopper à l’extérieur

wrap() permet d’« envelopper » n’importe quel élément entre deux balises. Le plus simple est de lui passer une balise ouvrante et une fermante sans contenu (<em></em> par exemple). 
$('span').wrap('<b></b>') transformera <span>Hello World !</span> en <b><span>Hello World !</span></b>

$('#titre').wrap('<h1></h1>');
$('.desactiver').wrap('<pre></pre>');
// Le contenu sera entre les <div></div>.
$('.contenu').wrap('<em>le contenu</em> ira là : <div></div> mais pas <strong>là</strong>');
// Le contenu sera entre les <em></em> mais aussi les <q></q>.
$('span').wrap('<em id="ici"></em> et là <q></q>');
Envelopper à l’intérieur

wrapInner() fontionne de la même manière mais entoure le contenu. Tout comme avec wrap(), le contenu est dupliqué dans chacun des couples de balises ouvrantes / fermantes sans contenu.
$('span').wrapInner('<b></b>') transformera <span>Hello World !</span>en <span><b>Hello World !</b></span>

$('span.italique').wrapInner('<i></i>');
$('h1:first').wrapInner('<a href="http://google.com"></a>');
$('a').wrapInner('<em>Ceci est un lien : </em><u></u>');
Déballer

unwrap() est une méthode permettant de « désenvelopper » (ou déballer) un élément. C’est-à-dire enlever la balise parent qui l’enveloppe.
C’est un peu la méthode inverse de wrap() !

Par exemple $('b > span').unwrap(); sur <p>Hello <b>Wor<span>ld</span></b></p> donne <p>Hello Wor<span>ld</span></p>.

Copier, supprimer et vider

Copier des éléments

clone() permet de copier des éléments (de les « cloner »), avec leur contenu, leurs attributs et valeurs (donc par conséquent les événements comme onclick etc.).
clone() va simplement renvoyer un objet jQuery qui est une copie de l’original, mais il ne va pas l’ajouter à votre page web.

// Multiplie le nombre de boutons par 2.
$('button').clone().appendTo($('body'));
// Revient à faire :
$('body').append($('button').clone());
Supprimer des éléments

remove() permet de supprimer des éléments de la page web. On peut lui passer un argument qui représente un sélecteur jQuery : il désignera les éléments qui doivent être supprimés parmi tous les éléments contenus dans l’objet jQuery.

// Supprime les liens de la page ayant la classe "sites".
$('a').remove('.sites');
// Supprime les balises <strong> dans des <button>.
$('button strong').remove();
Vider des éléments

empty() permet de vider le contenu de l’élément en question :

$('button').empty(); // Vide les boutons.
$('body').empty(); // Vide la page web.
// Revient à faire :
$('body').html('');

Exercice

Le but sera de manipuler du contenu en partant de ce bout de page HTML :

<p id="contenu"> 
  Lorem <span class="vert">ipsum dolor</span> sit amet, <span class="titre2"> 
  consectetur adipiscing elit</span>.Etiam <a href="#">facilisis</a>  
  <span class="rouge">ultrices</span> dolor, eu <span class="orange">fermentum 
   eros</span> aliquet ac. Aenean varius <span class="titre2">ultrices nisi 
  </span> vel aliquet. Nam eu viverra sem. <span class="gras">Fusce facilisis 
  </span> eros ac <span class="titre1">elit scelerisque molestie</span>. Morbi 
   lacus orci, interdum ac <span class="souligne">faucibus hendrerit</span>, 
   <span class="barre">facilisis vel</span> nunc. <span class="souligne">Sed in 
  </span> <span class="bleu">mauris</span> <span class="gras">lorem</span>.  
  Integer facilisis, <span class="italique">augue et suscipit</span> molestie, 
   <span class="barre">lectus lectus</span> pellentesque mi, <span class="vert"> 
  at</span> condimentum <span class="italique">nulla</span> nibh ut turpis. <span> 
  Cum sociis</span> natoque <span class="vert">penatibus et magnis</span> dis  
  <a href="#">parturient montes</a>, nascetur ridiculus mus. Etiam quis nisl  
  metus.<span class="vert">Phasellus</span>ullamcorper posuere augue quis placerat.  
  <span class="titre1">Duis sed quam</span>odio. Donec <span class="vert">aliquam 
   metus</span> a <a href="#">ligula lacinia</a> a tempor leo <span class="bleu">imperdiet</span>. 
   Cras augue purus, <span class="souligne">lobortis eu</span> scelerisque sed, 
   <span class="vert">venenatis ut</span> turpis. Donec <span class="bleu">quis 
   magna sapien</span>. Ut ut diam arcu. <span class="souligne">Suspendisse nec 
   risus</span> id lacus venenatis <a href="#">rhoncus.</a> In vitae  
  <span class="vert">justo tellus</span>, <span class="bleu">vitae lacinia nunc 
  </span>. Aliquam <span class="italique">erat</span> <span class="rouge">volutpat.</span> 
</p>
    .rouge {
      color: red;
    }
    .orange {
      color: orange;
    }
    .bleu {
      color: blue;
    }
    .vert {
      color: green;
    }
    .gras {
      font-weight: bold;
    }
    .italique {
      font-style: italic;
    }
    .souligne {
      text-decoration: underline;
    }
    .barre {
      text-decoration: line-through;
    }

L’utilisateur va pouvoir agir sur la page grâce à des boutons du type : <button onclick="fonctionJs()">Cliquez ici</button>.

Vous pouvez attribuer les fonctionnalités que vous voulez aux boutons, mais en voici quelques-unes que je vous propose :

  • enlever les liens ;
  • enlever le texte en gras ;
  • enlever le texte en italique ;
  • enlever le texte décoré ;
  • vider les boutons ;
  • voir le code ;
  • transformer les liens en boutons ;
  • dupliquer le texte ;
  • mettre des titres ;
  • colorer le texte ;
  • organiser sémantiquement le texte ;

Par exemple :

<button onclick="semantique()">Organiser sémantiquement le texte</button> 
<button onclick="colorer()">Colorer le texte</button> 
<button onclick="mettreTitres()">Mettre des titres</button> 
<button onclick="liensEnBoutons()">Transformer les liens en boutons</button> 
<button onclick="dupliquerTexte()">Dupliquer le texte</button> 
<button onclick="regrouperTitres()">Regrouper les titres</button> 
<button onclick="regrouperLiens()">Regrouper les liens</button> 
<button onclick="viderBoutons()">Vider les boutons</button> 
<button onclick="enleverLiens()">Enlever les liens</button> 
<button onclick="enleverGras()">Enlever le texte en gras</button> 
<button onclick="enleverItalique()">Enlever le texte en italique</button> 
<button onclick="enleverDecor()">Enlever le texte décoré</button> 
<button onclick="voirCode()">Voir le code</button>

De jQuery à Vanilla JS

jQuery, c’est sûrement très bien, ça simplifie pas mal de choses et le chaining est intéressant mais est-ce que vous connaissez l’équivalent en pur JavaScript ?

Note : Vanilla JS n’est pas un framework mais veut simplement dire “à nu”, c’est du JavaScript sans bibliothèque.

Événements

// jQuery
$(document).ready(function() {
  // code
});
 
// Vanilla
document.addEventListener("DOMContentLoaded", function() {
  // code
});
// jQuery
$('a').click(function() {
  // code…
})
 
// Vanilla
[].forEach.call(document.querySelectorAll('a'), function(el) {
  el.addEventListener('click', function() {
    // code…
  })
})

La liste des événements jQuery :

http://api.jquery.com/category/events/

Sélecteurs

// jQuery
var divs = $("div");
 
// Vanilla
var divs = document.querySelectorAll("div");
// jQuery
var newDiv = $("<div/>");
 
// Vanilla
var newDiv = document.createElement("div");

Attributs

// jQuery
$("img")
  .filter(":first")
  .attr("alt", "My image");
 
// Vanilla
document.querySelector("img").setAttribute("alt", "My image");

Classes

// jQuery
newDiv.addClass("foo");
 
// Vanilla
newDiv.classList.add("foo");
// jQuery
newDiv.toggleClass("foo");
 
// Vanilla
newDiv.classList.toggle("foo");

Manipulation

// jQuery
$("body").append($("<p/>"));
 
// Vanilla
document.body.appendChild(document.createElement("p"));
// jQuery
var clonedElement = $("#about").clone();
 
// Vanilla
var clonedElement = document.getElementById("about").cloneNode(true);
// jQuery
$("#wrap").empty();
 
// Vanilla
var wrap = document.getElementById("wrap");
while (wrap.firstChild) wrap.removeChild(wrap.firstChild);
// jQuery
var parent = $("#about").parent();
 
// Vanilla
var parent = document.getElementById("about").parentNode;
// jQuery
if($('#wrap').is(':empty'))
 
// Vanilla
if(!document.getElementById('wrap').hasChildNodes())
// jQuery
var nextElement = $("#wrap").next();
 
// Vanilla
var nextElement = document.getElementById("wrap").nextSibling;

Encore plus d’équivalences

http://youmightnotneedjquery.com/

Collection de scripts Vanilla

https://van11y.net/fr/

Exercice

Textures

  1. On a une grille de texture, lorsqu’on clique sur la texture, elle s’applique au fond de la page. Il faut récupérer le background-image de l’élément et le mettre dans le <body>
  2. Lorsqu’on passe la souris sur le logo, il se déplace vers le bas. Pour que ce soit animé, il faut utiliser la fonction animate(). Vous avez le droit de vous faire plaisir et faire une autre animation.
<!DOCTYPE html lang="fr">
<html>
<head>
<meta type="content" charset="utf-8" />
<title>Exercice jQuery</title>
<style>
  section { padding:10em 5em; text-align:center; }
  #patterns button { display:inline-block; margin:0 1em 1em 0; border-radius:5px; box-shadow:0 2px 2px rgba(0,0,0,0.1); height:150px; width:150px; cursor:pointer; border:solid 2px white; }
  #logo { position:absolute; top:0; width:100%; text-align:center; color:white; }
  #logo span { background:black; display:inline-block; padding:1em; border-radius:0 0 5px 5px; }
  .bloc1 { background-image:url(https://www.toptal.com/designers/subtlepatterns/patterns/moroccan-flower-dark.png); }
  .bloc2 { background-image:url(https://www.toptal.com/designers/subtlepatterns/patterns/moroccan-flower.png); }
  .bloc3 { background-image:url(https://www.toptal.com/designers/subtlepatterns/patterns/watercolor.png); }
  .bloc4 { background-image:url(https://www.toptal.com/designers/subtlepatterns/patterns/more-leaves-on-green.png); }
  .bloc5 { background-image:url(https://www.toptal.com/designers/subtlepatterns/patterns/more-leaves.png); }
  .bloc6 { background-image:url(https://www.toptal.com/designers/subtlepatterns/patterns/double-bubble.png); }
  #logo span {}
</style>
</head>
<body>
  <a href="#" id="logo"><span>Mon Logo</span></a>
  <section id="patterns">
    <button class="bloc1"></button>
    <button class="bloc2"></button>
    <button class="bloc3"></button>
    <button class="bloc4"></button>
    <button class="bloc5"></button>
    <button class="bloc6"></button>
  </section>
<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script>
<script>
$(document).ready(function(){
  // je lance une action sur le clic sur chaque bouton contenu dans la section "#patterns"
 
  // j'anime le logo au hover sur celui-ci
 
  // je remet le logo dans sa position initiale lorsque je retire la souris
});
</script>
 
</body>
</html>

Régions

Vous disposez du code HTML suivant :

<p>Ligne active : <a href="#reg23ref"  id="id-ligne-active"><em>reg23ref</em ></a></p>
<table id="reg24">
  <caption>Basse-Normandie</caption>
  <thead>
    <tr>
      <th id="reg24nom">Nom</th>
      <th id="reg24t4">2011</th>
      <th id="reg24t3">2010</th>
      <th id="reg24t2">2009</th>
      <th id="reg24t1">2008</th>
    </tr>
  </thead>
  <tbody>
    <tr id="dep14">
      <td headers="reg24nom">Calvados</td>
      <td headers="reg24t4">9,2</td>
      <td headers="reg24t3">9,3</td>
      <td headers="reg24t2">9,3</td>
      <td headers="reg24t1">9,2</td>
    </tr>
    <tr id="dep50">
      <td headers="reg24nom">Manche</td>
      <td headers="reg24t4">7,8</td>
      <td headers="reg24t3">8,1</td>
      <td headers="reg24t2">7,9</td>
      <td headers="reg24t1">8</td>
    </tr>
    <tr id="dep61">
      <td headers="reg24nom">Orne</td>
      <td headers="reg24t4">8,9</td>
      <td headers="reg24t3">8,8</td>
      <td headers="reg24t2">9</td>
      <td headers="reg24t1">8,7</td>
    </tr>
    <tr class="region-reference" id="reg24ref">
      <td headers="reg24nom">Basse-Normandie</td>
      <td headers="reg24t4">8,4</td>
      <td headers="reg24t3">8,4</td>
      <td headers="reg24t2">8,3</td>
      <td headers="reg24t1">8,5</td>
    </tr>
  </tbody>
</table>
<table id="reg23">
  <caption>Alsace</caption>
  <thead>
    <tr>
      <th id="reg23nom">Nom</th>
      <th id="reg23t4">2011</th>
      <th id="reg23t3">2010</th>
      <th id="reg23t2">2009</th>
      <th id="reg23t1">2008</th>
    </tr>
  </thead>
  <tbody>
    <tr id="dep67">
      <td headers="reg23nom">Bas-Rhin</td>
      <td headers="reg23t4">7,9</td>
      <td headers="reg23t3">7,8</td>
      <td headers="reg23t2" title="non significatif">0,2</td>
      <td headers="reg23t1">7,7</td>
    </tr>
    <tr id="dep68">
      <td headers="reg23nom">Haut-Rhin</td>
      <td headers="reg10t4" class="provisoire">9,2</td>
      <td headers="reg23t3">8,7</td>
      <td headers="reg23t2">9</td>
      <td headers="reg23t1" title="non significatif">8,6</td>
    </tr>
    <tr class="region-reference" id="reg23ref">
      <td headers="reg23nom">Alsace</td>
      <td headers="reg23t4" title="non significatif">8,3</td>
      <td headers="reg23t3">8,1</td>
      <td headers="reg23t2"></td>
      <td headers="reg23t1">8,2</td>
    </tr>
  </tbody>
</table>
<table id="reg1">
  <caption>Aquitaine</caption>
  <thead>
    <tr>
      <th id="reg1nom">Nom</th>
      <th id="reg1t4">2011</th>
      <th id="reg1t3">2010</th>
      <th id="reg1t2">2009</th>
      <th id="reg1t1">2008</th>
    </tr>
  </thead>
  <tbody>
    <tr id="dep24">
      <td headers="reg1nom">Dordogne</td>
      <td headers="reg1t4">9,8</td>
      <td headers="reg1t3" class="provisoire">9,8</td>
      <td headers="reg1t2"></td>
      <td headers="reg1t1">9,7</td>
    </tr>
    <tr id="dep33">
      <td headers="reg1nom">Gironde</td>
      <td headers="reg1t4">9,7</td>
      <td headers="reg1t3">9,7</td>
      <td headers="reg1t2">9,8</td>
      <td headers="reg1t1">9,6</td>
    </tr>
    <tr id="dep40">
      <td headers="reg1nom">Landes</td>
      <td headers="reg1t4">9,2</td>
      <td headers="reg1t3">9,1</td>
      <td headers="reg1t2"></td>
      <td headers="reg1t1">9,2</td>
    </tr>
    <tr id="dep47">
      <td headers="reg1nom">Lot-et-Garonne</td>
      <td headers="reg1t4">9,8</td>
      <td headers="reg1t3" title="non significatif">9,8</td>
      <td headers="reg1t2">9,9</td>
      <td headers="reg1t1">9,7</td>
    </tr>
    <tr id="dep64">
      <td headers="reg1nom">Pyrénées-Atlantiques</td>
      <td headers="reg1t4">8,1</td>
      <td headers="reg1t3">8</td>
      <td headers="reg1t2">8</td>
      <td headers="reg1t1">8,1</td>
    </tr>
    <tr class="region-reference" id="reg1ref">
      <td headers="reg1nom">Aquitaine</td>
      <td headers="reg1t4">9,3</td>
      <td headers="reg1t3"></td>
      <td headers="reg1t2">9,2</td>
      <td headers="reg1t1">9,4</td>
    </tr>
  </tbody>
</table>

    body {
      font-family: sans-serif;
    }
    table {
      border: 1px solid rgba(0,0,0,.2);
      border-collapse: collapse;
      width: 100%;
      max-width: 500px;
    }
    td {
      padding: 5px 10px;
    }
    caption {
      margin: 1em 0 .5em;
      font-size: 1.2em;
      font-weight: bold;
    }
    a {
      font-weight: normal;
      font-style: normal;
    }
    .non-defini {
      background: rgba(0, 0, 0,.2); 
    }
    .non-significatif {
      background: rgba(255, 165, 0, .4); 
    }
    .class-ligne-active {
      background: rgba(50, 205, 50, .4); 
      font-weight: bold;
    }

Instructions :

  1. Dans chaque tableau, mettre la dernière ligne en italique.
  2. Dans le corps des tableaux, attribuer à la première cellule de chaque ligne le style suivant :
 color: #555555;
 font-weight: bold;
 text-align: left;
  1. Attribuer à la ligne ayant l’identifiant reg24ref la couleur de fond #FBEC88
  2. Attribuer aux lignes paires des tableaux (dans le tbody) la couleur de fond #e8e8e8, sauf si elles ont l’identifiant #reg24ref.

Astuce : Le sélecteur :not(…) capture les nœuds qui ne vérifient pas une condition.

  1. Mettre un attribut title valant « Provisoire » aux cellules qui ont la classe provisoire.
  2. Dans les cellules vides, écrire « n.d. » et ajouter la classe non-defini.
  3. Mettre la classe non-significatif aux cellules dont l’attribut title contient « non significatif ».
  4. Récupérer le contenu texte du lien ayant l’identifiant id-ligne-active. Ce contenu est l’identifiant de la ligne à laquelle vous devez mettre la classe class-ligne-active.
  5. A la place du code, mettre le nom de la région active dans le lien ayant l’identifiant id-ligne-active.

Astuce : Le sélecteur :empty capture les nœuds vides

  1. Dans les cellules qui ont la classe provisoire, ajouter le lien suivant :
<a href="#" title="Provisoire">(p)</a>
  1. Dans les cellules qui sont vides ou bien ne contiennent que des espaces, écrire «n.d.» et ajouter la classe non-defini
  2. Après le nom des départements qui comprennent des cellules non-définies, ajouter le lien suivant :
<a href="#" title="Incomplet">(i)</a>
  1. Dans le corps des tableaux, remplacer la première cellule de chaque ligne par une cellule de type «titre» (balise <th> au lieu de <td>).
  2. Trier chacun des tableaux selon l’ordre alphabétique des départements.

Astuce : La fonction $.trim() supprime les espaces superflus