Démarrage
Inclure jQuery
Incluez jQuery via un CDN pour un chargement rapide et mis en cache. La version minifiée (.min.js) est pour la production ; la version non compressée pour le débogage. Prévoyez toujours un repli local au cas où le CDN serait injoignable. Avec npm, vous pouvez importer jQuery comme module — pratique pour les bundlers comme Webpack/Vite. jQuery 3.7.x est la branche actuelle ; les vieux IE ne sont plus pris en charge.
<!-- Production (CDN, minified) -->
<script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>
<!-- Development (CDN, uncompressed) -->
<script src="https://code.jquery.com/jquery-3.7.1.js"></script>
<!-- Fallback: load local if CDN fails -->
<script>
window.jQuery || document.write(
'<script src="js/jquery-3.7.1.min.js"><\/script>'
)
</script>
<!-- npm install -->
<!-- npm install jquery -->Document Ready
Enveloppez le code manipulant le DOM dans $(document).ready() pour qu'il ne s'exécute qu'après l'analyse de l'arbre DOM (sans attendre les images). $(fn) est le raccourci. Si votre <script> est en fin de <body>, le DOM est déjà disponible et vous pouvez sauter ready. Le ready de jQuery ressemble à DOMContentLoaded — il se déclenche avant window.load (qui attend les images/iframes).
// run code after DOM is fully parsed
$(document).ready(function () {
console.log('DOM ready')
})
// shorter equivalent
$(function () {
console.log('DOM ready')
})
// modern preferred (no ready needed at end of body)
// <script> at the end of <body> runs after DOM exists
// pass a function to $ — jQuery treats it as ready handler
$(function () {
$('.btn').on('click', function () {
alert('clicked')
})
})L'objet jQuery ($)
$ n'est qu'un alias de jQuery — les deux fonctionnent identiquement. En tant que fonction, $ sélectionne des éléments (renvoie une collection jQuery). En tant que namespace, $.foo fournit des méthodes utilitaires. Si une autre bibliothèque emploie $, appelez $.noConflict() pour la libérer ; vous pouvez encore employer jQuery ou passer $ dans un callback ready pour l'aliaser localement.
// $ is an alias for jQuery
console.log($ === jQuery) // true
// $ as a function: select elements
$('p') // all paragraphs
$('#main') // element with id main
$('.btn.primary') // elements with class btn and primary
// $ as a namespace: utility methods
$.each([1, 2, 3], function (i, v) { console.log(i, v) })
$.extend({}, defaults, options)
$.type([]) // 'array'
// noConflict: release $ back to other libraries
$.noConflict()
jQuery(function ($) { /* $ available here */ })Chaînage de méthodes
La plupart des méthodes jQuery renvoient la même collection jQuery, on peut donc chaîner les appels — la fonctionnalité signature de jQuery. Utilisez .end() pour revenir à l'ensemble précédent après une méthode de traversée (.find(), .filter()). L'indentation rend les traversées chaînées lisibles. Évitez les chaînes trop longues — difficiles à déboguer. Pour les méthodes non chaînables (comme le getter .width()), la chaîne casse car elles renvoient une valeur, pas la collection.
// most methods return the jQuery object, enabling chains
$('.box')
.addClass('active')
.css('color', 'red')
.slideDown(300)
.text('Hello')
// break across lines for readability
$('#nav')
.find('.item')
.addClass('highlight')
.end()
.find('.link')
.attr('target', '_blank')
// .end() pops the current filter back to previous setMode no-conflict
$.noConflict() rend le contrôle de $ à la bibliothèque qui l'a défini en premier. Après l'appel, employez le nom complet jQuery, ou assignez jQuery à une variable personnalisée. Le pattern IIFE (function($){...})(jQuery) est la façon classique de garder $ comme alias local dans votre module tout en laissant le $ global aux autres bibliothèques — essentiel dans WordPress et les environnements anciens.
// release $ to other libraries (e.g., Prototype)
$.noConflict()
// use jQuery full name
jQuery('.btn').on('click', function () { /* ... */ })
// or assign jQuery to a custom alias
const jq = $.noConflict()
jq('.btn').hide()
// IIFE pattern: keep $ inside a local scope
(function ($) {
$('.btn').on('click', function () { /* ... */ })
})(jQuery)Sélecteurs
Sélecteurs de base
jQuery emploie les sélecteurs CSS (largement compatibles avec querySelectorAll). Le trio de base : nom de balise, #id, .class. La virgule combine des sélecteurs (union). #id est le plus rapide (passe par getElementById). L'universel * est lent — évitez-le sur les grands documents. Les résultats de sélection sont toujours une collection jQuery (façon tableau), même si 0 ou 1 élément correspond.
// element selector
$('div') // all <div> elements
$('p') // all <p> elements
// id selector
$('#header') // element with id="header"
// class selector
$('.btn') // all elements with class="btn"
$('.btn.primary') // .btn AND .primary
// multiple (comma = OR)
$('div, p, .btn') // divs, paragraphs, and .btn
// universal
$('*') // all elements (slow — avoid)Hiérarchie et combinateurs
Les combinateurs décrivent les relations : espace (descendant), > (enfant direct), + (frère adjacent), ~ (frère général). L'évaluation de droite à gauche signifie que $('ul li') trouve d'abord tous les <li>, puis filtre ceux à l'intérieur d'un <ul> — les sélecteurs précis à droite performent donc mieux. Évitez les combinateurs profonds sur d'énormes documents ; restreignez à un conteneur via $(container).find(...) pour de meilleures performances.
// descendant: space (any depth)
$('ul li') // <li> anywhere inside <ul>
// child: > (direct children only)
$('ul > li') // <li> directly inside <ul>
// adjacent sibling: + (immediately next)
$('h2 + p') // <p> right after <h2>
// general sibling: ~ (all following siblings)
$('h2 ~ p') // all <p> siblings after <h2>
// multiple levels
$('#nav .item > a span')Sélecteurs d'attribut
Les sélecteurs d'attribut visent les éléments par valeurs d'attribut : [attr] (présence), [attr=val] (exact), [attr^=val] (commence par), [attr$=val] (finit par), [attr*=val] (contient), [attr~=val] (mot). Citez les valeurs par sécurité. [attr!=val] est une extension propre à jQuery (employez .not('[attr=val]') pour la conformité CSS). Utile pour les formulaires (types d'input), les liens (motifs href) et les attributs data-*.
// has attribute
$('[href]') // any element with href
$('[data-id]') // any element with data-id
// exact value
$('[type="text"]') // type="text"
$('[href="https://example.com"]')
// substring matches
$('[href^="https"]') // starts with "https"
$('[href$=".pdf"]') // ends with ".pdf"
$('[href*="example"]') // contains "example"
// whitespace-separated word
$('[class~="active"]') // class contains word "active"
// inequality (jQuery extension, not CSS)
$('[href!="https://x.com"]')Sélecteurs de formulaires et inputs
Les pseudo-sélecteurs de formulaires (:input, :text, :checked, etc.) sont des extensions jQuery — hors CSS, ils ne peuvent donc pas employer le chemin rapide de querySelectorAll. Pour la performance sur de grands formulaires, employez $('input[type=text]') plutôt que $(':text'). :checked et :selected sont essentiels pour lire l'état des formulaires. Ils sont dynamiques — réévalués à chaque accès.
// :input matches all form controls
$(':input') // input, textarea, select, button
// by type
$(':text') // <input type="text">
$(':password')
$(':checkbox')
$(':radio')
$(':submit')
$(':file')
// by state
$(':checked') // checked checkbox/radio or selected option
$(':selected') // selected <option>
$(':disabled')
$(':enabled')
$(':focus')
// combined with class
$('input.required:visible')Sélecteurs de filtre et de contenu
Les filtres resserrent une sélection : :first/:last, :even/:odd (indexés à 0), :eq(n), :gt(n), :lt(n). Les filtres de contenu (:contains, :has, :empty, :parent) matchent selon le contenu. :visible et :hidden s'appuient sur offsetWidth/Height et le CSS (note : les éléments visibility:hidden sont :hidden dans jQuery 3+ ; ils étaient auparavant :visible). Beaucoup sont des extensions jQuery — préférez les méthodes .filter(), .first(), .eq() pour de meilleures performances.
// basic filters
$('li:first') // first <li>
$('li:last') // last <li>
$('li:even') // even-indexed (0, 2, 4...)
$('li:odd') // odd-indexed
$('li:eq(2)') // 3rd <li> (0-indexed)
$('li:gt(2)') // <li> after index 2
$('li:lt(2)') // <li> before index 2
// content filters
$('div:contains("Hello")') // divs containing text "Hello"
$('div:empty') // divs with no children
$('div:has(p)') // divs containing <p>
$('div:parent') // divs that have children
// visibility
$(':visible')
$(':hidden')Événements
Lier des événements avec .on()
.on() est le lieur d'événements moderne et universel (remplaçant .bind/.delegate/.live). Passez le(s) nom(s) d'événement et un handler. 'this' dans le handler est l'élément DOM brut (pas enveloppé jQuery — enveloppez avec $(this) si besoin). Employez les namespaces d'événements (click.myapp) pour délier des handlers précis sans toucher aux autres. Plusieurs événements peuvent partager un handler (séparés par espaces) ou avoir des handlers distincts (forme objet).
// basic binding
$('.btn').on('click', function (e) {
console.log('clicked!', this) // 'this' is the DOM element
})
// multiple events, same handler
$('.box').on('mouseenter mouseleave', function () {
$(this).toggleClass('hover')
})
// multiple events, different handlers
$('.input').on({
focus: function () { $(this).addClass('focused') },
blur: function () { $(this).removeClass('focused') }
})
// named events (for targeted unbinding)
$('.btn').on('click.myapp', handler)
$('.btn').off('click.myapp') // only removes this oneDélégation d'événements
La délégation lie un handler à un parent qui capte les événements des enfants par bubbling. Le second sélecteur de .on() ('li') filtre quels enfants déclenchent le handler. Bénéfices : un handler au lieu de N, support automatique des éléments ajoutés dynamiquement, moins de mémoire. Essentiel pour les longues listes et les SPA. 'this' est l'enfant matché (le li), pas le parent. Employez e.delegateTarget pour accéder au parent.
// delegate: handle events on children, now or future
$('#list').on('click', 'li', function (e) {
// 'this' is the <li> that was clicked
$(this).toggleClass('done')
})
// works for <li> added AFTER binding too
$('#list').append('<li>New item (also clickable)</li>')
// WHY: instead of binding to each <li>,
// bind ONCE to the parent; clicks bubble up
// - 1 handler instead of N
// - works for dynamically added elements
// - lower memory, faster setupObjet événement et méthodes
L'objet événement (e) porte les infos et les méthodes de contrôle. preventDefault stoppe le comportement par défaut du navigateur (navigation de lien, envoi de formulaire). stopPropagation stoppe le bubbling ; stopImmediatePropagation stoppe aussi les autres handlers du même élément. e.target est l'élément réellement cliqué (peut être un enfant) ; e.currentTarget est l'élément porteur du handler (= this). Passez des données aux handlers via le second argument optionnel de .on().
$('.link').on('click', function (e) {
e.preventDefault() // stop default action (e.g., navigation)
e.stopPropagation() // stop bubbling to parents
e.stopImmediatePropagation() // stop other handlers on same element
console.log(e.type) // 'click'
console.log(e.target) // the actual clicked element
console.log(e.currentTarget) // the element with the handler (= this)
console.log(e.which) // mouse button or key code
console.log(e.pageX, e.pageY) // mouse coordinates
// data passed via .on(name, data, handler)
})
$('.btn').on('click', { greeting: 'hi' }, function (e) {
console.log(e.data.greeting) // 'hi'
})Méthodes d'événements raccourcies
Les méthodes raccourcies (.click, .focus, .submit, etc.) lient un handler quand appelées avec une fonction, ou déclenchent l'événement quand appelées sans. .hover(enter, leave) est une commodité pour mouseenter+mouseleave. Elles équivalent à .on('event', fn) mais plus courtes. Certains raccourcis (.load, .error) ont été retirés dans jQuery 3 — employez .on('load', ...) à la place. Préférez .on() pour le code neuf ; plus explicite et gère la délégation.
// shorthand: bind a handler (or trigger if no handler)
$('.btn').click(function () { /* ... */ })
$('.btn').click() // trigger click
// common shorthands
$('.box').hover(enterFn, leaveFn) // mouseenter + mouseleave
$('.input').focus(function () { /* ... */ })
$('.input').blur(function () { /* ... */ })
$('.form').submit(function (e) {
e.preventDefault()
/* ... */
})
$('.el').mouseenter(fn).mouseleave(fn).mousemove(fn)
$(window).resize(fn).scroll(fn)
// deprecated: .load(), .unload(), .error() (removed in jQuery 3)Déclencher et événements uniques
.trigger('event') déclenche les handlers ET le comportement natif (ex. navigation) ; .triggerHandler() ne déclenche que les handlers liés par jQuery et renvoie la valeur de retour du handler (non chaînable). .one() lie un handler qui se retire automatiquement après le premier appel — parfait pour des indications au premier clic, une configuration ponctuelle. Les événements personnalisés font dialoguer les composants : $(document).trigger('myapp:ready') et les écouteurs s'abonnent avec .on('myapp:ready', fn).
// trigger an event programmatically
$('.btn').trigger('click')
$('.btn').click() // shorthand
// trigger with extra data
$('.box').trigger('custom', [1, 2, 3])
// custom events
$('.box').on('custom', function (e, a, b, c) {
console.log(a, b, c) // 1 2 3
})
// fire handler only once
$('.btn').one('click', function () {
alert('This fires only once')
})
// trigger only native handlers, not custom
$('.link').triggerHandler('click')Manipulation du DOM
Lire et écrire le contenu
.html() travaille avec du balisage HTML (comme innerHTML) — les balises sont parsées. .text() sert au texte brut — les balises sont échappées et montrées littéralement (plus sûr contre le XSS pour les entrées utilisateur). .val() sert aux contrôles de formulaire (input, select, textarea). Les trois sont getters (renvoient la valeur du premier élément) sans argument, et setters (s'appliquent à tous les éléments matchés) avec argument. Les setters acceptent un callback (index, oldValue) => newValue.
// .html(): get or set HTML content
$('#box').html() // get innerHTML
$('#box').html('<p>Hello</p>') // set innerHTML
// .text(): get or set text (HTML-escaped)
$('#box').text() // get text content
$('#box').text('<p>Not parsed</p>') // displays literally
// setter with callback (index, old value)
$('p').text(function (i, oldText) {
return i + ': ' + oldText
})
// .val(): form value
$('input').val() // get
$('input').val('new value') // set
$('select').val() // get selected value
$('select').val(['a', 'b']) // multi-selectInsérer des éléments
Créez des éléments en passant du HTML à $(): $('<div class="x">...</div>'). Append/prepend insèrent à l'intérieur (à la fin/au début) ; before/after à l'extérieur (comme frères). Les variantes 'To' (appendTo, prependTo, insertBefore, insertAfter) renversent le sujet — pratique pour chaîner sur le nouvel élément. Les éléments nouvellement insérés héritent des handlers si liés par délégation, mais pas si liés directement avant l'insertion.
// create new element
const $li = $('<li class="item">New item</li>')
// add as last child of each matched element
$('ul').append($li)
$('ul').append('<li>Direct string</li>')
// add as first child
$('ul').prepend('<li>First</li>')
// insert before/after matched elements
$('.box').before('<hr>')
$('.box').after('<hr>')
// reverse direction (insert target into container)
$('<p>Hi</p>').appendTo('#main') // same as $('#main').append(...)
$('<p>Hi</p>').insertBefore('#nav')Retirer et remplacer
.remove() supprime les éléments et nettoie leurs données/événements. .detach() retire du DOM mais préserve données/événements — utile pour déplacer temporairement des éléments. .empty() vide les enfants mais garde l'élément. .replaceWith() échange chaque élément avec un nouveau contenu. .unwrap() retire le parent, remontant l'élément. Employez toujours .remove() ou .detach() — jamais un simple .html('') sur un parent, qui fuit les données/événements des enfants.
// remove element (and its data + events)
$('.box').remove()
// detach: remove but keep events/data (for re-insertion)
const $el = $('.box').detach()
// ... later
$('body').append($el) // events still work
// empty: remove all children (keep element)
$('.box').empty()
// replace with new content
$('.old').replaceWith('<div class="new">New</div>')
// unwrap: remove parent (keep element)
$('.box').unwrap()Envelopper et cloner
.wrap() enveloppe chaque élément individuellement ; .wrapAll() enveloppe tout l'ensemble comme un groupe ; .wrapInner() enveloppe le contenu (pas l'élément lui-même). .clone() crée une copie profonde — passez true pour cloner aussi les handlers d'événements et les données (défaut false, donc les handlers ne se déclenchent pas sur la copie). .unwrap() retire le parent immédiat. Puissant pour restructurer le balisage sans réécrire des chaînes HTML.
// wrap each element in a structure
$('p').wrap('<div class="wrapper"></div>')
// each <p> becomes <div class="wrapper"><p>...</p></div>
// wrap all matched elements together
$('p').wrapAll('<div class="all"></div>')
// wrap inner contents
$('p').wrapInner('<span></span>')
// <p><span>...</span></p>
// clone (with events)
const $copy = $('.box').clone(true) // true = clone events too
$('body').append($copy)
// unwrap (remove wrapper)
$('.box').unwrap()Itérer et filtrer
.each() itère — 'this' est l'élément DOM brut ; renvoyez false pour casser, autre chose pour continuer. .map() transforme en une nouvelle collection jQuery ; appelez .get() pour convertir en tableau ordinaire. .filter() resserre par sélecteur ou callback ; .not() est l'inverse. .is() renvoie un booléen (un élément correspond-t-il ?) — utile dans les conditionnels. Évitez les boucles for avec .eq(i) ; employez .each() ou .map() pour un jQuery idiomatique.
// .each: iterate (this = DOM element, i = index)
$('li').each(function (i, el) {
console.log(i, this, el) // el === this
if (i === 2) return false // break
// return true to continue
})
// .map: transform to new array
const ids = $('li').map(function (i, el) {
return $(el).data('id')
}).get() // .get() converts to plain array
// .filter: keep matching
$('li').filter('.active').addClass('on')
$('li').filter(function (i) { return i % 2 === 0 })
// .not: remove matching
$('li').not('.active').addClass('off')
// .is: returns boolean (does ANY match?)
if ($('li').is('.active')) { /* at least one is active */ }Manipulation du CSS
Lire et écrire les propriétés CSS
.css() lit les styles calculés (toujours la valeur résolue, même issue des règles CSS) ou écrit des styles inline. Pour les getters, passez un seul nom de propriété (renvoie une chaîne). Pour les setters, passez (prop, value) ou un objet de paires prop:valeur. Les noms de propriétés peuvent être camelCase ou kebab-case (ce dernier exige des guillemets). Les valeurs numériques valent des pixels pour la plupart des propriétés. Évitez .css() pour la mise en page — employez classes et feuilles de style pour la maintenabilité.
// get computed style (first matched element)
$('.box').css('color') // 'rgb(255, 0, 0)'
$('.box').css('font-size') // '14px'
// set single property
$('.box').css('color', 'red')
// set multiple properties
$('.box').css({
color: 'red',
'background-color': '#eee', // kebab-case needs quotes
fontSize: '16px', // or use camelCase
marginTop: '10px'
})
// setter with callback (index, old value)
$('div').css('width', function (i, old) {
return (parseInt(old) + 50) + 'px'
})Manipulation des classes
Les méthodes de classes sont la façon préférée de styler les éléments — elles gardent la présentation en CSS, pas en JS. .addClass, .removeClass, .toggleClass acceptent des listes de classes séparées par des espaces. .toggleClass(name, bool) ajoute/retire selon le booléen — utile pour une UI pilotée par l'état. .hasClass(name) renvoie un booléen (ne vérifie que le premier élément). Côté perf, les classes sont bien plus rapides que .css() pour un style non trivial : elles groupent les changements et laissent le navigateur optimiser.
// add class
$('.box').addClass('active')
// remove class
$('.box').removeClass('active')
// toggle (add if absent, remove if present)
$('.box').toggleClass('active')
// toggle based on boolean
$('.box').toggleClass('active', isValid)
// add/remove multiple (space-separated)
$('.box').addClass('active highlighted urgent')
$('.box').removeClass('active highlighted')
// check if has class (boolean)
if ($('.box').hasClass('active')) { /* ... */ }
// callback form (index, hasClass)
$('div').toggleClass('even', function (i) {
return i % 2 === 0
})Largeur et hauteur
.width()/.height() = boîte de contenu (sans padding/bordure). .innerWidth()/.innerHeight() = contenu + padding. .outerWidth()/.outerHeight() = contenu + padding + bordure. .outerWidth(true) inclut la marge. Les setters prennent un nombre (px) ou une chaîne. Pour window/document, employez $(window) pour la fenêtre d'affichage et $(document) pour la page entière. Elles renvoient des nombres (pas des chaînes comme .css('width')), pratique pour les calculs.
// content size (excludes padding, border, margin)
$('.box').width() // e.g., 200
$('.box').width(300) // set content width to 300px
$('.box').height()
// inner (content + padding)
$('.box').innerWidth()
$('.box').innerHeight()
// outer (content + padding + border)
$('.box').outerWidth()
$('.box').outerHeight()
// outer including margin
$('.box').outerWidth(true)
// window & document
$(window).width() // viewport width
$(document).height() // full document heightPosition et offset
.offset() renvoie {top, left} relatif au document (utile pour le positionnement absolu ou le drag-drop). .position() renvoie les coordonnées relatives au parent de positionnement (l'ancêtre le plus proche avec position: relative/absolute/fixed). .scrollTop()/.scrollLeft() lisent ou règlent la position de défilement — $(window).scrollTop(0) remonte en haut. .offsetParent() trouve l'ancêtre positionné. Essentiel pour les animations, drag-drop et défilement infini.
// .offset(): position relative to document
const off = $('.box').offset()
console.log(off.left, off.top) // e.g., 100, 50
$('.box').offset({ top: 200, left: 100 }) // set
// .position(): position relative to offset parent
const pos = $('.box').position()
console.log(pos.left, pos.top)
// .scrollTop() / .scrollLeft(): scroll position
$(window).scrollTop() // how far scrolled down
$(window).scrollTop(0) // scroll to top
$('.container').scrollTop(100)
// .offsetParent(): nearest positioned ancestor
$('.box').offsetParent()Défilement et coordonnées
La gestion du défilement est courante pour les navs épinglées, le défilement infini et les animations déclenchées au scroll. $('html, body').animate({scrollTop: n}) défile en douceur. Pour la perf, étranglez les handlers de scroll (ils se déclenchent très souvent). Le helper isVisible vérifie si un élément est dans la fenêtre d'affichage — utile pour le lazy-loading d'images ou le déclenchement d'animations. IntersectionObserver moderne est plus efficace pour la détection de visibilité ; envisagez-le pour les nouveaux projets.
// scroll to top smoothly
$('html, body').animate({ scrollTop: 0 }, 500)
// scroll to an element
const top = $('#section').offset().top
$('html, body').animate({ scrollTop: top }, 500)
// detect scroll position
$(window).on('scroll', function () {
const scrolled = $(window).scrollTop()
if (scrolled > 100) {
$('.nav').addClass('fixed')
} else {
$('.nav').removeClass('fixed')
}
})
// check if element is in viewport
function isVisible($el) {
const t = $el.offset().top
const h = $el.outerHeight()
const wTop = $(window).scrollTop()
const wH = $(window).height()
return t >= wTop && (t + h) <= (wTop + wH)
}AJAX
$.ajax (contrôle total)
$.ajax est la méthode bas niveau à contrôle total. method/verbe http, data (envoyé en query pour GET ou corps pour POST), dataType indice la réponse attendue (parsée automatiquement). success/error/complete sont les hooks de callback historiques. beforeSend permet de modifier le xhr (ajouter des en-têtes). timeout abandonne après N ms. Pour le code moderne, préférez fetch() ou $.ajax avec les promises .done()/.fail() au lieu des callbacks success/error.
$.ajax({
url: '/api/users',
method: 'GET', // or 'POST', 'PUT', 'DELETE'
data: { page: 1, limit: 10 }, // query string or body
dataType: 'json', // expected response type
contentType: 'application/json',
timeout: 5000, // ms
headers: { 'X-Token': 'abc' },
beforeSend: function (xhr) { /* ... */ },
success: function (data, status, xhr) {
console.log('got', data)
},
error: function (xhr, status, error) {
console.error('failed', status, error)
},
complete: function (xhr, status) {
// runs on both success and error
}
})Raccourcis : $.get et $.post
$.get et $.post sont des raccourcis pour des requêtes GET/POST simples. L'interface façon promise (.done/.fail/.always) est plus propre que les callbacks success/error — et gère le chaînage de plusieurs handlers .done. Pour des corps de requête JSON, il faut régler contentType: 'application/json' ET sérialiser les données avec JSON.stringify (jQuery ne stringify pas les objets en JSON automatiquement). Note : la promise de jQuery est un Deferred, pas une Promise native, mais fonctionne de façon semblable dans la plupart des cas.
// GET request
$.get('/api/users', { page: 1 }, function (data) {
console.log(data)
}, 'json')
// promise-based (preferred)
$.get('/api/users', { page: 1 })
.done(function (data) { console.log(data) })
.fail(function (xhr, status, err) { console.error(err) })
// POST request
$.post('/api/users', { name: 'Alice' })
.done(function (data) { /* created */ })
// POST JSON
$.ajax({
url: '/api/users',
method: 'POST',
contentType: 'application/json',
data: JSON.stringify({ name: 'Alice' })
})Charger du HTML dans des éléments
.load() est un raccourci spécialisé : récupère le HTML d'une URL et l'injecte dans les éléments matchés. La syntaxe 'url #fragment' ne charge qu'une portion de la réponse (la partie correspondant à #fragment). .load() est parfait pour des mises à jour partielles sans rechargement complet — courant dans les SPA anciennes. GET par défaut, POST si vous passez des données. Le callback reçoit (responseText, status, xhr). Pour les apps modernes, fetch + mise à jour manuelle du DOM est préférée.
<!-- load HTML from server into element -->
<div id="content">Loading...</div>
<script>
$('#content').load('/partials/header.html')
// load a fragment (selector after URL space)
$('#content').load('/page.html #main')
// with callback (response, status, xhr)
$('#content').load('/page.html', function (resp, status, xhr) {
if (status === 'error') {
$('#content').html('Failed to load')
}
})
// POST with data
$('#content').load('/api', { id: 5 })
</script>getJSON et getScript
$.getJSON est un raccourci de $.ajax avec dataType:'json' — parse automatiquement la réponse. L'astuce '?callback=?' active le JSONP pour les requêtes cross-domain (héritage — employez CORS désormais). $.getScript récupère et exécute un fichier JavaScript — utile pour charger à la demande des plugins ou de l'analytique. Les deux renvoient des objets jqXHR (façon promise). Pour les requêtes cross-domain aujourd'hui, assurez-vous que le serveur envoie les en-têtes CORS ; le JSONP est une parade pré-CORS avec des réserves de sécurité.
// fetch and parse JSON
$.getJSON('/api/users', { page: 1 })
.done(function (data) {
console.log(data.users)
})
.fail(function (xhr, status, err) {
console.error('JSON fetch failed:', err)
})
// fetch and execute a script
$.getScript('/js/analytics.js')
.done(function (script, status) {
console.log('analytics loaded')
// script is now available
})
.fail(function () {
console.error('script failed')
})
// JSONP (cross-domain, legacy)
$.getJSON('https://api.example.com/data?callback=?')
.done(function (data) { /* ... */ })Événements AJAX globaux et config
Les événements AJAX globaux (ajaxStart, ajaxStop, ajaxComplete, ajaxError, ajaxSuccess) se déclenchent pour chaque requête AJAX — parfait pour les loaders globaux et la gestion d'erreurs. $.ajaxSetup fixe les défauts appliqués à tous les appels AJAX suivants (base d'URL, en-têtes, timeout). .serialize() transforme un formulaire en query string ; .serializeArray() renvoie un tableau d'objets {name, value} — utile pour construire du JSON ou des charges personnalisées. Incluez toujours un token CSRF pour les requêtes qui modifient l'état.
// global ajax event handlers (bind on document)
$(document)
.ajaxStart(function () { $('#loader').show() })
.ajaxStop(function () { $('#loader').hide() })
.ajaxError(function (e, xhr, settings, error) {
console.error('AJAX error:', settings.url, error)
})
// default settings for all AJAX
$.ajaxSetup({
baseURL: '/api',
timeout: 10000,
headers: { 'X-CSRF-Token': $('meta[name=csrf]').attr('content') }
})
// now $.get('/users') -> GET /api/users with the headers
$.get('/users').done(/* ... */)
// serialize a form for AJAX
const data = $('form').serialize() // "name=Alice&age=30"
const arr = $('form').serializeArray() // [{name, value}, ...]Effets et animations
Show/Hide de base
.show()/.hide()/.toggle() changent le display. Sans arguments, affichage/masquage instantanés. Avec une durée, animation de width/height/opacity. 'slow' = 600 ms, 'fast' = 200 ms, ou un nombre en ms. Le callback se déclenche à la fin de l'animation. Les animations jQuery emploient requestAnimationFrame par défaut (sans à-coups). Note : .hide() met display:none ; .show() restaure la valeur d'affichage d'origine. Pour plus de contrôle, employez .animate() directement.
// instantly show/hide/toggle
$('.box').show()
$('.box').hide()
$('.box').toggle()
// animated (duration in ms or 'slow'/'fast')
$('.box').show(400) // fade in over 400ms
$('.box').hide('slow') // ~600ms
$('.box').toggle(300)
// with callback (runs when animation completes)
$('.box').hide(300, function () {
console.log('hidden')
})
// easing (default 'swing', also 'linear' with plugin)
$('.box').hide({ duration: 300, easing: 'linear' })Fondu
Les animations de fondu ne changent que l'opacité (le display reste). .fadeTo( anime vers une opacité précise — utile pour estomper des éléments sans les masquer entièrement. Les animations se mettent en file par élément : chaîner .fadeOut().fadeIn() les exécute séquentiellement, pas simultanément. Pour du parallèle, employez .animate() avec plusieurs propriétés ou l'option queue. Le fondu est plus fluide que show/hide pour une UI pilotée par l'opacité comme les notifications.
// fade in / out / toggle (opacity only)
$('.box').fadeIn(400)
$('.box').fadeOut(400)
$('.box').fadeToggle(400)
// fade to a specific opacity (0.0 - 1.0)
$('.box').fadeTo(400, 0.5) // 50% opacity
// with callback
$('.box').fadeOut(300, function () {
// runs after fade out completes
$(this).remove()
})
// sequence: fade out, then fade in
$('.box')
.fadeOut(300)
.fadeIn(300) // queued automaticallyGlissement
Le glissement anime la hauteur (et le display). .slideDown révèle un élément (de display:none à sa hauteur naturelle), .slideUp le masque (se referme à 0 puis display:none), .slideToggle inverse l'état. Parfait pour accordéons, menus déroulants et panneaux repliables. Combiné avec siblings() pour le comportement accordéon (fermer les autres quand l'un s'ouvre). Le glissement est l'animation jQuery la plus courante — fluide et accessible quand on l'associe à un ARIA correct.
// slide down (reveal) / up (hide) / toggle
$('.panel').slideDown(400)
$('.panel').slideUp(400)
$('.panel').slideToggle(400)
// accordion pattern
$('.accordion .header').on('click', function () {
$(this).next('.content').slideToggle(300)
.siblings('.content').slideUp(300)
})
// callback after slide completes
$('.panel').slideUp(300, function () {
console.log('panel closed')
}).animate() personnalisé
.animate() interpole des propriétés CSS numériques sur une durée. Employez les valeurs relatives ('+=50') pour des changements incrémentaux. Les noms de propriétés doivent être en camelCase (marginLeft, pas margin-left). Les couleurs exigent le plugin jQuery Color ou jQuery UI — le cœur de jQuery n'anime que des nombres. La forme options donne plus de contrôle : queue:false exécute en parallèle au lieu de séquentiel. L'easing par défaut est 'swing' (ease-out) ; 'linear' est uniforme. Plusieurs propriétés peuvent s'animer en un appel.
// animate numeric CSS properties
$('.box').animate({
width: '+=50', // relative: add 50px
height: '300px',
opacity: 0.5,
marginLeft: '20px', // camelCase for hyphenated props
fontSize: '20px'
}, 800, 'swing', function () {
console.log('animation done')
})
// options object form
$('.box').animate({
left: 500
}, {
duration: 1000,
easing: 'linear',
complete: function () { /* done */ },
queue: false // run immediately, not queued
})
// NOTE: colors can't be animated without jQuery UI / color pluginArrêter et chaîner
.stop() interrompt les animations ; (clearQueue, jumpToEnd) donne le contrôle. Sans stop, les survols rapides empilent les animations (l'élément continue d'animer longtemps après le départ de la souris) — .stop(true) avant .animate() prévient cela. .finish() saute toutes les animations en file à leur état final instantanément. .delay(ms) insère une pause dans la file d'animation — utile pour séquencer. Associez toujours les animations de survol à .stop() pour éviter un empilement saccadé.
// .stop(): stop current animation
$('.box').stop() // stop, leave at current state
$('.box').stop(true) // clear queue too
$('.box').stop(true, true) // clear queue AND jump to end
// prevent animation buildup on rapid hover
$('.box').hover(function () {
$(this).stop(true).animate({ width: 300 }, 200)
}, function () {
$(this).stop(true).animate({ width: 100 }, 200)
})
// .finish(): jump all queued animations to end state
$('.box').finish()
// .delay(): pause between queued animations
$('.box')
.fadeOut(300)
.delay(500) // wait 500ms
.fadeIn(300)Traversée
Monter (parents)
Traverser vers le haut : .parent() (parent immédiat), .parents() (tous les ancêtres jusqu'au document), .parents(selector) les filtre, .closest(selector) remonte et renvoie le premier match (soi inclus — le plus courant pour trouver un composant englobant). .parentsUntil(selector) renvoie les ancêtres jusqu'au match exclu. .closest() est le cheval de trait des patterns de délégation d'événements — partant d'un élément cliqué, trouver sa carte/ligne/composant englobant.
// direct parent
$('#item').parent()
// all ancestors (up to <html> or selector)
$('#item').parents() // all ancestors
$('#item').parents('.container') // first .container ancestor
// closest ancestor (incl. self) matching selector
$('#item').closest('.box') // very common - find enclosing box
// parentsUntil: ancestors up to (not including) match
$('#item').parentsUntil('.wrapper')
// offsetParent: nearest positioned ancestor
$('#item').offsetParent()Descendre (enfants)
.children() ne renvoie que les enfants directs (un niveau en dessous) ; .find() descend sur tous les niveaux. .find() est la plus courante — partant d'un conteneur, trouver les descendants correspondants (ex. tous les champs d'un formulaire). .children() est plus rapide quand seuls les enfants directs sont nécessaires. .contents() inclut les nœuds texte et commentaire (utile pour traiter du texte ou des iframes). Filtrez les deux avec un sélecteur. Restreignez toujours les traversées avec .find() pour éviter de scanner tout le document.
// direct children (optionally filtered)
$('#list').children() // all direct children
$('#list').children('.item') // direct children with class .item
// all descendants (filtered)
$('#list').find('li') // all <li> anywhere inside
$('#list').find('.active') // all .active descendants
// contents: children including text/comment nodes
$('#box').contents()
// first/last child
$('#list').children().first()
$('#list').children().last()Aller sur le côté (frères)
Traversées latérales : .siblings() (tous), .next()/.prev() (immédiats), .nextAll()/.prevAll() (tous dans un sens), .nextUntil()/.prevUntil() (jusqu'à un match). Filtrez avec un sélecteur. Le pattern classique de l'onglet actif ($(this).addClass('active').siblings().removeClass('active')) emploie siblings pour réinitialiser l'état des frères. Les frères partagent le même parent — si les éléments sont imbriqués autrement, ils ne sont pas frères.
// all siblings (excluding self)
$('#item').siblings()
$('#item').siblings('.active') // siblings with class .active
// next/prev: immediate sibling
$('#item').next()
$('#item').prev()
// nextAll/prevAll: all following/preceding siblings
$('#item').nextAll()
$('#item').prevAll('.item')
// nextUntil/prevUntil: siblings up to a match
$('#item').nextUntil('.stop')
// common: highlight active tab
$('.tab').on('click', function () {
$(this).addClass('active').siblings().removeClass('active')
})Filtrer une sélection
Le filtrage resserre l'ensemble courant sans re-interroger le DOM. .filter(selector) garde les matchs ; .not(selector) est l'inverse. .has(selector) garde les éléments contenant un descendant correspondant. .eq(n) réduit à un élément (n négatif compte depuis la fin). .first()/.last() sont des commodités. .slice(start, end) prend une plage. Employez-les pour affiner une sélection après traversée au lieu d'écrire des sélecteurs complexes — souvent plus clair et plus rapide.
// .filter: keep matching
$('li').filter('.active')
$('li').filter(function (i) { return i % 2 === 0 }) // even index
// .not: remove matching (inverse of filter)
$('li').not('.active')
$('li').not(':first')
// .has: keep elements that contain a descendant
$('div').has('p') // divs that contain <p>
// .eq: reduce to one element by index
$('li').eq(2) // 3rd <li> (0-indexed)
$('li').eq(-1) // last <li>
// .first / .last
$('li').first()
$('li').last()
// .slice: range
$('li').slice(2, 5) // indices 2, 3, 4Chaîner avec .end() et .addBack()
.end() dépile la pile de traversée, revenant à l'ensemble précédent — essentiel pour des chaînes lisibles qui traversent puis continuent sur l'original. .addBack() (ex-.andSelf) fusionne l'ensemble courant avec le précédent, faisant participer l'élément d'origine aux opérations suivantes. Cela permet des chaînes d'une ligne puissantes : trouver les enfants, les modifier, end() vers le parent, modifier le parent. Indentez les chaînes pour rendre la structure de traversée claire.
// .end(): pop back to previous set after a traversal
$('ul') // [ul]
.find('li') // [li, li, li]
.addClass('item')
.end() // back to [ul]
.addClass('has-items')
// .addBack(): include previous set in current
$('ul')
.children('li') // [li, li]
.addClass('item')
.addBack() // [li, li, ul]
.addClass('related')
// without .addBack, the ul would not get .related
// .andSelf (old name) is deprecated, use .addBackFonctions utilitaires
Itération : $.each et $.map
$.each itère les tableaux (index, valeur) ou objets (clé, valeur) — notez l'ordre des arguments inversé face à Array.forEach. Renvoyez false pour casser. $.map transforme chaque item en un nouveau tableau (renvoyez null pour sauter). $.grep filtre un tableau. Ce sont les utilitaires d'itération d'avant ES5 de jQuery ; le code moderne emploie souvent les méthodes Array natives (forEach, map, filter). La principale raison d'employer $.each est l'itération d'objets simples (Object.entries en JS moderne).
// $.each: iterate arrays or objects (returns the collection)
$.each([10, 20, 30], function (index, value) {
console.log(index, value) // 0 10, 1 20, 2 30
if (value === 20) return false // break
})
$.each({ a: 1, b: 2 }, function (key, value) {
console.log(key, value) // 'a' 1, 'b' 2
})
// $.map: transform to a new array
const doubled = $.map([1, 2, 3], function (value, index) {
return value * 2 // [2, 4, 6]
})
// return null/undefined to skip
const evens = $.map([1, 2, 3, 4], function (v) {
return v % 2 === 0 ? v : null // [2, 4]
})
// $.grep: filter an array
const evens = $.grep([1, 2, 3, 4], function (v) { return v % 2 === 0 })
// [2, 4]Vérification de types
$.type renvoie une chaîne de type en minuscules (plus fine que typeof). $.isArray, $.isFunction, $.isPlainObject, $.isEmptyObject, $.isWindow, $.isNumeric sont des booléens de commodité. $.isPlainObject distingue les {} simples des instances comme new Date ou window. $.isNumeric renvoie true pour les nombres finis et chaînes numériques (pas pour l'hexa comme '0x1F' dans les jQuery récents). En JS moderne, Array.isArray et typeof couvrent la plupart des besoins, mais $.isPlainObject reste pratique pour la sécurité du deep-extend.
// $.type: detailed type
$.type([]) // 'array'
$.type({}) // 'object'
$.type('hi') // 'string'
$.type(null) // 'null'
$.type(undefined) // 'undefined'
$.type(/regex/) // 'regexp'
// specific checks (all return boolean)
$.isArray([]) // true
$.isFunction(fn => {}) // true
$.isEmptyObject({}) // true
$.isPlainObject({}) // true (created by {} or new Object)
$.isPlainObject([]) // false
$.isWindow(window) // true
$.isNumeric('42') // true (also '0x1F')
$.isNumeric('abc') // false
// $.isEmptyObject: no own enumerable props
$.isEmptyObject({ a: 1 }) // falseUtilitaires objets et tableaux
$.extend fusionne des objets — les propriétés suivantes l'emportent sur les précédentes. Passez true en premier argument pour une fusion profonde (récursive) ; sinon c'est superficielle. Passez toujours {} en premier argument pour ne pas muter la source. $.merge concatène des tableaux (mute le premier). $.inArray est indexOf (renvoie -1 si introuvable). $.makeArray convertit les objets façon tableau (NodeList, arguments) en vrais tableaux — le code moderne emploie Array.from ou le spread [...nl] à la place.
// $.extend: merge objects (mutates first unless deep copy flag)
const defaults = { a: 1, b: 2 }
const options = { b: 3, c: 4 }
const merged = $.extend({}, defaults, options)
// { a: 1, b: 3, c: 4 } (later overrides earlier)
// deep merge (recurses into nested objects)
const deep = $.extend(true, {},
{ nested: { x: 1, y: 2 } },
{ nested: { y: 3, z: 4 } }
)
// { nested: { x: 1, y: 3, z: 4 } }
// $.merge: combine two arrays (mutates first)
const combined = $.merge([1, 2], [3, 4]) // [1, 2, 3, 4]
// $.inArray: find index (-1 if not found)
const idx = $.inArray(2, [1, 2, 3]) // 1
// $.makeArray: convert array-like to true array
const arr = $.makeArray(document.querySelectorAll('li'))Utilitaires chaînes et données
$.trim retire les espaces (moderne : str.trim()). $.parseHTML convertit une chaîne HTML en tableau de nœuds DOM — plus sûr que $.fn.html pour les entrées non fiables (évite l'exécution de scripts). $.param sérialise un objet en query string (inverse du parse). $.now vaut Date.now(). $.unique déduplique les tableaux d'éléments DOM (rarement nécessaire aujourd'hui). La plupart ont des équivalents natifs modernes ; les plus utiles restants sont $.param (pour les données AJAX) et $.parseHTML.
// $.trim: remove leading/trailing whitespace
$.trim(' hello ') // 'hello' (use str.trim() in modern code)
// $.parseHTML: parse string to DOM nodes
const nodes = $.parseHTML('<div><p>Hi</p></div>')
// [div] — array of DOM nodes
// $.parseJSON: parse JSON string (use JSON.parse instead)
const obj = $.parseJSON('{"a":1}')
// $.param: serialize object to query string
$.param({ name: 'Alice', age: 30 })
// 'name=Alice&age=30'
$.param({ tags: ['a', 'b'] })
// 'tags%5B%5D=a&tags%5B%5D=b'
// $.now: current timestamp (Date.now equivalent)
$.now() // 1700000000000
// $.unique: remove duplicates from DOM element array
$.unique($('.box').get())Stockage de données ($.data)
$.data / .data() stocke des valeurs arbitraires associées aux éléments dans un cache interne (invisible dans le DOM, plus rapide que les attributs). .data() lit aussi automatiquement les attributs data-* (avec conversion de type : nombres, booléens, JSON). Important : .data(name, value) écrit dans le cache, PAS dans l'attribut data-* — employez .attr('data-name', val) pour mettre à jour l'attribut lui-même. .removeData vide l'entrée du cache. Le cache se nettoie quand les éléments sont .remove()'s, prévenant les fuites.
// store data on an element (private, won't appear in DOM)
$.data(document.getElementById('box'), 'key', { count: 1 })
// read it back
const v = $.data(el, 'key') // { count: 1 }
//.data() method form (more common)
$('.box').data('key', { count: 1 })
$('.box').data('key') // { count: 1 }
// auto-parses data-* attributes
// <div class="box" data-id="42" data-name="alice"></div>
$('.box').data('id') // 42 (auto-cast to number)
$('.box').data('name') // 'alice'
// remove data
$('.box').removeData('key')
// note: .data() does NOT write back to data-* attrs
// use .attr('data-key', val) to update the attributePlugins et extensions
Écrire un plugin
Les plugins étendent $.fn (le prototype de jQuery) pour être appelables sur les collections. Renvoyez toujours this (ou le résultat d'une méthode sur this) pour la chaînabilité. Dans le plugin, 'this' est la collection jQuery ; dans .each(), 'this' est un élément DOM brut. Enveloppez dans une IIFE pour aliaser $ via jQuery en toute sécurité. Le pattern des défauts $.extend est la façon standard d'accepter des options avec valeurs sensées. Publiez les plugins via npm ou en scripts autonomes.
// basic plugin pattern
(function ($) {
$.fn.highlight = function (color) {
// 'this' is the jQuery collection
return this.css('background', color || 'yellow')
}
}(jQuery))
// usage
$('.box').highlight('red')
$('.box').highlight() // default 'yellow'
// options pattern
$.fn.tooltip = function (options) {
const settings = $.extend({
position: 'top',
delay: 200
}, options)
return this.each(function () {
// 'this' is a DOM element here
// ... tooltip logic ...
})
}Plugin avec méthodes
Le pattern du plugin boilerplate emploie un objet methods dispatché par le premier argument : $('.c').counter({ start: 5 }) pour l'init, $('.c').counter('increment') pour appeler une méthode. L'état vit dans $.data. Ce pattern était populaire à l'ère pré-Vue/React pour des composants comme sliders, modales, datepickers. Aujourd'hui, un framework (Vue/React) est généralement un meilleur choix pour une UI avec état ; mais pour augmenter des sites jQuery anciens, ce pattern reste utile et bien compris.
// stateful plugin using data + methods
(function ($) {
$.fn.counter = function (method) {
const methods = {
init: function (options) {
return this.each(function () {
const $el = $(this)
$el.data('count', options?.start || 0)
$el.text($el.data('count'))
})
},
increment: function () {
return this.each(function () {
const $el = $(this)
const c = $el.data('count') + 1
$el.data('count', c).text(c)
})
},
reset: function () {
return this.each(function () {
$(this).data('count', 0).text(0)
})
}
}
if (methods[method]) {
return methods[method].apply(this, Array.prototype.slice.call(arguments, 1))
} else if (typeof method === 'object' || !method) {
return methods.init.apply(this, arguments)
} else {
$.error('Method ' + method + ' does not exist')
}
}
}(jQuery))Employer des plugins populaires
jQuery UI est la bibliothèque compagnon officielle pour les widgets (datepicker, accordion, autocomplete, dialog) et les interactions (draggable, droppable, sortable). Autres plugins populaires : DataTables (tableaux riches), Select2 (selects améliorés), Slick (carrousels), Magnific Popup (modales). Incluez le CSS et le JS du plugin après jQuery. Initialisez au DOM ready. Beaucoup de plugins offrent une API de méthode comme $('#x').plugin('method', args) et des mises à jour d'options via plugin('option', name, val).
<!-- jQuery UI (interactions, widgets, effects) -->
<link rel="stylesheet" href="https://code.jquery.com/ui/1.13.2/themes/base/jquery-ui.css">
<script src="https://code.jquery.com/ui/1.13.2/jquery-ui.min.js"></script>
<script>
// datepicker
$('#date').datepicker({ dateFormat: 'yy-mm-dd' })
// draggable / droppable / sortable
$('.item').draggable()
$('.list').sortable()
// dialog
$('<div>Hello</div>').dialog({ modal: true })
</script>
<!-- Other common plugins -->
<!-- DataTables: tables with sorting, search, pagination -->
<!-- Select2: enhanced <select> with search -->
<!-- Slick: carousel/slider -->
<!-- Magnific Popup: lightbox/modal -->Widget Factory (jQuery UI)
La Widget Factory de jQuery UI ($.widget) est une façon structurée de construire des plugins avec état et héritage. Elle fournit _create (constructeur), _destroy (nettoyage), _setOption, _on (liaison d'événements avec nettoyage auto), _trigger (événements personnalisés). Les options s'exposent via l'API de méthode : $el.widget('option', name, value). Les événements personnalisés se déclenchent comme widgetname + eventname. Pour une UI complexe avec état en jQuery, la widget factory est le pattern le plus robuste — mais envisagez une migration vers Vue/React pour le code neuf.
// create a reusable widget with state + inheritance
$.widget('my.counter', {
options: { start: 0 },
_create: function () {
this.count = this.options.start
this._refresh()
this._on(this.element, { click: 'increment' })
},
increment: function () {
this.count++
this._refresh()
this._trigger('changed', null, { count: this.count })
},
_refresh: function () {
this.element.text(this.count)
},
_destroy: function () {
this.element.text('')
}
})
// usage
$('#el').counter({ start: 5 }) // init
$('#el').counter('increment') // call method
$('#el').on('counterchanged', function (e, data) {
console.log('count is', data.count)
})
$('#el').counter('destroy') // cleanupBonnes pratiques des plugins
Bonnes pratiques des plugins : (1) renvoyez toujours this pour la chaînabilité ; (2) enveloppez dans une IIFE pour la sécurité de $ ; (3) employez .each() pour que le plugin fonctionne sur les sélections multi-éléments ; (4) namespacez les événements (click.myplugin) pour que les utilisateurs puissent délier sans toucher aux autres ; (5) fusionnez les options avec $.extend et exposez les défauts pour une surcharge globale ; (6) nettoyez à la destruction (événements, données, modifications DOM) ; (7) namespacez le nom du plugin pour éviter les collisions ; (8) exposez méthodes publiques et défauts pour la flexibilité.
// 1. always return this for chainability
$.fn.green = function () { return this.css('color', 'green') }
// 2. use IIFE for $ safety
(function ($) { /* plugin */ })(jQuery)
// 3. iterate with .each() for multi-element support
$.fn.x = function () { return this.each(function () { /* per element */ }) }
// 4. namespace events so users can unbind cleanly
this._on(this.element, { 'click.myplugin': 'handler' })
// 5. accept options via $.extend
const opts = $.extend({}, $.fn.x.defaults, options)
$.fn.x.defaults = { color: 'red' }
// 6. clean up on destroy (events, data, DOM)
// 7. namespace your plugin name to avoid collisions
// 8. provide public methods + defaults accessible for overrideAttributs et propriétés
Getters et setters d'attributs
.attr() lit/écrit les attributs HTML (les valeurs du balisage, toujours des chaînes). .prop() lit/écrit les propriétés DOM (l'état courant — ex. la propriété checked d'une case peut différer de son attribut checked après interaction utilisateur). Employez .prop() pour les attributs booléens (checked, disabled, selected) et .attr() pour les autres (href, src, alt, data-*). .data() lit data-* mais stocke les valeurs dans un cache interne avec préservation de type — employez .attr('data-*') si vous devez mettre à jour l'attribut DOM lui-même.
// .attr: HTML attribute (what's in the markup)
$('img').attr('src') // get
$('img').attr('src', 'new.jpg') // set
$('img').attr({ // set multiple
src: 'new.jpg',
alt: 'Photo',
width: 200
})
// .removeAttr: remove attribute entirely
$('img').removeAttr('alt')
// .prop: DOM property (current state, may differ from attr)
$('input').prop('checked') // true/false (current state)
$('input').prop('checked', true) // check it
$('input').prop('disabled', true)
// data-* attributes
$('div').attr('data-id', 42) // sets the attribute (string)
$('div').data('id', 42) // stores in cache (typed)Attributs data
.data(name) lit les attributs data-* avec conversion de type automatique (nombres, booléens, JSON). Régler via .data(name, value) écrit dans un cache interne, PAS dans l'attribut — donc .attr('data-name') renvoie encore l'original. Pour mettre à jour le véritable attribut DOM (ex. pour des sélecteurs CSS ou une lecture côté serveur), employez .attr('data-name', value). Cette distinction cause des bugs si on la confond. .removeData vide le cache. Noms en camel case : data-foo-bar devient .data('fooBar').
<!-- HTML -->
<div class="box" data-id="42" data-name="alice" data-active="true" data-config='{"x":1}'></div>
<script>
// .data() reads data-* with auto type conversion
$('.box').data('id') // 42 (number, not string)
$('.box').data('name') // 'alice'
$('.box').data('active') // true (boolean)
$('.box').data('config') // { x: 1 } (parsed JSON)
// set data (stored in cache, NOT the attribute)
$('.box').data('id', 99)
$('.box').data('id') // 99
$('.box').attr('data-id') // still '42' (attribute unchanged)
// to update the attribute itself, use .attr
$('.box').attr('data-id', 99)
// remove data
$('.box').removeData('id')
</script>Propriétés de formulaire
Pour l'état des formulaires, employez .prop() (propriétés DOM booléennes) — .prop('checked') reflète l'état courant, tandis que .attr('checked') renvoie l'attribut HTML initial (ne se met pas à jour à l'interaction). .val() lit/écrit les valeurs de formulaire de façon uniforme. Pour les radios, trouvez celui :checked et lisez son .val(). Pour un multi-select, .val() renvoie un tableau. .is(':checked') est une vérification booléenne propre. Ces distinctions comptent pour la validation et la sérialisation des formulaires.
// checkbox state
$('input[type=checkbox]').prop('checked') // true/false
$('input[type=checkbox]').prop('checked', true)
$('input[type=checkbox]').is(':checked') // boolean
// disabled / readonly
$('input').prop('disabled', true)
$('input').prop('readOnly', true) // note: camelCase
// select value
$('select').val() // selected value
$('select').val('option2') // set selected
$('select option:selected').text() // selected text
// multiple select
$('select[multiple]').val() // ['a', 'b'] array
// radio: value of checked
$('input[name=gender]:checked').val()
//.prop vs .attr for checkboxes:
// .prop('checked') = current state (changes when clicked)
// .attr('checked') = initial HTML value (doesn't change)Classe vs attribut
Trois façons d'exposer l'état d'un élément au CSS et au JS : les classes (bien connues, .hasClass), les attributs data-* (requêtables, porteurs de valeur) et les attributs ARIA (accessibles aux lecteurs d'écran). Pour l'état visuel, les classes sont les plus simples. Pour un état multi-valeurs (data-state='loading|success|error'), data-* est plus propre. Pour l'accessibilité, employez aria-* (aria-pressed, aria-expanded, aria-busy) — ils chevauchent souvent l'état visuel, associez-les donc. Les frameworks modernes facilitent cela, mais en jQuery, choisissez à dessein.
// adding behavior tags via class
$('.btn').addClass('loading')
// CSS: .btn.loading { opacity: 0.5; pointer-events: none; }
// via data attribute (cleaner for state)
$('.btn').attr('data-state', 'loading')
// CSS: .btn[data-state="loading"] { ... }
// via aria (accessible)
$('.btn').attr('aria-busy', 'true')
// choosing:
// - class: many CSS hooks, well-known
// - data-*: cleaner for state values, queryable
// - aria-*: exposes state to screen readers
// toggling example
$('.btn').on('click', function () {
const $b = $(this)
$b.attr('aria-pressed', $b.attr('aria-pressed') !== 'true')
})Valeur (champs de formulaire)
.val() est le getter/setter universel des valeurs de formulaire — inputs texte, textareas, selects, et (pour radios/checkboxes) la valeur du coché. .serialize() produit une chaîne encodée URL ; .serializeArray() donne un tableau {name, value} — convertissez-le en objet simple avec .serializeArray().reduce((o, p) => (o[p.name] = p.value, o), {}). Pour réinitialiser un formulaire, appelez la méthode native .reset() sur l'élément DOM brut (jQuery n'a pas de méthode .reset()).
// text input
$('input[type=text]').val() // get current value
$('input[type=text]').val('new value') // set
// textarea
$('textarea').val()
// select
$('select').val() // selected value
$('select').val('opt2') // set
$('select').val(['a', 'b']) // multi-select set
// checkbox (use prop for state)
$('input[type=checkbox]').prop('checked')
// radio
$('input[type=radio][name=g]:checked').val()
// serialize whole form
$('form').serialize() // 'name=Alice&age=30'
$('form').serializeArray() // [{name, value}]
// reset form
$('form')[0].reset()Dimensions et position
Méthodes de largeur et hauteur
Les méthodes de largeur/hauteur renvoient des nombres (px), contrairement à .css('width') qui renvoie des chaînes avec unités. .width() = boîte de contenu (largeur CSS). .innerWidth() = contenu + padding. .outerWidth() = contenu + padding + bordure. .outerWidth(true) inclut la marge. Pour window/document, $(window).width() est la fenêtre d'affichage (zone visible) ; $(document).height() est la hauteur totale de la page (peut dépasser la fenêtre quand on défile). Les setters prennent des nombres (px) ou des chaînes ('50%', '10em').
// content box (no padding, border, margin)
$('.box').width() // 200 (number, px)
$('.box').width(300) // set to 300px
// inner (content + padding)
$('.box').innerWidth()
$('.box').innerHeight()
// outer (content + padding + border)
$('.box').outerWidth()
$('.box').outerHeight()
// outer + margin
$('.box').outerWidth(true)
$('.box').outerHeight(true)
// window & document
$(window).width() // viewport width
$(window).height() // viewport height
$(document).height() // document height (may exceed viewport)Position vs offset
.offset() est relatif au document (coordonnées absolues — utile pour le drag-drop, les tooltips posés à la souris). .position() est relatif au parent de positionnement (l'ancêtre le plus proche avec position:relative/absolute/fixed) — utile pour repositionner dans un conteneur. .offsetParent() trouve cet ancêtre. .scrollTop()/.scrollLeft() lisent ou règlent la position de défilement — $(window).scrollTop() est le scroll de page. La distinction offset (document) / position (parent) est critique pour des calculs de positionnement corrects.
// .offset(): relative to document (top-left of page)
const o = $('.box').offset()
console.log(o.left, o.top) // e.g., 100, 200
$('.box').offset({ top: 0, left: 0 }) // move to top-left of page
// .position(): relative to offset parent
const p = $('.box').position()
console.log(p.left, p.top) // position within parent
// .scrollTop() / .scrollLeft()
$(window).scrollTop() // how far page is scrolled down
$(window).scrollTop(0) // scroll to top
$('.container').scrollTop(100) // scroll inner container
// .offsetParent(): nearest positioned ancestor
$('.box').offsetParent() // the element .position() is relative toHelpers de mise en page responsif
Resize se déclenche très souvent pendant un glisser — débouncz avec setTimeout pour éviter les problèmes de performance. Ajouter des classes au body (mobile/desktop) laisse le CSS réagir via body.mobile .nav { ... }. Pour du code responsif moderne, préférez les media queries CSS pour le style et window.matchMedia() en JS — plus performants et alignés sur les breakpoints CSS. L'approche resize de jQuery convient au code ancien, mais CSS + matchMedia est le standard moderne.
// check viewport width on resize
$(window).on('resize', function () {
const w = $(window).width()
if (w < 768) {
$('body').addClass('mobile').removeClass('desktop')
} else {
$('body').addClass('desktop').removeClass('mobile')
}
}).resize() // trigger once to initialize
// debounced resize (avoid firing hundreds of times)
let timer
$(window).on('resize', function () {
clearTimeout(timer)
timer = setTimeout(function () {
console.log('resize settled')
}, 200)
})
// match media (preferred for responsive checks)
if (window.matchMedia('(max-width: 768px)').matches) {
// mobile
}Détection de visibilité des éléments
:visible/:hidden vérifient display, visibility, opacité et dimensions — jQuery 3+ traite visibility:hidden et opacity:0 comme hidden (les versions antérieures les traitaient comme visibles). Pour la détection dans la fenêtre d'affichage, le helper inViewport compare les bornes de l'élément à la position de défilement. Le code moderne emploie IntersectionObserver pour cela — bien plus efficace (le navigateur fait les calculs, callbacks seulement aux changements) et sans écouteurs de scroll. L'approche jQuery fonctionne mais se déclenche à chaque événement de scroll.
// :visible / :hidden pseudo-classes
$('.box').is(':visible') // boolean
$('.box:visible').doSomething()
// note: visibility:hidden is now :hidden in jQuery 3+
// (display:none, opacity:0, width:0/height:0 are also :hidden)
// is element in viewport?
function inViewport($el) {
const elTop = $el.offset().top
const elBottom = elTop + $el.outerHeight()
const docTop = $(window).scrollTop()
const docBottom = docTop + $(window).height()
return elBottom >= docTop && elTop <= docBottom
}
// scroll-triggered reveal
$(window).on('scroll', function () {
$('.reveal').each(function () {
if (inViewport($(this))) {
$(this).addClass('shown')
}
})
})Position de scroll et animation
Défilement fluide : animez scrollTop sur html et body (cross-browser). Soustrayez la hauteur de l'en-tête pour les navs fixes. Défilement infini : quand position de scroll + hauteur de la fenêtre sont à moins de N pixels de la hauteur du document, chargez plus de contenu. Parallaxe : translatez les éléments selon la position de scroll. Étranglez toujours les handlers de scroll (ils se déclenchent des dizaines de fois par seconde) — employez _.throttle, un debounce par minuteur, ou requestAnimationFrame. Alternatives modernes : CSS scroll-behavior:smooth pour le défilement, IntersectionObserver pour les déclencheurs.
// current scroll position
const scrollTop = $(window).scrollTop()
// smooth scroll to top
$('html, body').animate({ scrollTop: 0 }, 500)
// smooth scroll to element
function scrollTo($el, duration) {
const top = $el.offset().top - 20 // 20px offset for fixed header
$('html, body').animate({ scrollTop: top }, duration || 500)
}
scrollTo($('#section2'))
// infinite scroll: load more when near bottom
$(window).on('scroll', function () {
if ($(window).scrollTop() + $(window).height() >= $(document).height() - 100) {
loadMore()
}
})
// parallax (simple)
$(window).on('scroll', function () {
const y = $(window).scrollTop()
$('.hero').css('transform', 'translateY(' + (y * 0.5) + 'px)')
})Deferred et Promises
Créer un Deferred
$.Deferred est l'implémentation de promise de jQuery (antérieure à Promise native). Créez-en un, puis appelez .resolve(value) ou .reject(reason) pour le conclure. .promise() renvoie une vue en lecture seule (les consommateurs ne peuvent le conclure). L'API historique emploie .done/.fail/.always au lieu de .then/.catch. Les Deferred de jQuery 3+ sont thenables, donc await et Promise.resolve fonctionnent avec eux. Préférez Promise native pour le code neuf — Deferred n'a d'intérêt que pour AJAX et les API anciennes.
// create a Deferred (jQuery's promise source)
const deferred = $.Deferred()
// resolve or reject it later
setTimeout(function () {
if (Math.random() > 0.5) {
deferred.resolve('success data')
} else {
deferred.reject(new Error('failed'))
}
}, 1000)
// get the promise (read-only view)
const promise = deferred.promise()
// consume it
promise
.done(function (data) { console.log('done:', data) })
.fail(function (err) { console.log('fail:', err) })
.always(function () { console.log('settled') })When (asynchrone parallèle)
$.when(deferreds...) attend que plusieurs Deferred/Promises se résolvent tous, puis appelle .done avec des tableaux de chaque résultat. Si l'un rejette, .fail se déclenche immédiatement. C'est le pattern asynchrone parallèle (comme Promise.all). Le callback reçoit un tableau par deferred d'entrée (contenant chacun [data, status, xhr] pour AJAX). Pour le code moderne, Promise.all + fetch est plus propre et renvoie les valeurs résolues directement. $.when reste utile dans les bases de code très jQuery.
// run multiple async ops in parallel, wait for all
$.when(
$.get('/api/users'),
$.get('/api/posts'),
$.get('/api/comments')
).done(function (usersResp, postsResp, commentsResp) {
// each arg is [data, status, xhr]
const users = usersResp[0]
const posts = postsResp[0]
console.log('all loaded:', users, posts)
}).fail(function (err) {
console.error('one failed:', err)
})
// modern equivalent
Promise.all([
fetch('/api/users').then(r => r.json()),
fetch('/api/posts').then(r => r.json())
]).then(([users, posts]) => {
console.log('all loaded:', users, posts)
})Chaîner .then()
jQuery 3+ a aligné .then sur la spécification Promises/A+ — il prend (onFulfilled, onRejected) et renvoie une nouvelle promise, comme Promise.then native. On peut chaîner des opérations asynchrones et transformer des valeurs. Renvoyer une promise depuis .then l'attend ; renvoyer une valeur la passe en aval. .catch est aussi géré en 3+. Pour jQuery 1.x/2.x, .then avait un comportement non standard — employez .pipe à la place. Si possible, passez en 3+ et employez .then/.catch pour un code asynchrone plus propre.
// jQuery 3+: .then follows Promises/A+ (like native then)
$.get('/api/users')
.then(function (users) {
// transform or chain another async
return $.get('/api/users/' + users[0].id)
})
.then(function (userDetail) {
console.log('detail:', userDetail)
return userDetail.name // pass value downstream
})
.then(function (name) {
console.log('name:', name)
})
.catch(function (err) {
console.error('any error in chain:', err)
})
// in jQuery 1.x/2.x, .then had different semantics
// use .done/.pipe for old code; .then for newInterface promise d'AJAX
Tous les appels $.ajax (et $.get/$.post) renvoient un objet jqXHR, façon promise (gère .done/.fail/.always) et (dans jQuery 3+) thenable (donc await et Promise.resolve fonctionnent). Plusieurs callbacks .done peuvent s'attacher — tous se déclenchent au succès. .abort() annule la requête (déclenche .fail avec le statut 'abort'). Pour du code neuf, await $.ajax(...) ou enveloppez avec Promise.resolve() pour s'intégrer proprement aux chaînes de Promise natives et à async/await.
// $.ajax returns a jqXHR (promise-like)
const req = $.ajax({ url: '/api/data', method: 'GET' })
// multiple callbacks on same request
req.done(function (data) { console.log('handler 1', data) })
req.done(function (data) { console.log('handler 2', data) })
req.fail(function (xhr, status, err) { console.error(err) })
req.always(function () { console.log('settled') })
// abort an in-flight request
req.abort()
// convert to native Promise (jQuery 3+)
Promise.resolve(req).then(function (data) {
console.log('via native promise:', data)
})
// use with async/await (jQuery 3+)
async function getData() {
try {
const data = await $.ajax({ url: '/api/data' })
console.log(data)
} catch (err) {
console.error(err)
}
}Pipeline de promise personnalisé
Enveloppez n'importe quelle opération asynchrone dans un Deferred pour obtenir une promise : créez, resolve/reject plus tard, renvoyez .promise(). Les collections jQuery exposent aussi .promise() qui se résout quand toutes les animations en file des éléments se terminent — utile pour déclencher du code après un lot d'animations. Cela relie la file d'animation de jQuery au code basé sur les promises, permettant d'attendre les animations ou de les chaîner avec AJAX ou d'autres travaux asynchrones proprement.
// wrap a callback-based API in a promise
function delay(ms) {
const d = $.Deferred()
setTimeout(function () { d.resolve() }, ms)
return d.promise()
}
// use it
delay(500).then(function () { console.log('500ms passed') })
// animate then continue
$('.box').fadeOut(300).promise().done(function () {
console.log('fade done')
})
// queue of animations on multiple elements
$('.box').each(function (i) {
$(this).delay(i * 100).fadeIn().promise()
})
// when animations on a set are done
$('.box').fadeOut().promise().done(function () {
console.log('all boxes faded')
})Formulaires
Événements de formulaire
submit se déclenche à l'envoi du formulaire — faites toujours preventDefault pour AJAX. input se déclenche à chaque frappe (texte) ou changement de valeur — parfait pour la validation en direct ou la recherche à la frappe. change se déclenche au blur pour les inputs texte mais immédiatement pour les checkboxes, radios et selects. focus/blur se déclenchent au focus du champ. Employez la d élégation d'événements sur le formulaire pour les champs ajoutés dynamiquement. La distinction 'change' vs 'input' compte : 'input' est en direct, 'change' quand l'utilisateur finit d'éditer.
// submit event
$('form').on('submit', function (e) {
e.preventDefault() // stop page reload
const data = $(this).serialize()
$.post('/api/save', data)
})
// input event (fires on every keystroke/change)
$('input').on('input', function () {
console.log('current value:', $(this).val())
})
// change event (fires on blur for text, immediately for checkbox/select)
$('select').on('change', function () {
console.log('selected:', $(this).val())
})
// focus / blur
$('input').on('focus', function () { $(this).addClass('focused') })
$('input').on('blur', function () { $(this).removeClass('focused') })
// delegated (works for dynamically added fields)
$('form').on('input', '.field', function () { /* ... */ })Sérialiser les données de formulaire
.serialize() produit une chaîne encodée URL prête pour les données AJAX. .serializeArray() donne un tableau {name, value} — convertissez-le en objet simple avec reduce. Les deux respectent l'état courant du formulaire (les checkboxes ne sont incluses que si cochées ; les selects emploient l'option sélectionnée). Pour les checkboxes, la valeur vaut 'on' par défaut sauf si vous réglez value='quelque chose'. Les champs désactivés sont exclus. C'est la façon standard de collecter les données de formulaire pour un envoi AJAX sans rechargement complet.
<!-- form -->
<form id="f">
<input name="name" value="Alice">
<input name="email" value="[email protected]">
<select name="role"><option value="admin" selected>Admin</option></select>
<input type="checkbox" name="agree" checked>
</form>
<script>
// serialize: URL-encoded string
$('#f').serialize()
// 'name=Alice&email=a%40b.com&role=admin&agree=on'
// serializeArray: array of {name, value}
$('#f').serializeArray()
// [{ name: 'name', value: 'Alice' }, ...]
// convert to plain object
const obj = {}
$('#f').serializeArray().forEach(p => { obj[p.name] = p.value })
// { name: 'Alice', email: '[email protected]', role: 'admin', agree: 'on' }
// or one-liner reduce
const obj2 = $('#f').serializeArray().reduce((o, p) =>
(o[p.name] = p.value, o), {})
</script>Validation de formulaire
Validation manuelle : itérez les champs requis, vérifiez .val(), basculez une classe 'invalid' pour le style CSS. La regex email est un contrôle de bon sens basique (la regex RFC 5322 complète est excessive). Pour les formulaires complexes, employez le jQuery Validation Plugin qui fournit des règles déclaratives (class='required email') et des messages d'erreur cohérents. Validez toujours côté client pour l'UX ET côté serveur pour la sécurité — la validation client se contourne. Les attributs HTML5 (required, type='email', pattern) sont la base moderne.
// simple validation
function validate($form) {
let valid = true
$form.find('[data-required]').each(function () {
const $f = $(this)
if (!$f.val()) {
$f.addClass('invalid')
valid = false
} else {
$f.removeClass('invalid')
}
})
$form.find('[type=email]').each(function () {
if (!/^[^@]+@[^@]+\.[^@]+$/.test($(this).val())) {
$(this).addClass('invalid')
valid = false
}
})
return valid
}
$('form').on('submit', function (e) {
e.preventDefault()
if (validate($(this))) {
$.post('/api/save', $(this).serialize())
}
})Champs de formulaire dynamiques
Ajoutez/retirez des champs dynamiquement en créant des éléments avec $() et en les ajoutant. Employez des noms façon tableau (tags[]) pour que le serveur reçoive un tableau. La délégation d'événements (on('click', '.remove', ...)) gère les clics sur les boutons de suppression ajoutés dynamiquement. Pour des champs réordonnables (boutons haut/bas ou drag-drop), renumérotez les noms après chaque changement pour que le serveur voie une séquence propre. Ce pattern est courant pour les inputs de tags, lignes dynamiques et formulaires de configuration.
// add a new field
$('.add-field').on('click', function () {
const $field = $('<input>', {
type: 'text',
name: 'tags[]',
class: 'tag-input',
placeholder: 'Tag'
})
$('#fields').append($field)
})
// remove a field
$('#fields').on('click', '.remove', function () {
$(this).closest('.field-row').remove()
})
// array field names (tags[]) — server receives an array
// PHP/Rails auto-parse 'name[]' into arrays
// re-number fields after add/remove
function renumber() {
$('#fields .field').each(function (i) {
$(this).find('input').attr('name', 'item_' + i)
})
}Envoi de formulaire AJAX
Un handler de formulaire AJAX réutilisable : sérialisez le formulaire, POSTez vers son URL d'action, gérez succès/erreur. Désactivez le bouton d'envoi pendant la requête pour prévenir les doubles envois. Déclenchez des événements personnalisés (ajax:success, ajax:error) pour que d'autres codes réagissent. Réinitialisez le formulaire en cas de succès. Montrez les erreurs de validation serveur en mappant les noms de champs aux messages. Ce pattern transforme n'importe quel formulaire en formulaire AJAX en ajoutant class='ajax' — une amélioration progressive courante.
// generic AJAX form submission
$('form.ajax').on('submit', function (e) {
e.preventDefault()
const $form = $(this)
const data = $form.serialize()
const url = $form.attr('action') || window.location.href
const method = $form.attr('method') || 'POST'
// show loading state
$form.find('button').prop('disabled', true).addClass('loading')
$.ajax({
url: url,
method: method,
data: data,
dataType: 'json'
})
.done(function (resp) {
$form.trigger('ajax:success', [resp])
$form[0].reset()
})
.fail(function (xhr) {
$form.trigger('ajax:error', [xhr])
const errors = xhr.responseJSON?.errors
if (errors) showErrors($form, errors)
})
.always(function () {
$form.find('button').prop('disabled', false).removeClass('loading')
})
})Itération et boucles
$.each vs .each()
$.each est un utilitaire générique qui itère les tableaux (index, valeur) ou les objets simples (clé, valeur). .each() est une méthode des collections jQuery — 'this' est l'élément DOM brut. Les deux acceptent return false pour casser et autre chose pour continuer. Notez l'ordre des arguments (index, valeur) — opposé à (valeur, index) de Array.forEach. Pour le code moderne, forEach/map/for...of natifs sont préférés ; .each() reste utile avec les collections jQuery quand vous avez besoin de l'élément comme 'this'.
// $.each: generic iterator (arrays AND objects)
$.each([10, 20, 30], function (index, value) {
console.log(index, value) // 0 10, 1 20, 2 30
})
$.each({ a: 1, b: 2 }, function (key, value) {
console.log(key, value) // 'a' 1, 'b' 2
})
// .each(): method on jQuery collections only
$('li').each(function (index, element) {
// 'this' is the DOM element (= element)
// wrap with $(this) for jQuery methods
$(this).text(index + ': ' + $(this).text())
})
// breaking out
$('li').each(function (i) {
if (i === 3) return false // stop iteration
// return true (or nothing) to continue
})$.map vs .map()
$.map transforme un tableau/objet en un nouveau tableau (renvoyez null pour sauter, un tableau pour aplatir). Notez l'ordre des arguments (valeur, index) — opposé à $.each. .map() sur les collections jQuery renvoie une nouvelle collection jQuery (appelez .get() pour convertir en tableau ordinaire). Renvoyer null/undefined depuis .map() exclut l'item. Elles précèdent Array.map native ; le code moderne emploie map natif, mais .map() de jQuery reste pratique pour extraire des valeurs des collections DOM.
// $.map: transform an array or object
const doubled = $.map([1, 2, 3], function (value, index) {
return value * 2 // [2, 4, 6]
})
// returning null/undefined removes the item
const evens = $.map([1, 2, 3, 4], function (v) {
return v % 2 === 0 ? v : null // [2, 4]
})
// returning an array flattens it
const flat = $.map([1, 2], function (v) {
return [v, v * 10] // [1, 10, 2, 20]
})
// .map() on jQuery collections
const ids = $('li').map(function (index, el) {
return $(el).data('id') // jQuery collection of ids
}).get() // .get() converts to plain array [1, 2, 3]Boucler avec for/while
Pour la performance brute sur de grandes collections, employez une boucle for classique avec $items[i] (élément DOM brut) au lieu de $items.eq(i) (enveloppé jQuery) — évite de créer un nouvel objet jQuery par itération. La propriété .length fonctionne directement. for...of fonctionne sur les collections jQuery (elles sont itérables). Cependant, préférez .each() pour la lisibilité sauf si vous avez mesuré un problème de performance — la différence est rarement perceptible sauf sur des milliers d'éléments.
// classic for loop with .eq(i)
const $items = $('li')
for (let i = 0; i < $items.length; i++) {
const $item = $items.eq(i)
$item.text('Item ' + i)
}
// or use the raw DOM elements (faster, no jQuery wrapping)
for (let i = 0; i < $items.length; i++) {
$items[i].textContent = 'Item ' + i // raw DOM
}
// while loop
let i = 0
while (i < $items.length) {
$($items[i]).addClass('item-' + i)
i++
}
// for...of (modern, on the collection)
for (const el of $items) {
$(el).addClass('processed')
}Filtrer pendant l'itération
Filtrez avant d'itérer pour un code plus propre — $('li').filter('.active').each(...) est plus idiomatique que des conditionnels dans .each(). Pour collecter un sous-ensemble, poussez les éléments DOM bruts correspondants dans un tableau et enveloppez avec $() à la fin. Pour l'extraction de valeurs, .map().get() est le pattern le plus propre. Évitez de construire des collections jQuery dans des boucles (chaque appel $() a un coût) — collectez les éléments bruts, enveloppez une fois.
// filter then iterate
$('li').filter('.active').each(function () {
$(this).addClass('highlighted')
})
// iterate with conditional logic
$('li').each(function (i) {
if (i % 2 === 0) {
$(this).addClass('even')
} else {
$(this).addClass('odd')
}
})
// collect matching items
const active = []
$('li').each(function () {
if ($(this).hasClass('active')) {
active.push(this) // push raw DOM element
}
})
const $active = $(active) // wrap in jQuery
// or use .map().get()
const ids = $('li.active').map(function () {
return $(this).data('id')
}).get()Imbrication et itération complexe
Les .each() imbriqués traitent grilles et matrices. Pour construire du DOM depuis des données, ajoutez à un fragment de document et insérez une fois (bien plus rapide que d'ajouter par item — chaque append déclenche un reflow). $(document.createDocumentFragment()) crée un fragment enveloppé jQuery. Pour de très longues listes, envisagez la concaténation de chaînes + .html() (le plus rapide) ou une bibliothèque de templates. Les frameworks modernes (Vue/React) gèrent cela déclarativement, mais le pattern fragment reste une optimisation jQuery utile.
// nested iteration over rows and cells
$('table tr').each(function (rowIdx, row) {
$(row).find('td').each(function (colIdx, cell) {
$(cell).text('R' + rowIdx + 'C' + colIdx)
})
})
// iterate over a JSON response and build DOM
$.get('/api/users').done(function (users) {
const $list = $('#users')
$.each(users, function (i, user) {
$list.append(
$('<li>').text(user.name).data('id', user.id)
)
})
})
// build with a document fragment (faster)
const $frag = $(document.createDocumentFragment())
$.each(users, function (i, user) {
$frag.append('<li>' + user.name + '</li>')
})
$('#users').append($frag) // one DOM updateStockage de données et cache
$.data vs .data()
$.data(el, key, val) est la fonction bas niveau sur un élément DOM brut ; .data() est la méthode pratique des collections jQuery. Les deux stockent les valeurs dans un cache interne (pas dans le DOM), donc plus rapide que l'accès par attribut. .data() lit aussi automatiquement les attributs data-* avec conversion de type (nombres, booléens, JSON). Régler via .data(key, val) ne met PAS à jour l'attribut data-* — employez .attr('data-key', val) pour cela. Employez $.removeData(el, key) ou .removeData(key) pour vider.
// $.data: low-level, on raw DOM element
const el = document.getElementById('box')
$.data(el, 'count', 1)
$.data(el, 'count') // 1
$.data(el, 'count', 2)
$.data(el, 'count') // 2
$.removeData(el, 'count')
// .data(): method on jQuery collection (more common)
$('.box').data('count', 1)
$('.box').data('count') // 1
$('.box').removeData('count')
// auto-reads data-* attributes (with type conversion)
// <div data-id="42" data-active="true"></div>
$('.box').data('id') // 42 (number)
$('.box').data('active') // true (boolean)Stocker un état par élément
L'état par élément est la fonctionnalité tueuse de .data() — stockez config, compteurs, flags ou objets associés à chaque élément sans polluer le DOM. Appeler .data() sans argument renvoie toutes les données stockées sous forme d'objet. Notez que stocker un objet et le muter mute la référence stockée (pas besoin de re-régler). Le cache interne se nettoie automatiquement quand les éléments sont retirés via .remove(), prévenant les fuites mémoire — mais pas si vous les retirez par les méthodes DOM brutes (parentNode.removeChild).
// store per-element state on plugin init
$('.counter').each(function () {
$(this).data('count', 0)
})
// increment on click
$('.counter').on('click', function () {
const $el = $(this)
const c = $el.data('count') + 1
$el.data('count', c)
$el.text('Count: ' + c)
})
// retrieve all data
const all = $('.counter').data() // { count: 5, ... }
// store objects
$('.box').data('config', { color: 'red', size: 10 })
$('.box').data('config').color = 'blue' // mutates the stored object
$('.box').data('config').color // 'blue'Mettre en cache les sélections
Mettre en cache les sélections jQuery évite de re-interroger le DOM — un gain de perf significatif dans les boucles ou les handlers fréquents. Convention : préfixez les objets jQuery en cache de $ ($boxes, $nav) pour les distinguer des éléments DOM bruts. Attention : les sélections en cache deviennent périmées si le DOM change (vous ajoutez/retirez des éléments correspondants). Re-requêtez après insertion de contenu dynamique. Pour les handlers d'événements, mettre en cache hors du handler (dans la même portée) évite de re-requêter à chaque événement.
// BAD: re-querying the DOM on every use
function update() {
$('.box').text('updated') // queries every call
$('.box').addClass('done') // queries again
}
// GOOD: cache the selection
const $boxes = $('.box') // query once
function update() {
$boxes.text('updated')
$boxes.addClass('done')
}
// re-query when content changes
$('#container').load('/partial', function () {
// $boxes is stale — re-query
const $newBoxes = $('.box')
})
// convention: prefix cached jQuery objects with $
const $nav = $('#nav')
const $items = $('.item')Attributs HTML5 data-*
Les attributs data-* permettent d'intégrer la configuration au HTML déclarativement — parfait pour l'amélioration progressive (le serveur rend la config, le JS la lit). .data() lit avec conversion de type (nombres, booléens, objets JSON) ; .attr() lit la chaîne brute. Les noms multi-mots emploient le kebab-case en HTML (data-foo-bar) et le camelCase en JS (.data('fooBar')). Pour les valeurs JSON, employez les guillemets simples en HTML pour envelopper le JSON (qui emploie les doubles). Mettre à jour data-* via .attr() persiste au DOM ; .data() n'écrit que dans le cache.
<!-- declarative config in HTML -->
<div class="widget"
data-id="42"
data-mode="advanced"
data-config='{"timeout":5000,"retries":3}'
data-enabled="true">
Widget
</div>
<script>
// .data() reads with type conversion
const $w = $('.widget')
$w.data('id') // 42 (number)
$w.data('mode') // 'advanced'
$w.data('config') // { timeout: 5000, retries: 3 } (parsed JSON)
$w.data('enabled') // true (boolean)
// .attr() reads raw strings
$w.attr('data-id') // '42' (string)
$w.attr('data-config') // '{"timeout":5000,...}' (string)
// camelCase mapping: data-foo-bar -> .data('fooBar')
$('[data-foo-bar]').data('fooBar')
</script>Mémoire et nettoyage
Employez .remove() pour supprimer des éléments — il nettoie automatiquement les données et événements associés. .detach() retire du DOM mais préserve données/événements (pour réinsertion). .empty() retire les enfants ET nettoie leurs données/événements. N'employez JAMAIS .html('') pour vider les enfants — il ne nettoie pas leurs données/événements, causant des fuites mémoire. Pour les plugins, exposez une méthode destroy qui délie les événements et retire les données. Le nettoyage automatique de jQuery est une raison majeure d'employer .remove() plutôt que la suppression DOM brute.
// .remove() cleans up data and events
$('.box').remove() // safe — data and events gone
// .detach() preserves data and events for re-insertion
const $box = $('.box').detach()
$('#elsewhere').append($box) // events still fire
// .empty() removes children AND their data/events
$('.container').empty() // children's data/events cleaned
// .html('') does NOT clean up children's data/events (leak!)
// use .empty() instead
// manual cleanup before removal
$('.box').off().removeData().remove()
// custom cleanup in a plugin
$.fn.myPlugin = function () {
this.on('click.myplugin', handler)
this.data('myplugin', { /* state */ })
// expose destroy for manual cleanup
// ... or use .on('remove') event (non-standard)Animations personnalisées
Bases de .animate()
.animate() interpole des propriétés CSS numériques sur une durée. Employez les valeurs relatives ('+=50', '-=20') pour des changements incrémentaux. Les noms de propriétés doivent être en camelCase (marginLeft, pas margin-left). Les valeurs spéciales 'toggle', 'show', 'hide' fonctionnent comme leurs méthodes homologues. Les nombres valent des pixels par défaut. Les couleurs exigent le plugin jQuery Color — le cœur de jQuery n'anime que des nombres. Le callback se déclenche une fois à la fin de l'animation (par élément, donc possiblement plusieurs fois pour les collections).
// animate numeric CSS properties
$('.box').animate({
width: '500px',
height: 200, // number = px
opacity: 0.5,
marginLeft: '+=50', // relative
fontSize: '20px' // camelCase for hyphenated props
}, 1000) // duration in ms
// with callback
$('.box').animate({ left: 300 }, 1000, function () {
console.log('done')
})
// 'slow' = 600, 'fast' = 200
$('.box').animate({ height: 'toggle' }, 'slow')
// special values: 'toggle', 'show', 'hide'
$('.box').animate({ width: 'toggle' })Easing et options
L'easing contrôle la courbe de vitesse : 'swing' (défaut, départ/arrivée lents, milieu rapide) et 'linear' (constant). jQuery UI ou le plugin easing en ajoutent plus de 30 (easeInOutCubic, easeOutBounce). La forme options donne un contrôle fin : step est appelé à chaque frame d'animation (utile pour synchroniser d'autres éléments), queue:false exécute en parallèle (défaut true met en file séquentiellement), specialEasing règle l'easing par propriété. step reçoit (now, fx) où fx porte fx.prop (nom de propriété) et fx.start/fx.end.
// easing: 'swing' (default, ease-out) or 'linear'
$('.box').animate({ left: 300 }, 1000, 'linear')
// options object form
$('.box').animate({ left: 300 }, {
duration: 1000,
easing: 'swing',
complete: function () { console.log('done') },
step: function (now, fx) {
console.log(fx.prop, now) // called each frame
},
queue: true, // default true (sequential)
specialEasing: {
width: 'linear', // per-property easing
height: 'swing'
}
})
// jQuery UI adds more easings: easeInOutCubic, etc.
// or include jquery.easing pluginFile d'animation
Chaque élément a une file 'fx' — les animations sur le même élément s'exécutent séquentiellement par défaut. Employez queue:false pour du parallèle. .delay(ms) insère une pause. .queue(fn) insère une fonction personnalisée dans la file — appelez next() (ou dequeue()) pour continuer. Cela permet de mélanger animations et code arbitraire (AJAX, callbacks) dans une séquence. .clearQueue() vide la file sans toucher à l'animation courante. .dequeue() avance à l'élément suivant de la file.
// animations queue per element (default)
$('.box')
.animate({ width: 500 }, 500) // runs first
.animate({ height: 300 }, 500) // runs after
.animate({ opacity: 0.5 }, 500) // runs after that
// total: 1500ms (sequential)
// run in parallel: queue: false
$('.box').animate({ width: 500 }, { duration: 500, queue: false })
$('.box').animate({ height: 300 }, { duration: 500, queue: false })
// both run simultaneously
// .delay(): pause in the queue
$('.box')
.animate({ width: 500 }, 500)
.delay(300) // wait 300ms
.animate({ height: 300 }, 500)
// .queue(): insert custom function into the queue
$('.box').animate({ width: 500 }, 500).queue(function (next) {
console.log('between animations')
next() // must call to continue
})Animations de couleurs
Le cœur de jQuery ne peut animer les couleurs (non numériques). Le plugin jQuery Color (petit, autonome) ou jQuery UI ajoute le support des animations de couleurs — backgroundColor, color, borderColor, etc. jQuery UI active aussi les animations par classes : .addClass('foo', 500) passe aux styles de la nouvelle classe sur 500 ms. Pour les sites modernes, préférez les transitions CSS (transition: background 0.3s) — accélérées matériellement et sans JS. Réservez l'animation de couleurs jQuery au support du code ancien.
<!-- jQuery core does NOT animate colors -->
<!-- include jQuery Color plugin or jQuery UI -->
<script src="https://code.jquery.com/color/jquery.color-2.2.0.min.js"></script>
<script>
// now color animations work
$('.box').animate({
backgroundColor: '#ff0000',
color: '#ffffff',
borderColor: '#000000'
}, 1000)
// jQuery UI also enables:
// - class animations: .toggleClass('active', 500)
// - more easing functions
// - color transitions on hover
$('.box').hover(function () {
$(this).animate({ backgroundColor: '#eee' }, 300)
}, function () {
$(this).animate({ backgroundColor: '#fff' }, 300)
})
</script>Arrêter et vider
.stop() interrompt l'animation courante. Avec (clearQueue=true), il vide aussi la file. Avec (jumpToEnd=true), il saute l'animation courante à son état final. .finish() saute toutes les animations en file à leurs états finaux instantanément. Le sélecteur :animated matche les éléments en cours d'animation. Associez toujours les animations pilotées par le survol à .stop(true) pour prévenir l'empilement quand la souris entre/sort rapidement — sans lui, les animations s'empilent et se jouent longtemps après le départ de la souris, causant un comportement saccadé.
// .stop([clearQueue], [jumpToEnd])
$('.box').stop() // stop current, stay at current state
$('.box').stop(true) // also clear the queue
$('.box').stop(true, true) // clear queue AND jump current to end
$('.box').stop(false, true) // jump current to end, keep queue
// .finish(): jump ALL queued animations to end state
$('.box').finish()
// prevent hover animation buildup
$('.box').hover(function () {
$(this).stop(true).animate({ width: 300 }, 200)
}, function () {
$(this).stop(true).animate({ width: 100 }, 200)
})
// check if currently animating
if (!$(':animated').length) { /* nothing animating */ }
if ($('.box').is(':animated')) { /* still animating */ }Délégation d'événements
Pourquoi déléguer ?
La délégation d'événements lie un handler à un parent ; les clics sur les enfants remontent par bubbling et le déclenchent. Bénéfices : (1) un handler au lieu de N (mémoire), (2) fonctionne automatiquement pour les éléments ajoutés dynamiquement, (3) mise en place plus rapide (une liaison vs N). Le second argument de .on() ('li') est le filtre de sélecteur — 'this' dans le handler est l'enfant matché, pas le parent. Employez la délégation pour toute liste, table ou conteneur dont les enfants partagent un comportement. Le seul coût : une légère surcharge par événement (vérification de sélecteur), négligeable.
// ANTI-PATTERN: bind to each <li> directly
$('li').on('click', function () {
$(this).toggleClass('done')
})
// - 1 handler PER <li> (100 items = 100 handlers)
// - NEW <li> added later DON'T get the handler
// - high memory, slow setup
// PATTERN: delegate to parent
$('ul').on('click', 'li', function (e) {
$(this).toggleClass('done')
})
// - 1 handler total
// - works for future <li>
// - low memory, fast setup
// - 'this' is the <li> (not the <ul>)Délégation en pratique
Ce pattern de todo-list montre la puissance de la délégation : deux handlers délégués sur #tasks gèrent les boutons de suppression et le basculement des items pour tous les items présents et futurs. Ajouter un nouveau <li> n'exige aucune re-liaison. e.stopPropagation() sur le bouton de suppression empêche le clic sur li de se déclencher aussi (ce qui basculerait .done lors de la suppression). .closest('li') trouve le <li> englobant depuis le bouton cliqué. Ce pattern est le fondement des SPA jQuery d'avant les frameworks — et reste utile pour une UI façon widget.
<!-- dynamic list -->
<ul id="tasks">
<li>Task 1 <button class="delete">×</button></li>
</ul>
<script>
// ONE delegated handler handles all current AND future items
$('#tasks').on('click', '.delete', function (e) {
e.stopPropagation()
$(this).closest('li').remove()
})
$('#tasks').on('click', 'li', function () {
$(this).toggleClass('done')
})
// adding new items works without re-binding
$('.add').on('click', function () {
$('#tasks').append('<li>New task <button class="delete">×</button></li>')
})
</script>Délégué vs liaison directe
La liaison directe attache le handler aux éléments matchés ; la liaison déléguée s'attache à un parent et filtre par sélecteur. Différence clé dans le handler : en direct, e.currentTarget === this === l'élément. En délégué, e.currentTarget est le parent (là où le handler est lié), this est l'enfant matché (la correspondance du sélecteur), et e.target est l'élément réellement cliqué (peut être un descendant de l'enfant matché). Employez e.delegateTarget pour accéder au parent dans les handlers délégués.
// DIRECT: bind directly to element
// - element must exist at bind time
// - handler attached to element itself
// - e.target === e.currentTarget === this
$('.btn').on('click', function (e) {
console.log(e.currentTarget === this) // true
})
// DELEGATED: bind to parent, filter by selector
// - works for future children
// - handler attached to parent
// - e.currentTarget = parent (the bound element)
// - this = child (matched selector)
// - e.target = actual clicked element (may be deeper child)
$('ul').on('click', 'li', function (e) {
console.log(e.currentTarget) // the <ul>
console.log(this) // the <li>
console.log(e.target) // clicked element (maybe <span> in li)
})Délier les handlers délégués
Le namespacing (click.task) est la façon la plus propre de délier des handlers précis sans toucher aux autres. .off('click', 'li') retire les handlers délégués correspondant à ce sélecteur. .off('click') retire tous les handlers click (directs et délégués). .off() retire tout — employez-le avec soin. Pour retirer un handler précis, passez la référence originale de la fonction. Pour les plugins, namespacez toujours les événements (click.myplugin) pour que les utilisateurs puissent délier proprement sans connaître vos entrailles.
// delegate with namespace
$('ul').on('click.task', 'li', handler)
// remove just this delegated handler (by namespace)
$('ul').off('click.task')
// remove all delegated click handlers
$('ul').off('click')
// remove all delegated handlers with a specific selector
$('ul').off('click', 'li')
// remove ALL handlers (including delegated)
$('ul').off()
// remove with reference to the original handler
function handler() { /* ... */ }
$('ul').on('click', 'li', handler)
$('ul').off('click', 'li', handler) // exact matchPièges de la délégation
Restreignez la délégation à l'ancêtre stable le plus proche — ne déléguez pas tout à document/body (chaque événement remonte et est comparé au sélecteur, ce qui est lent). Évitez les sélecteurs trop larges ('div'). Attention à stopPropagation dans les enfants : il empêche les handlers délégués des ancêtres de se déclencher. Si un enfant stoppe la propagation, le handler délégué du parent ne tourne jamais. Le compromis : la délégation est flexible mais ajoute une minime surcharge par événement (correspondance de sélecteur) — généralement négligeable, mais perceptible sur d'énormes pages.
// PITFALL 1: delegated handler on a parent that's too high
$(document).on('click', '.btn', handler)
// works, but EVERY click bubbles to document and is checked
// (slow on large pages — scope to nearest stable parent)
// BETTER: scope to the nearest container that won't be replaced
$('#sidebar').on('click', '.btn', handler)
// PITFALL 2: selector that matches too broadly
$('body').on('click', 'div', handler) // fires on every div click
// PITFALL 3: stopping propagation in a child breaks delegation
$('.btn').on('click', function (e) {
e.stopPropagation() // parent's delegated handler won't fire!
})
// PITFALL 4: delegated handlers don't fire if a parent
// stops propagation before reaching the delegate targetBonnes pratiques
Conseils de performance
Conseils de performance clés : (1) mettez les sélections en cache ; (2) restreignez les requêtes à un conteneur avec .find() ; (3) préférez les sélecteurs #id (emploient getElementById en interne) ; (4) évitez * ; (5) déléguez les événements ; (6) grouperez les mises à jour DOM via des fragments — chaque append déclenche un reflow, construisez donc un fragment et ajoutez une fois ; (7) détachez avant les manipulations lourdes (les opérations sur des éléments détachés ne déclenchent pas de reflow). Pour les listes de 1000+ items, la concaténation de chaînes + .html() est la plus rapide, mais le fragment est plus propre.
// 1. cache selections
const $items = $('.items') // query once
// 2. scope queries to a container
$('.item', $container) // search within container
$container.find('.item') // equivalent, slightly faster
// 3. use ID selectors when possible (fastest)
$('#header') // getElementById
// 4. avoid universal selector
$('*').doSomething() // SLOW
// 5. delegate events instead of binding many
$('ul').on('click', 'li', fn) // 1 handler
// 6. batch DOM updates (use document fragment)
const $frag = $(document.createDocumentFragment())
for (let i = 0; i < 1000; i++) {
$frag.append('<li>Item ' + i + '</li>')
}
$('ul').append($frag) // one reflow, not 1000
// 7. detach before heavy manipulation
const $list = $('ul').detach()
// ... modify $list ...
$('#container').append($list)Performance d'insertion DOM
L'insertion DOM est le plus grand goulot de performance. Chaque .append() déclenche un reflow (le navigateur recalcule la mise en page). Pour les insertions en masse : (1) construisez une chaîne HTML et réglez-la avec .html() (le plus rapide pour un contenu simple) ; (2) employez un fragment de document et ajoutez une fois (plus propre pour les éléments complexes) ; (3) détachez le conteneur, modifiez, rattachez (évite le reflow du DOM vivant pendant la modification). Pour 1000+ items, l'approche chaîne est nettement plus rapide que le .append() par item.
// SLOW: appending in a loop (reflow per iteration)
for (let i = 0; i < 1000; i++) {
$('ul').append('<li>Item ' + i + '</li>')
}
// FASTER: build string, append once
let html = ''
for (let i = 0; i < 1000; i++) {
html += '<li>Item ' + i + '</li>'
}
$('ul').html(html)
// FASTEST: detached node + fragment
const $list = $('ul').detach()
const $frag = $(document.createDocumentFragment())
for (let i = 0; i < 1000; i++) {
$frag.append($('<li>').text('Item ' + i))
}
$list.append($frag).appendTo('#container')
// even faster: array.join
const html = new Array(1000).fill(0).map((_, i) =>
'<li>Item ' + i + '</li>'
).join('')
$('ul').html(html)Patterns jQuery modernes
Patterns jQuery modernes (3.x) : employez .on()/.off() (les méthodes anciennes comme .bind/.live/.delegate sont retirées ou dépréciées). Préférez l'interface promise (.done/.fail) aux callbacks success/error. Restreignez le code dans des IIFE ou modules ES — ne polluez pas les globales. Sautez $(document).ready si votre script est en fin de body. Préférez les transitions/animations CSS à .animate() (accélérées matériellement, plus fluides). Employez 'use strict'. Pour les nouveaux projets, évaluez si un framework (Vue/React) convient mieux que jQuery.
// use .on() / .off() (not bind/unbind, live, delegate)
$('.btn').on('click', fn)
// use promises (.done/.fail) instead of success/error
$.get('/api').done(fn).fail(errFn)
// use IIFE or modules to scope code
(function ($) {
'use strict'
// private code
$('.btn').on('click', fn)
}(jQuery))
// or ES modules
import $ from 'jquery'
$('.btn').on('click', fn)
// don't pollute global scope
// don't use $(document).ready if script is at end of body
// prefer CSS for animations (hardware-accelerated)
// .css({ transition: 'all 0.3s', transform: 'translateX(100px)' })Accessibilité
Essentiels d'accessibilité : ajoutez les rôles et états ARIA (role='dialog', aria-modal, aria-expanded, aria-labelledby). Rendez les widgets personnalisés accessibles au clavier — gérez Entrée/Espace pour les boutons, les flèches pour les menus, Échap pour fermer les modales. Gérez le focus : déplacez-le dans les modales à l'ouverture, rendez-le au déclencheur à la fermeture. Employez des éléments sémantiques (<button>, <a>, <nav>) plutôt que des div avec onclick. Visibilité : préférez masquer via des classes CSS (que les lecteurs d'écran peuvent ignorer) à display:none (qu'ils ignorent toujours).
// add ARIA attributes for screen readers
$('.modal').attr({
role: 'dialog',
'aria-modal': true,
'aria-labelledby': 'modal-title'
})
// toggle aria-expanded for collapsibles
$('.accordion .header').on('click', function () {
const $h = $(this)
const expanded = $h.attr('aria-expanded') !== 'true'
$h.attr('aria-expanded', expanded)
$h.next('.content').slideToggle()
})
// keyboard navigation
$('.menu-item').on('keydown', function (e) {
if (e.which === 13 || e.which === 32) { // Enter or Space
$(this).trigger('click')
}
})
// focus management for modals
$('.modal').on('shown', function () {
$(this).find('input:first').focus()
})
// use button elements for actions (not <div onclick>)
$('<button>').text('Save').on('click', save).appendTo('body')Sécurité : XSS et injection HTML
N'injectez jamais de chaînes non fiables via .html() — il exécute les balises <script> et handlers d'événements intégrés (XSS). Employez .text() pour le texte brut (échappé automatiquement). Quand vous devez inclure du HTML, assainissez d'abord (échappement manuel ou une bibliothèque comme DOMPurify). Le pattern le plus sûr : construisez les éléments avec $() et employez .text() pour le contenu dynamique — $('<li>').text(userInput) échappe automatiquement. Soyez particulièrement prudent avec les patterns .append('<div>' + data + '</div>') — vecteurs de XSS si data est contrôlée par l'utilisateur.
// DANGEROUS: injecting untrusted HTML
const userInput = '<script>alert("xss")</script>'
$('.box').html(userInput) // EXECUTES the script!
// SAFE: escape with .text()
$('.box').text(userInput) // displays as text, no execution
// SAFE: sanitize before injecting
function escapeHtml(str) {
return str
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''')
}
$('.box').html(escapeHtml(userInput))
// SAFE: build elements with .text() for content
const $li = $('<li>').text(userInput) // text is auto-escaped
$('ul').append($li)
// AVOID .html() with user input. Use .text() or DOMPurify.
// $('div').html('<p>' + data + '</p>') // BAD if data is user inputPatterns courants
Dialogue modal
Un pattern modal : créez overlay + modale, ajoutez au body (échappe les contextes d'empilement parents), fondu d'entrée. Le clic sur l'overlay (pas la modale) ferme — employez e.target === this pour détecter. La touche Échap ferme. Nettoyez toujours (retirer le DOM, délier les handlers) à la fermeture. En production, envisagez une bibliothèque (Magnific Popup, Bootstrap Modal) qui gère l'accessibilité (piégeage du focus, ARIA, retour du focus au déclencheur), les animations et les modales iframe/ajax. Le pattern ci-dessus est la version minimale faite main.
// simple modal pattern
function openModal(html) {
const $overlay = $('<div class="modal-overlay"></div>')
const $modal = $('<div class="modal"></div>').html(html)
$overlay.append($modal).appendTo('body').hide().fadeIn(200)
$overlay.on('click', function (e) {
if (e.target === this) closeModal() // click outside to close
})
$(document).on('keydown.modal', function (e) {
if (e.which === 27) closeModal() // Esc to close
})
}
function closeModal() {
$('.modal-overlay').fadeOut(200, function () { $(this).remove() })
$(document).off('keydown.modal')
}
// usage
$('.open').on('click', function () {
openModal('<p>Hello from modal!</p>')
})Onglets
Pattern d'onglets classique : cliquer un lien d'onglet active cet onglet. Le href du lien (#tab1) correspond à l'id du contenu. La classe active sur le lien et le contenu contrôle la visibilité (CSS : .tab-content:not(.active) { display: none }). Le handler emploie la délégation d'événements (gère les onglets ajoutés dynamiquement).preventDefault empêche le hash d'URL de changer (ou omettez preventDefault pour activer les liens profonds par hash vers les onglets). Pour l'accessibilité, ajoutez role='tab', aria-selected et la navigation clavier aux flèches.
<!-- HTML -->
<div class="tabs">
<ul class="tab-nav">
<li><a href="#tab1" class="active">Tab 1</a></li>
<li><a href="#tab2">Tab 2</a></li>
<li><a href="#tab3">Tab 3</a></li>
</ul>
<div id="tab1" class="tab-content active">Content 1</div>
<div id="tab2" class="tab-content">Content 2</div>
<div id="tab3" class="tab-content">Content 3</div>
</div>
<script>
$('.tab-nav').on('click', 'a', function (e) {
e.preventDefault()
const $a = $(this)
$a.addClass('active').parent().siblings().find('a').removeClass('active')
$($a.attr('href')).addClass('active').siblings().removeClass('active')
})
</script>Accordéon
Patterns d'accordéon : cliquer un en-tête bascule son contenu. La variante à ouverture unique ferme les autres quand l'un s'ouvre (retirez le bloc .not($h) pour la multi-ouverture). Employez aria-expanded pour exposer l'état aux lecteurs d'écran — le CSS peut styler selon lui (.acc-header[aria-expanded="true"] { ... }). slideToggle anime le contenu. Employez <button> pour les en-têtes (accessibles au clavier par défaut). Pour beaucoup d'items, la délégation d'événements sur le parent évite de lier chaque en-tête individuellement.
<!-- HTML -->
<div class="accordion">
<div class="acc-item">
<button class="acc-header" aria-expanded="false">Section 1</button>
<div class="acc-content">Content 1</div>
</div>
<!-- more items -->
</div>
<script>
$('.accordion').on('click', '.acc-header', function () {
const $h = $(this)
const $c = $h.next('.acc-content')
// close others (single-open accordion)
$h.closest('.accordion')
.find('.acc-header').not($h)
.attr('aria-expanded', false)
.next('.acc-content').slideUp()
// toggle this one
const isOpen = $h.attr('aria-expanded') === 'true'
$h.attr('aria-expanded', !isOpen)
$c.slideToggle()
})
</script>Défilement infini
Défilement infini : détectez quand l'utilisateur défile près du bas, récupérez plus d'items, ajoutez-les. Protégez contre les chargements concurrents (flag loading). Quand le serveur ne renvoie plus d'items, déliez le handler de scroll (plus de tentatives). Ajoutez via un fragment pour la performance. Étranglez le handler de scroll (il se déclenche très souvent) — soit par debounce/_.throttle, soit en vérifiant le flag loading (comme ici) pour sauter pendant qu'une requête est en vol. Alternative moderne : IntersectionObserver sur un élément sentinelle en bas.
let loading = false
let page = 1
function loadMore() {
if (loading) return
loading = true
$('.loader').show()
$.get('/api/items', { page: page })
.done(function (items) {
if (items.length === 0) {
// no more items — unbind the scroll handler
$(window).off('scroll.inf')
return
}
const $frag = $(document.createDocumentFragment())
items.forEach(item => {
$frag.append($('<li>').text(item.name))
})
$('ul.items').append($frag)
page++
})
.always(function () {
loading = false
$('.loader').hide()
})
}
// trigger when near bottom
$(window).on('scroll.inf', function () {
if ($(window).scrollTop() + $(window).height() > $(document).height() - 200) {
loadMore()
}
})Recherche en direct (débouncée)
Recherche en direct : à chaque frappe, interrogez le serveur et montrez les résultats. Le debounce est essentiel — sans lui, chaque frappe lance une requête (frappe rapide = des dizaines de requêtes). Le debounce attend N ms après la dernière frappe avant de se déclencher. 300 ms est un bon défaut. Gérez toujours la requête vide (videz les résultats). En production, annulez aussi les requêtes en vol quand une nouvelle démarre (employez .abort() sur le jqXHR précédent) pour éviter des réponses désordonnées. Alternatives modernes : AbortController avec fetch.
// debounce: wait until user pauses typing
function debounce(fn, wait) {
let timer
return function () {
clearTimeout(timer)
const args = arguments
const ctx = this
timer = setTimeout(() => fn.apply(ctx, args), wait)
}
}
// live search
const $input = $('#search')
const $results = $('#results')
$input.on('input', debounce(function () {
const q = $(this).val()
if (!q) { $results.empty(); return }
$.get('/api/search', { q: q })
.done(function (items) {
$results.empty()
items.forEach(item => {
$results.append($('<li>').text(item.name))
})
})
}, 300)) // wait 300ms after last keystroke
// without debounce, a search fires on every keystroke (too many requests)Snippets jQuery associés
Copy-paste ready code for common tasks.
Selectors
Select elements by id, class, attribute, and pseudo-filters.
Events & Delegation
Bind handlers with on(), support delegation and namespaced removal.
DOM Manipulation
Get/set text, html, attributes, classes, and insert nodes.
AJAX Requests
Use $.ajax, $.get, $.post, and load with promises.
Effects & Animation
Show, hide, fade, slide, and animate elements.
Traversing the DOM
Navigate relatives and filter the matched set.
Utility Methods
Iterate, merge, and filter with jQuery helpers.
Method Chaining
Chain jQuery methods and use end() to restore context.
Was this helpful?