Démarrage
Installation via CDN
jQuery UI dépend du cœur de jQuery — chargez toujours jQuery avant jquery-ui.js. Le CSS fournit le thème par défaut et est requis pour que des widgets comme Datepicker et Dialog s'affichent correctement. La version 1.13.x gère jQuery 1.8+.
<!-- jQuery UI requires jQuery core first -->
<link rel="stylesheet"
href="https://code.jquery.com/ui/1.13.2/themes/base/jquery-ui.css">
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
<script src="https://code.jquery.com/ui/1.13.2/jquery-ui.min.js"></script>Installation via npm
Installer via npm permet le tree-shaking en n'important que les widgets nécessaires (ex. jquery-ui/ui/widgets/datepicker). Importer le bundle complet 'jquery-ui' inclut tous les widgets et effets. Le thème CSS doit être importé séparément.
# Install via npm
npm install jquery jquery-ui
# Import in your bundle
import $ from "jquery";
import "jquery-ui/ui/widgets/datepicker";
import "jquery-ui/themes/base/all.css";
// Or import the full bundle
import "jquery-ui";Initialisation de base d'un widget
Tous les widgets jQuery UI suivent le même pattern de plugin : $(selector).widgetName(options). Passez un objet d'options pour configurer, appelez les méthodes via la syntaxe chaîne ('methodName', args...). Enveloppez toujours l'initialisation dans $(function(){}) ou placez le script en fin de body.
$(function () {
// Initialize a widget on a selector
$("#datepicker").datepicker();
$("#dialog").dialog();
// Pass options as an object
$("#accordion").accordion({
active: false,
collapsible: true,
});
// Get or set an option after init
$("#accordion").accordion("option", "active", 1);
});Pattern de méthode des widgets
L'API basée sur chaînes est cohérente entre tous les widgets. 'option' getter/setter, 'enable'/'disable', 'widget' (renvoie l'élément le plus extérieur) et 'destroy' (restaure le balisage d'origine) sont gérés par chaque widget. Employez destroy en retirant des éléments pour éviter les fuites mémoire.
// All widgets share the same API conventions
$("#dialog").dialog("open"); // call a method
$("#dialog").dialog("option", "title"); // get an option
$("#dialog").dialog("option", "modal", true); // set an option
$("#dialog").dialog("disable"); // disable widget
$("#dialog").dialog("enable"); // enable widget
$("#dialog").dialog("widget"); // get the wrapper element
$("#dialog").dialog("destroy"); // remove widget entirelyConfiguration du thème
jQuery UI livre ~24 thèmes préconstruits. Le thème 'base' est le défaut. ThemeRoller (themroller.jqueryui.com) génère des thèmes personnalisés. Chargez votre propre CSS après le base pour surcharger des classes précises comme .ui-widget-header ou .ui-state-default.
<!-- Default base theme -->
<link rel="stylesheet"
href="https://code.jquery.com/ui/1.13.2/themes/base/jquery-ui.css">
<!-- Other bundled themes: ui-lightness, ui-darkness, smoothness, redmond, ... -->
<link rel="stylesheet"
href="https://code.jquery.com/ui/1.13.2/themes/smoothness/jquery-ui.css">
<!-- Override theme with your own CSS -->
<link rel="stylesheet" href="jquery-ui.css">
<link rel="stylesheet" href="my-theme-overrides.css">Convention de nommage des classes
Le framework CSS emploie une convention de nommage ui-* cohérente. Les états d'interaction (default, hover, active, focus) sont appliqués automatiquement par les widgets. Vous pouvez employer ces classes directement dans votre propre balisage pour coller au style jQuery UI.
/* jQuery UI CSS classes are namespaced with ui- */
.ui-widget /* base widget class */
.ui-widget-header /* header bar (accordion, datepicker) */
.ui-widget-content /* content area */
.ui-state-default /* default interactive state */
.ui-state-hover /* mouse-over state */
.ui-state-active /* active/selected state */
.ui-state-focus /* keyboard focus state */
.ui-state-disabled /* disabled state */
.ui-corner-all /* rounded corners (themable) */
.ui-icon /* base icon class */Draggable
Draggable de base
Rendre un élément draggable tient en un seul appel. L'élément peut ensuite être déplacé à la souris. La classe ui-widget-content applique le style du thème par défaut. Draggable hérite du positionnement — relative/absolute/absolute s'applique au besoin.
<!-- HTML -->
<div id="box" class="ui-widget-content" style="width:100px;height:100px;">
Drag me
</div>
<!-- JS -->
<script>
$(function () {
$("#box").draggable();
});
</script>Options de Draggable
Les options contrôlent le comportement du glissement. 'axis' limite le mouvement à un axe, 'containment' restreint la zone de glissement, 'grid' s'aligne sur des intervalles, et 'revert' ramène l'élément à sa position de départ. 'helper: clone' glisse une copie au lieu de l'original.
$("#box").draggable({
axis: "x", // constrain to x or y axis
containment: "parent", // or "window", "document", or selector
cursor: "move", // cursor while dragging
cursorAt: { left: 5 }, // offset cursor from drag handle
grid: [20, 20], // snap to grid
delay: 100, // ms delay before drag starts
distance: 5, // px before drag starts
revert: true, // snap back to start
revertDuration: 200, // revert animation duration
scroll: false, // prevent auto-scroll
helper: "clone", // "original", "clone", or function
opacity: 0.6, // opacity while dragging
zIndex: 1000, // z-index while dragging
});Événements de glissement
Trois événements se déclenchent pendant un glissement : 'start' (une fois au début), 'drag' (en continu pendant le mouvement) et 'stop' (une fois à la fin). L'objet ui fournit position (relatif au parent) et offset (relatif à la page). Un travail lourd dans 'drag' nuit aux performances.
$("#box").draggable({
start: function (event, ui) {
console.log("Drag started", ui.position);
},
drag: function (event, ui) {
// Fires continuously during drag
console.log(ui.position.left, ui.position.top);
},
stop: function (event, ui) {
console.log("Drag stopped at", ui.position);
console.log("Offset:", ui.offset);
},
});Handle et Cancel
'handle' restreint l'initiation du glissement à un élément enfant précis — utile quand toute la boîte doit être déplaçable mais seulement via une barre de titre. 'cancel' empêche le glissement depuis certains éléments comme les inputs ou textareas où l'interaction souris sert à l'édition.
<!-- Only the header acts as the drag handle -->
<div id="box" class="ui-widget-content">
<div class="drag-handle">Drag from here</div>
<div class="content">Some content here</div>
<textarea>Editable content</textarea>
</div>
<script>
$("#box").draggable({
handle: ".drag-handle", // only this starts the drag
cancel: "textarea", // these elements never start a drag
});
</script>Contraindre le mouvement
Containment restreint où l'élément peut être glissé. 'parent', 'window', 'document', un sélecteur ou un tableau explicite [x1,y1,x2,y2] fonctionnent tous. Combiné à 'grid', on obtient un positionnement précis et aligné pour des éditeurs de mise en page ou dashboards.
// Constrain within a parent element
$("#box").draggable({ containment: "parent" });
// Constrain within the window
$("#box").draggable({ containment: "window" });
// Constrain within a specific selector
$("#box").draggable({ containment: "#drag-area" });
// Constrain to an explicit bounding box [x1, y1, x2, y2]
$("#box").draggable({ containment: [0, 0, 500, 300] });
// Snap to a 50px grid
$("#box").draggable({ grid: [50, 50] });Aimantation aux éléments
'snap' fait sauter le draggable pour s'aligner sur les éléments cibles quand il en est assez proche. 'snapMode' contrôle l'alignement : 'inner' (à l'intérieur de la cible), 'outer' (à l'extérieur) ou 'both'. Utile pour construire des outils de diagrammes ou des dispositions de dashboard où les éléments doivent s'aligner.
$(".card").draggable({
snap: ".snap-target", // selector of elements to snap to
snapMode: "inner", // "inner", "outer", or "both"
snapTolerance: 30, // px distance to trigger snap
});
// Snap to all siblings of the same class
$(".card").draggable({
snap: ".card",
snapTolerance: 20,
});Droppable
Droppable de base
Droppable définit une zone cible qui accepte les éléments glissés. Le callback 'drop' se déclenche quand un draggable y est relâché. La propriété ui.draggable donne une référence à l'élément glissé pour le déplacer ou le traiter.
<div id="draggable" class="ui-widget-content">Drag me</div>
<div id="droppable" class="ui-widget-header">Drop here</div>
<script>
$(function () {
$("#draggable").draggable();
$("#droppable").droppable({
drop: function (event, ui) {
$(this).addClass("ui-state-highlight")
.html("Dropped!");
},
});
});
</script>Options de Droppable
'accept' filtre les draggables autorisés — un sélecteur ou une fonction. 'activeClass' et 'hoverClass' offrent un retour visuel. 'greedy: true' empêche des droppables imbriqués de recevoir tous deux l'événement de dépôt, utile pour des zones de dépôt imbriquées.
$("#droppable").droppable({
accept: ".special", // only accept matching draggables
activeClass: "ui-state-default", // class while a drag is active
hoverClass: "ui-state-hover", // class while draggable is over
tolerance: "fit", // drop detection mode
greedy: true, // stop event propagation
disabled: false, // disable the droppable
});Événements de dépôt
Cinq événements couvrent tout le cycle de dépôt. 'activate'/'deactivate' se déclenchent quand un glissement correspondant démarre/se termine. 'over'/'out' quand le draggable entre/sort de la zone. 'drop' seulement lors d'un relâchement réussi. Employez-les pour un retour visuel progressif.
$("#droppable").droppable({
activate: function (event, ui) {
// Fires when an accepted draggable starts moving
$(this).addClass("ui-state-default");
},
deactivate: function (event, ui) {
// Fires when the drag ends (drop or cancel)
$(this).removeClass("ui-state-default");
},
over: function (event, ui) {
// Draggable entered the drop zone
$(this).addClass("ui-state-hover");
},
out: function (event, ui) {
// Draggable left the drop zone
$(this).removeClass("ui-state-hover");
},
drop: function (event, ui) {
// Draggable was released here
console.log("Dropped:", ui.draggable);
},
});Sélecteur accept
'accept' peut être une chaîne de sélecteur ou une fonction renvoyant un booléen. La fonction reçoit l'élément glissé et s'exécute pour chaque candidat, permettant une logique d'exécution comme les attributs data ou les états calculés. Les draggables non acceptés ne déclenchent pas d'événements de dépôt.
<!-- HTML: red and blue boxes -->
<div class="red draggable">Red</div>
<div class="blue draggable">Blue</div>
<div id="red-bin" class="bin">Red bin</div>
<div id="blue-bin" class="bin">Blue bin</div>
<script>
// Only accept elements matching the selector
$("#red-bin").droppable({ accept: ".red" });
$("#blue-bin").droppable({ accept: ".blue" });
// Or use a function for dynamic logic
$("#any-bin").droppable({
accept: function (drag) {
return $(drag).data("category") === "recyclable";
},
});
</script>Modes de tolérance
La tolérance définit le recouvrement requis pour qu'un dépôt s'enregistre. 'fit' est la plus stricte (élément entier à l'intérieur). 'pointer' se base sur le curseur. 'intersect' (50% de recouvrement) est un bon compromis pour la plupart des UI. 'touch' est la plus souple.
$("#droppable").droppable({
// "fit": draggable must be fully inside (default)
tolerance: "fit",
// "intersect": at least 50% overlap
tolerance: "intersect",
// "pointer": mouse pointer must be inside
tolerance: "pointer",
// "touch": any edge touching counts
tolerance: "touch",
});Retour visuel par classes
Combinez activeClass (montrée dès qu'un glissement accepté est en cours) et hoverClass (montrée quand le draggable survole la zone) pour un retour clair. Dans le handler de dépôt, on ajoute typiquement le draggable pour le re-parenter dans la zone.
<!-- CSS -->
<style>
.drop-active { border: 2px dashed #ccc; }
.drop-hover { border: 2px solid #0a0; background: #efe; }
</style>
<!-- JS -->
$("#zone").droppable({
accept: ".item",
activeClass: "drop-active",
hoverClass: "drop-hover",
drop: function (event, ui) {
$(this).append(ui.draggable);
ui.draggable.css({ top: 0, left: 0 });
},
});Resizable
Resizable de base
Resizable ajoute des poignées de redimensionnement à un élément. Par défaut, une poignée apparaît au coin bas-droit (se). L'élément doit avoir un positionnement appliqué (relative/absolute) pour que les poignées s'ancrent correctement.
<div id="box" class="ui-widget-content">
Resize me from the corner
</div>
<script>
$(function () {
$("#box").resizable();
});
</script>Poignées de redimensionnement
'handles' contrôle quels bords/coins reçoivent des prises. Employez les directions de boussole : n, e, s, w, ne, se, sw, nw. Le défaut est 'e, s, se'. On peut fournir des éléments de poignée personnalisés par sélecteur pour un contrôle stylistique total.
$("#box").resizable({
handles: "n, e, s, w, ne, se, sw, nw", // all eight handles
});
// Or specify handle elements
$("#box").resizable({
handles: {
n: ".n-handle",
se: ".se-handle",
},
});Options de Resizable
Les options contraignent et personnalisent le redimensionnement. 'aspectRatio' conserve les proportions (idéal pour images/vidéo). 'alsoResize' synchronise un autre élément. 'ghost' montre un aperçu pâle pendant le redimensionnement, la taille réelle s'appliquant au relâchement. Les dimensions min/max imposent des bornes.
$("#box").resizable({
alsoResize: "#other", // resize another element in sync
animate: true, // animate to final size
animateDuration: 200, // ms
aspectRatio: 16 / 9, // preserve width:height ratio
autoHide: true, // hide handles until hover
containment: "parent", // restrict resize within parent
grid: [10, 10], // snap to grid
maxHeight: 400,
maxWidth: 600,
minHeight: 100,
minWidth: 100,
ghost: true, // show a ghost outline while resizing
});Événements de redimensionnement
Comme draggable, resize déclenche start/resize/stop. L'objet ui porte 'size' (width, height) et 'position' (left, top). En redimensionnant depuis les bords nord ou ouest, taille et position changent tous deux. Employez l'événement resize pour mettre à jour l'UI dépendante comme un aperçu en direct.
$("#box").resizable({
start: function (event, ui) {
console.log("Resize start", ui.size, ui.position);
},
resize: function (event, ui) {
// Fires continuously during resize
ui.size.width; // new width
ui.size.height; // new height
ui.position.left; // new position (may change for n/w handles)
},
stop: function (event, ui) {
console.log("Final size:", ui.size);
},
});Ratio d'aspect et contraintes
Employez aspectRatio (un nombre ou true pour verrouiller le ratio courant) pour les images et médias. Combiné aux contraintes min/max, on prévient les tailles disgracieuses. L'aimantation à la grille s'aligne sur des intervalles — utile pour des interfaces d'édition et outils de mise en page.
// Keep a 4:3 ratio
$("#photo").resizable({ aspectRatio: 4 / 3 });
// Keep ratio and stay within bounds
$("#photo").resizable({
aspectRatio: 4 / 3,
maxWidth: 800,
maxHeight: 600,
minWidth: 100,
minHeight: 75,
});
// Snap to a grid of 20px
$("#grid-box").resizable({ grid: [20, 20] });Modes animate et ghost
'animate' passe en douceur à la nouvelle taille après le relâchement de la souris. 'ghost' montre un aperçu semi-transparent pendant le glissement, n'appliquant le vrai changement qu'au relâchement. Ensemble, ils créent une expérience de redimensionnement soignée, sans à-coups.
// Animate to the final size after release
$("#box").resizable({
animate: true,
animateDuration: "slow", // or ms number
animateEasing: "swing",
});
// Show a ghost outline while dragging, apply on release
$("#box").resizable({
ghost: true,
helper: "ui-resizable-helper", // class for the ghost
});
// Combine both
$("#box").resizable({ ghost: true, animate: true });Selectable
Selectable de base
Selectable transforme une liste d'enfants en groupe sélectionnable. Cliquez pour sélectionner, ou tirez un lasso pour en sélectionner plusieurs. Maintenez Ctrl/Cmd pour ajouter à la sélection, Maj pour une plage. Les items sélectionnés reçoivent automatiquement la classe ui-selected.
<ol id="selectable">
<li class="ui-widget-content">Item 1</li>
<li class="ui-widget-content">Item 2</li>
<li class="ui-widget-content">Item 3</li>
</ol>
<script>
$(function () {
$("#selectable").selectable();
});
</script>Options de Selectable
'filter' restreint les enfants participants. 'tolerance' contrôle le lasso : 'touch' sélectionne au moindre recouvrement (défaut), 'fit' exige l'enfermement complet. Mettez 'autoRefresh: false' pour les grandes listes afin d'améliorer la performance — appelez $(...).selectable('refresh') manuellement après changement de mise en page.
$("#selectable").selectable({
filter: "li", // which children can be selected
tolerance: "touch", // "touch" or "fit" for lasso overlap
distance: 0, // px before lasso starts
delay: 0, // ms delay before lasso starts
autoRefresh: true, // recompute positions on each drag
disabled: false,
cancel: "a, .no-select", // elements that never start selection
});Événements de sélection
Les événements se déclenchent pendant le cycle de sélection : 'selecting'/'unselecting' pendant le glissement, 'selected'/'unselected' une fois confirmés, et 'start'/'stop' pour l'opération globale. Chaque objet ui porte l'élément concerné (selecting, selected, etc.).
$("#selectable").selectable({
selecting: function (event, ui) {
// ui.selecting: element being lassoed
$(ui.selecting).addClass("highlight");
},
selected: function (event, ui) {
// ui.selected: element just confirmed selected
console.log("Selected:", $(ui.selected).text());
},
unselecting: function (event, ui) {
$(ui.unselecting).removeClass("highlight");
},
unselected: function (event, ui) {
console.log("Unselected:", $(ui.unselected).text());
},
start: function (event, ui) { /* lasso started */ },
stop: function (event, ui) { /* lasso released */ },
});Filtrer les items
Employez 'filter' pour n'autoriser que certains enfants à être sélectionnés, et 'cancel' pour en exclure d'autres. Utile pour des galeries où certains items (verrouillés, en lecture seule) ne doivent pas participer. Le lasso ignore simplement les éléments non correspondants.
<ul id="gallery">
<li class="selectable-item">Photo 1</li>
<li class="locked">Locked</li>
<li class="selectable-item">Photo 2</li>
</ul>
<script>
$("#gallery").selectable({
filter: ".selectable-item", // only these can be selected
cancel: ".locked", // locked items never select
});
</script>Styler les items sélectionnés
jQuery UI applique automatiquement les classes ui-selecting (pendant le glissement) et ui-selected (après relâchement). Stylez-les pour donner un retour. Lisez la sélection courante à tout moment via $('.ui-selected') dans le conteneur — pratique pour les barres d'outils et actions groupées.
/* CSS */
#selectable .ui-selecting {
background: #feca40; /* while dragging */
}
#selectable .ui-selected {
background: #f39814; /* confirmed selection */
color: white;
}
#selectable li {
margin: 3px; padding: 6px;
border: 1px solid #ccc;
}
/* selected count badge */
function updateCount() {
var n = $("#selectable .ui-selected").length;
$("#count").text(n + " selected");
}
$("#selectable").on("selectablestop", updateCount);Sélection par programme
Appelez 'refresh' après ajout/retrait d'items pour que le test de collision du lasso reste exact. Il n'y a pas de méthode 'select' intégrée, mais on peut basculer la classe ui-selected manuellement. Effacez en retirant cette classe de tous les items.
// Refresh positions after DOM changes
$("#selectable").selectable("refresh");
// Disable / enable
$("#selectable").selectable("disable");
$("#selectable").selectable("enable");
// Remove the widget
$("#selectable").selectable("destroy");
// Manually select an item (set the class)
$("#selectable li").eq(2).addClass("ui-selected");
// Clear all selections
$("#selectable .ui-selected").removeClass("ui-selected");Sortable
Sortable de base
Sortable rend les items de liste réordonnables par glissement. Les items se déplacent visuellement pendant le glissement et l'ordre du DOM se met à jour au relâchement. Utile pour les listes de tâches, galeries photo et tout contenu ordonné par priorité.
<ul id="sortable">
<li class="ui-widget-content">Item 1</li>
<li class="ui-widget-content">Item 2</li>
<li class="ui-widget-content">Item 3</li>
</ul>
<script>
$(function () {
$("#sortable").sortable();
});
</script>Options de Sortable
Les options affinent le tri. 'placeholder' style l'espace laissé derrière ; forcePlaceholderSize garantit qu'il épouse les dimensions de l'item. 'axis' restreint à horizontal/vertical. 'handle' désigne une prise de glissement — idéal quand l'item tout entier porte des enfants interactifs.
$("#sortable").sortable({
axis: "y", // constrain to vertical
cursor: "move",
handle: ".handle", // drag from this element only
placeholder: "sortable-placeholder", // class for the drop preview
forcePlaceholderSize: true, // match placeholder to item size
helper: "clone", // "original" or "clone"
opacity: 0.7,
revert: true, // animate item into place
tolerance: "pointer", // "intersect" or "pointer"
scroll: true, // auto-scroll the page
containment: "parent", // restrict within parent
});Événements de tri
Événements clés : 'start'/'stop' encadrent le tri. 'change' se déclenche quand la position de l'item change pendant le glissement. 'update' seulement quand l'ordre final diffère du départ — c'est là qu'on persiste le nouvel ordre, souvent via toArray() qui renvoie les IDs des items dans l'ordre.
$("#sortable").sortable({
start: function (event, ui) {
ui.item; // the dragged element
ui.placeholder; // the placeholder element
ui.helper; // the helper being dragged
},
change: function (event, ui) {
// Position in list changed during drag
},
sort: function (event, ui) {
// Fires continuously while sorting
},
beforeStop: function (event, ui) {
// Just before the item is placed
},
stop: function (event, ui) {
console.log("Sort ended");
},
update: function (event, ui) {
// Order actually changed — persist it here
var order = $(this).sortable("toArray");
saveOrder(order);
},
});Listes connectées
'connectWith' relie plusieurs sortables pour que les items passent de l'un à l'autre — parfait pour des tableaux Kanban ou gestionnaires de pipeline. Chaque liste suit toujours son propre ordre via toArray(). Employez les événements receive/remove pour réagir aux transferts entre listes.
<ul id="list-a" class="connected">
<li>Task A1</li><li>Task A2</li>
</ul>
<ul id="list-b" class="connected">
<li>Task B1</li>
</ul>
<script>
$(".connected").sortable({
connectWith: ".connected", // allow moving between lists
placeholder: "ui-state-highlight",
}).disableSelection();
</script>Placeholder et helper
Le placeholder est l'espace vide montré là où l'item atterrira — stylez-le pour un retour de dépôt clair. forcePlaceholderSize est important quand les items ont des hauteurs variables. Une fonction helper personnalisée permet de montrer un aperçu simplifié pendant le glissement.
$("#sortable").sortable({
placeholder: "ui-state-highlight", // class for the gap
forcePlaceholderSize: true,
helper: function (event, el) {
// Return a custom helper element
return $("<div class='custom-helper'>Moving...</div>");
},
cursorAt: { top: 10, left: 10 },
});
// Use a clone as the helper instead of moving the original
$("#sortable").sortable({ helper: "clone" });Méthodes de tri
toArray() renvoie les IDs dans l'ordre courant — le plus utile pour la persistance. serialize() construit une query string quand les IDs suivent la convention 'name_number'. cancel() annule le tri le plus récent. Appelez refresh() après ajout d'items par programme.
// Get current order as an array of IDs
var order = $("#sortable").sortable("toArray");
// ["item-1", "item-3", "item-2"]
// Get option values
var placeholder = $("#sortable").sortable("option", "placeholder");
// Serialize items as a query string (uses id="name_number")
var data = $("#sortable").sortable("serialize");
// "item[]=1&item[]=2&item[]=3"
// Cancel the current sort (revert)
$("#sortable").sortable("cancel");
// Refresh positions after DOM changes
$("#sortable").sortable("refresh");
// Disable / enable / destroy
$("#sortable").sortable("disable");
$("#sortable").sortable("enable");
$("#sortable").sortable("destroy");Accordion
Accordion de base
Accordion attend des paires en-tête + contenu (l'en-tête doit venir en premier). Par défaut, une seule section est ouverte à la fois. L'élément d'en-tête par défaut est h3, modifiable via l'option header. Les panneaux de contenu suivent chaque en-tête.
<div id="accordion">
<h3>Section 1</h3>
<div>Content for section 1</div>
<h3>Section 2</h3>
<div>Content for section 2</div>
<h3>Section 3</h3>
<div>Content for section 3</div>
</div>
<script>
$(function () {
$("#accordion").accordion();
});
</script>Options d'Accordion
Mettez 'collapsible: true' pour autoriser tous les panneaux fermés (le défaut force un ouvert). 'heightStyle: content' dimensionne chaque panneau à son contenu ; 'fill' met tous les panneaux à la hauteur du conteneur ; 'auto' emploie la hauteur du panneau le plus grand.
$("#accordion").accordion({
active: 0, // index of open panel (false = all closed)
collapsible: true, // allow closing all panels
disabled: false,
animate: 200, // ms or "ease name" or false
heightStyle: "content", // "auto", "fill", or "content"
header: "h3", // header selector
icons: {
header: "ui-icon-triangle-1-e",
activeHeader: "ui-icon-triangle-1-s",
},
event: "click", // event that toggles panels
});Événements d'Accordion
beforeActivate permet d'opposer son veto à un changement de panneau en renvoyant false — utile pour les avertissements de modifications non enregistrées. activate se déclenche après la fin de l'animation. L'objet ui donne les en-têtes et panneaux anciens/nouveaux pour les deux événements.
$("#accordion").accordion({
beforeActivate: function (event, ui) {
// ui.oldHeader, ui.oldPanel (closing)
// ui.newHeader, ui.newPanel (opening)
// Return false to cancel
if ($(ui.newHeader).data("locked")) return false;
},
activate: function (event, ui) {
// Fires after a panel finishes opening
console.log("Opened:", ui.newHeader.text());
},
create: function (event, ui) {
// Fires on initialization
console.log("Accordion created, open:", ui.header.text());
},
});Icônes personnalisées
icons mappe les classes d'icônes fermé (header) et ouvert (activeHeader). Passez false pour désactiver les icônes. On peut employer n'importe quelle bibliothèque d'icônes (FontAwesome, Material Icons) en fournissant les classes appropriées — le span d'icône se crée automatiquement.
$("#accordion").accordion({
icons: {
header: "ui-icon-circle-arrow-e",
activeHeader: "ui-icon-circle-arrow-s",
},
});
// Disable icons entirely
$("#accordion").accordion({ icons: false });
// Use your own icon classes (e.g. with FontAwesome)
$("#accordion").accordion({
icons: {
header: "fa fa-plus",
activeHeader: "fa fa-minus",
},
});Collapsible et sections multiples
Pour un vrai accordéon « plusieurs ouverts à la fois », l'accordion de jQuery UI ne le gère pas nativement — initialisez plutôt des accordéons collapsibles séparés par section, ou employez tabs. L'option 'collapsible: true' ne permet que de fermer le panneau actuellement ouvert.
// Allow all panels to be closed
$("#accordion").accordion({
collapsible: true,
active: false, // start with all closed
});
// Make every section independently toggleable
// (a true multi-open accordion = separate collapsibles)
$(".section").each(function () {
$(this).accordion({
collapsible: true,
active: false,
header: ".section-header",
});
});Accordion dynamique
Appelez refresh() après ajout ou retrait de panneaux pour que le widget re-lie. Employez l'option active pour ouvrir un panneau par programme par index. Le pattern beforeActivate est une façon propre de charger paresseusement le contenu d'un panneau par AJAX seulement à la première ouverture.
// Refresh after adding content
$("#accordion").append("<h3>New</h3><div>Content</div>");
$("#accordion").accordion("refresh");
// Switch the open panel
$("#accordion").accordion("option", "active", 2);
// Disable / enable
$("#accordion").accordion("disable");
$("#accordion").accordion("enable");
// Destroy
$("#accordion").accordion("destroy");
// Load content on demand (AJAX-style)
$("#accordion").accordion({
beforeActivate: function (event, ui) {
var panel = ui.newPanel;
if (panel.is(":empty")) {
panel.load("/api/section/" + ui.newHeader.data("id"));
}
},
});Autocomplete
Autocomplete de base
Passez un simple tableau de chaînes à 'source' pour des suggestions statiques. Le widget filtre par sous-chaîne pendant la saisie. Les suggestions apparaissent dans un menu déroulant ; en sélectionner une remplit l'input. La liste peut aussi porter des objets {label, value} pour un affichage plus riche.
<label for="city">City:</label>
<input id="city" type="text">
<script>
$(function () {
var cities = ["London", "Paris", "Berlin", "Madrid", "Rome"];
$("#city").autocomplete({ source: cities });
});
</script>Source de données distante
Quand source est une URL, autocomplete envoie une requête GET avec ?term= le texte tapé et attend un tableau JSON. minLength retarde la requête jusqu'à assez de caractères pour réduire la charge serveur. L'option delay débouncé la frappe rapide.
$("#city").autocomplete({
source: "/api/cities", // server endpoint
minLength: 2, // start suggesting after 2 chars
delay: 300, // ms between keystroke and request
});
// The server should return JSON like:
// ["London", "Paris", "Berlin"]
// or [{ "label": "London, UK", "value": "London" }]Options d'Autocomplete
autoFocus: true met en surbrillance la première suggestion pour qu'Entrée la sélectionne immédiatement. position configure le placement du menu relatif à l'input via jQuery UI Position. appendTo est utile quand l'input est dans un conteneur positionné en absolu avec des problèmes d'overflow.
$("#city").autocomplete({
source: cities, // array, URL, or function
minLength: 1, // chars before suggestions appear
delay: 300, // ms between keystroke and request
autoFocus: true, // focus first item automatically
appendTo: "#container", // where to render the menu
position: { my: "left top", at: "left bottom" },
disabled: false,
});Fonction source personnalisée
Une source fonction donne un contrôle total — utile pour le cache, le filtrage personnalisé ou combiner plusieurs endpoints. Vous DEVEZ appeler response(results) avec un tableau, même vide. Chaque item peut porter des champs arbitraires au-delà de label/value, accessibles dans le handler select.
$("#city").autocomplete({
source: function (request, response) {
// request.term is the typed text
// response() must be called with the results array
$.getJSON("/api/cities", { q: request.term })
.done(function (data) {
response(data);
})
.fail(function () {
response([]); // always call response, even on error
});
},
select: function (event, ui) {
// ui.item.label, ui.item.value
$("#city-id").val(ui.item.id);
},
});Événements d'Autocomplete
focus se déclenche quand l'utilisateur parcourt les suggestions (clavier ou survol). select quand un item est choisi. change au blur, au bon endroit pour valider que la valeur finale existe dans la source. Renvoyer false empêche le remplissage par défaut de l'input.
$("#city").autocomplete({
source: cities,
focus: function (event, ui) {
// Fires when an item is highlighted (not selected)
$("#preview").text(ui.item.label);
return false; // prevent setting the input value on focus
},
select: function (event, ui) {
// Fires when an item is chosen
$("#city").val(ui.item.label);
$("#city-id").val(ui.item.value);
return false; // prevent default behavior
},
change: function (event, ui) {
// Fires when input loses focus
if (!ui.item) {
// User typed something not in the list
console.log("No match:", this.value);
}
},
});Catégories et rendu personnalisé
Surchargez _renderMenu ou _renderItem pour personnaliser la disposition du menu déroulant. Cet exemple groupe les suggestions par catégorie avec des lignes d'en-tête. Le pattern $.widget étend l'autocomplete de base, toutes les options et événements d'origine fonctionnent donc. Courant pour les interfaces de recherche.
$.widget("custom.catcomplete", $.ui.autocomplete, {
_renderMenu: function (ul, items) {
var that = this, currentCategory = "";
$.each(items, function (index, item) {
if (item.category !== currentCategory) {
ul.append("<li class='ui-autocomplete-category'>"
+ item.category + "</li>");
currentCategory = item.category;
}
that._renderItemData(ul, item);
});
},
});
// Use the new widget
$("#search").catcomplete({
source: [
{ label: "Java", category: "Languages" },
{ label: "JavaScript", category: "Languages" },
{ label: "React", category: "Frameworks" },
],
});Datepicker
Datepicker de base
Cliquer ou focaliser l'input ouvre un popup de calendrier. La date choisie remplit l'input en texte. Le calendrier montre le mois courant avec des flèches de navigation mois précédent/suivant. Par défaut, les dates emploient le format US (mm/dd/yy).
<label for="date">Pick a date:</label>
<input type="text" id="date">
<script>
$(function () {
$("#date").datepicker();
});
</script>Options de Datepicker
minDate/maxDate acceptent un objet Date, un nombre (jours à partir d'aujourd'hui) ou une chaîne ('+1M +1W'). numberOfMonths affiche plusieurs mois — pratique pour les sélecteurs de plage de dates. changeMonth/changeYear ajoutent des menus déroulants pour sauter vers des années lointaines.
$("#date").datepicker({
dateFormat: "yy-mm-dd", // ISO format
defaultDate: "+1", // tomorrow when calendar opens
minDate: 0, // no past dates (today+)
maxDate: "+1Y", // up to one year ahead
numberOfMonths: 2, // show 2 months side by side
showButtonPanel: true, // Today/Done buttons
changeMonth: true, // dropdown for month
changeYear: true, // dropdown for year
showAnim: "fadeIn", // open animation
duration: "fast",
firstDay: 1, // start week on Monday
showWeek: true, // show week numbers
});Format de date
L'option dateFormat emploie des jetons à la PHP. 'yy' signifie année à quatre chiffres (le y supplémentaire est voulu). Employez la méthode formatDate() pour convertir une Date en chaîne avec les mêmes jetons, et parseDate() pour l'inverse.
$("#date").datepicker({
dateFormat: "yy-mm-dd", // 2026-07-04
});
// Format tokens:
// d - day of month, no leading zero (1)
// dd - day, two digits (01)
// D - short day name (Mon)
// DD - full day name (Monday)
// m - month, no leading zero (1)
// mm - month, two digits (01)
// M - short month name (Jan)
// MM - full month name (January)
// y - two-digit year (26)
// yy - four-digit year (2026)
// @ - Unix timestamp
// ! - Windows ticks
// Common formats:
// "mm/dd/yy" -> 07/04/2026
// "yy-mm-dd" -> 2026-07-04
// "DD, MM d, yy" -> Friday, July 4, 2026Dates min/max et plages
Pour un sélecteur de plage, reliez deux datepickers : quand le début est choisi, réglez le minDate de la fin ; quand la fin est choisie, réglez le maxDate du début. beforeShowDay permet de désactiver ou styler des jours individuels — noWeekends est un utilitaire intégré qui bloque samedis et dimanches.
// Restrict to a date range
$("#start").datepicker({
minDate: 0,
maxDate: "+6M",
onSelect: function (dateText) {
// Set the end date's minimum to the start date
$("#end").datepicker("option", "minDate", dateText);
},
});
$("#end").datepicker({
minDate: 0,
maxDate: "+6M",
onSelect: function (dateText) {
$("#start").datepicker("option", "maxDate", dateText);
},
});
// Disable weekends
$("#date").datepicker({
beforeShowDay: $.datepicker.noWeekends,
});Localisation
jQuery UI livre des fichiers régionaux dans le dossier i18n pour ~40 locales. Chargez le fichier et appliquez avec $.datepicker.regional['fr']. On peut aussi surcharger des chaînes individuelles en ligne. Le fichier régional règle d'un coup noms de mois, noms de jours, firstDay et dateFormat.
// Set the regionalization
$("#date").datepicker($.datepicker.regional["fr"]);
// Override specific strings
$("#date").datepicker({
monthNames: ["janvier","février","mars","avril","mai","juin",
"juillet","août","septembre","octobre","novembre","décembre"],
dayNamesMin: ["Di","Lu","Ma","Me","Je","Ve","Sa"],
firstDay: 1,
dateFormat: "dd/mm/yy",
prevText: "Précédent",
nextText: "Suivant",
closeText: "Fermer",
currentText: "Aujourd'hui",
});
// Include the regional file for built-in locales:
// <script src="jquery-ui/i18n/datepicker-fr.js"></script>Datepicker inline et événements
Appliquez datepicker à une div au lieu d'un input pour un calendrier inline toujours visible — parfait pour des interfaces de réservation. onSelect se déclenche au choix d'une date, onChangeMonthYear à la navigation entre mois. getDate/setDate travaillent avec des objets Date pour un contrôle par programme.
<!-- Inline (always visible) calendar -->
<div id="inline-calendar"></div>
<script>
$("#inline-calendar").datepicker({
onSelect: function (dateText, inst) {
console.log("Selected:", dateText);
},
onChangeMonthYear: function (year, month, inst) {
console.log("Viewing:", month + "/" + year);
},
beforeShow: function (input, inst) {
// Fires before the popup opens
return { /* override options */ };
},
onClose: function (dateText, inst) {
// Fires when the popup closes
},
});
// Methods
$("#date").datepicker("setDate", "+7"); // set to a week from today
$("#date").datepicker("getDate"); // returns a Date object
$("#date").datepicker("option", "minDate", new Date(2026, 0, 1));
</script>Dialog
Dialog de base
L'attribut title de l'élément devient la barre de titre du dialogue. Le dialogue s'ouvre automatiquement par défaut et est déplaçable/redimensionnable. L'élément est déplacé dans un enveloppeur jQuery UI avec empilement z-index correct. Fermez via le bouton X ou la touche Échap.
<div id="dialog" title="Basic dialog">
<p>This is a simple dialog window.</p>
</div>
<script>
$(function () {
$("#dialog").dialog();
});
</script>Options de Dialog
Mettez autoOpen: false pour créer le dialogue caché, puis appelez dialog('open') au besoin — c'est le pattern standard des dialogues à la demande. modal ajoute un overlay qui bloque l'interaction avec la page. position emploie l'utilitaire jQuery UI Position pour un placement précis.
$("#dialog").dialog({
autoOpen: false, // don't open on init
modal: true, // dim the page behind
width: 400,
height: "auto",
minWidth: 200,
maxWidth: 600,
resizable: true,
draggable: true,
closeOnEscape: true,
position: { my: "center", at: "center", of: window },
title: "Custom Title", // override the title attr
show: { effect: "fade", duration: 200 },
hide: { effect: "fade", duration: 200 },
});Boutons du dialogue
buttons accepte un tableau (préféré, permet icônes et options par bouton) ou un objet (texte : handler). Dans un handler, 'this' est l'élément dialogue — appelez $(this).dialog('close') pour fermer. Les boutons sont thémés et alignés à droite par défaut.
$("#dialog").dialog({
buttons: [
{
text: "Save",
icon: "ui-icon-disk",
click: function () {
saveForm();
$(this).dialog("close");
},
},
{
text: "Cancel",
click: function () {
$(this).dialog("close");
},
},
],
});
// Shortcut object form (1.12+)
$("#dialog").dialog({
buttons: {
"Save": function () { saveForm(); $(this).dialog("close"); },
"Cancel": function () { $(this).dialog("close"); },
},
});Événements du dialogue
beforeClose est le gardien — renvoyez false pour garder le dialogue ouvert (utile pour les avertissements de modifications non enregistrées). close se déclenche après la fermeture, au bon endroit pour réinitialiser l'état du formulaire ou libérer les ressources. Les événements drag/resize reflètent ceux des interactions sous-jacentes.
$("#dialog").dialog({
beforeClose: function (event, ui) {
// Return false to prevent closing
if (!confirm("Discard changes?")) return false;
},
open: function (event, ui) {
console.log("Dialog opened");
},
close: function (event, ui) {
console.log("Dialog closed");
// Clean up form state
$(this).find("form")[0].reset();
},
focus: function (event, ui) {
// Dialog gained focus
},
dragStart: function (event, ui) { /* dragging started */ },
dragStop: function (event, ui) { /* dragging ended */ },
resizeStart: function (event, ui) { /* resizing started */ },
resizeStop: function (event, ui) { /* resizing ended */ },
});Dialogue modal et de confirmation
Créez un dialogue depuis un élément construit dynamiquement pour des confirmations ponctuelles. L'overlay modal empêche l'interaction avec le reste de la page. Détruisez toujours et retirez l'élément dans le handler close pour ne pas fuiter des nœuds DOM quand le dialogue se ferme.
function confirmDialog(message, onConfirm) {
$("<div>" + message + "</div>").dialog({
modal: true,
title: "Confirm",
buttons: {
"OK": function () {
onConfirm();
$(this).dialog("close");
},
"Cancel": function () {
$(this).dialog("close");
},
},
close: function () {
$(this).dialog("destroy").remove(); // clean up
},
});
}
// Usage
confirmDialog("Delete this item?", function () {
deleteItem();
});Contenu AJAX et méthodes
Employez l'événement open pour charger le contenu par AJAX et initialiser tout widget imbriqué. Videz toujours le contenu à la fermeture pour que la prochaine ouverture soit fraîche. moveToTop élève le dialogue au-dessus des autres en z-index — utile pour des dialogues empilés. isOpen est un getter booléen pour la logique conditionnelle.
// Load content from a URL when opening
function openEditDialog(id) {
var $dlg = $("#edit-dialog");
$dlg.dialog({
autoOpen: false,
modal: true,
open: function () {
$dlg.load("/api/edit/" + id, function () {
// Initialize widgets in loaded content
$dlg.find(".datepicker").datepicker();
});
},
close: function () {
$dlg.empty(); // clear for next open
},
});
$dlg.dialog("open");
}
// Common methods
$("#dialog").dialog("open");
$("#dialog").dialog("close");
$("#dialog").dialog("isOpen"); // returns boolean
$("#dialog").dialog("moveToTop"); // bring to front
$("#dialog").dialog("option", "title", "New Title");Progressbar
Progressbar de base
Progressbar montre une barre horizontale remplie à un pourcentage (0-100). L'option value règle la progression courante. La barre se thème automatiquement avec le style jQuery UI. La largeur du conteneur détermine la largeur totale — réglez-la via CSS.
<div id="progress"></div>
<script>
$(function () {
$("#progress").progressbar({ value: 37 });
});
</script>Mode indéterminé
Mettre value à false place la barre en mode indéterminé — une rayure animée indique « quelque chose se passe » sans pourcentage précis. Employez-le quand le total est inconnu (ex. en attente d'un serveur). Repassez à un nombre dès que la progression devient traçable.
<div id="progress"></div>
<script>
// Set value to false for an indeterminate (animated) bar
$("#progress").progressbar({ value: false });
// Switch to determinate later when you know the percent
$("#progress").progressbar("option", "value", 50);
</script>Options de Progressbar
L'option 'max' permet des échelles non centésimales (ex. max: 1000 pour un téléchargement en Ko). La valeur s'interprète comme fraction du max. L'option classes (1.12+) permet d'ajouter des classes personnalisées à des éléments internes précis pour un theming fin.
$("#progress").progressbar({
value: 0, // 0-100, or false for indeterminate
max: 100, // upper bound (default 100)
disabled: false,
// 1.12+ supports a 'classes' option for theming
classes: {
"ui-progressbar": "highlight",
"ui-progressbar-value": "animated",
},
});Mettre à jour la valeur
Mettez à jour la barre en réglant l'option value. Une boucle setInterval simule la progression pour les uploads ou tâches longues. Pour de vrais uploads, employez l'événement de progression XHR pour régler value selon les octets transférés. Videz toujours le minuteur à la fin.
// Simulate a file upload
var progress = 0;
$("#progress").progressbar({ value: 0 });
var timer = setInterval(function () {
progress += 5;
$("#progress").progressbar("option", "value", progress);
if (progress >= 100) {
clearInterval(timer);
console.log("Complete!");
}
}, 200);
// Get current value
var current = $("#progress").progressbar("option", "value");Événement change et labels personnalisés
change se déclenche à chaque mise à jour de la valeur, complete à 100% — tous deux utiles pour un style ou des labels dynamiques. Pour montrer le texte du pourcentage, ajoutez un label positionné en absolu au-dessus de la barre. Mettez-le à jour dans le handler change pour le garder synchronisé.
$("#progress").progressbar({
value: 0,
change: function () {
var v = $("#progress").progressbar("value");
$("#progress .ui-progressbar-value")
.css("background", v < 50 ? "#fa0" : "#0a0");
},
complete: function () {
$("#progress .ui-progressbar-value").css("background", "#0a0");
$("#progress-label").text("Done!");
},
});
// Overlay a text label
$("#progress").append(
'<div id="progress-label" style="position:absolute;left:50%;top:0;">Loading...</div>'
);Slider
Slider de base
Slider crée une poignée déplaçable sur une piste horizontale. La plage par défaut est 0-100 avec la poignée à 0. La piste est entièrement thémée. Réglez les dimensions via CSS sur le conteneur — largeur pour un slider horizontal, hauteur pour un vertical.
<div id="slider"></div>
<script>
$(function () {
$("#slider").slider();
});
</script>Options de Slider
Employez 'values' (tableau) au lieu de 'value' pour un slider de plage à deux poignées. 'range: true' ombrage la zone entre les poignées ; 'range: min' de la poignée au minimum ; 'range: max' de la poignée au maximum. 'step' doit diviser exactement (max - min).
$("#slider").slider({
min: 0,
max: 100,
step: 1, // increment size
value: 50, // single value
values: [25, 75], // two-handle range (omit 'value')
orientation: "horizontal", // or "vertical"
range: true, // or "min", "max"
disabled: false,
animate: "fast", // or ms, or false
});Événements de Slider
slide se déclenche en continu pendant le glissement — idéal pour mettre à jour un label en direct. Renvoyer false dans slide annule le mouvement, utile pour contraindre dynamiquement les valeurs. change se déclenche après le relâchement et aux changements d'options par programme ; servez-vous en pour persister la valeur.
$("#slider").slider({
start: function (event, ui) {
// User started dragging a handle
console.log("Start:", ui.value || ui.values);
},
slide: function (event, ui) {
// Fires continuously during drag
// Return false to prevent the handle from moving
$("#label").text(ui.value);
},
change: function (event, ui) {
// Fires after the handle is released (and on programmatic change)
saveValue(ui.value);
},
stop: function (event, ui) {
// User released the handle
},
});Slider de plage
Un slider de plage à deux poignées se construit en réglant range: true et en fournissant un tableau values. ui.values[0] est la poignée basse, ui.values[1] la haute. Les poignées ne peuvent se croiser. C'est le pattern classique des filtres de prix ou de plage de dates.
<div id="range-slider"></div>
<p>Price: $<span id="min-price"></span> - $<span id="max-price"></span></p>
<script>
$("#range-slider").slider({
range: true,
min: 0,
max: 500,
values: [75, 300],
slide: function (event, ui) {
$("#min-price").text(ui.values[0]);
$("#max-price").text(ui.values[1]);
},
});
</script>Vertical et orientations
Les sliders verticaux exigent une hauteur explicite via CSS — la largeur s'applique à l'axe transversal. La poignée bouge haut/bas au lieu de gauche/droite. L'ombrage de plage fonctionne pareil. Utile pour des mixeurs audio, égaliseurs ou toute UI où la vertical est plus naturel.
// Vertical slider
$("#vertical").slider({
orientation: "vertical",
min: 0,
max: 100,
value: 60,
});
// Vertical range
$("#vertical-range").slider({
orientation: "vertical",
range: true,
min: 0,
max: 100,
values: [20, 80],
});
/* CSS: vertical sliders need a height */
/* #vertical { height: 200px; } */
</script>Méthodes de Slider
Pour les sliders de plage, employez values() (sans argument) pour obtenir un tableau, values(index, value) pour régler une poignée, ou values(tableau) pour les deux. Régler des options comme min/max/step à l'exécution repositionne automatiquement les poignées dans les nouvelles bornes.
// Get or set the value
$("#slider").slider("value");
$("#slider").slider("value", 75);
// Get or set both handles of a range slider
var vals = $("#slider").slider("values"); // [25, 75]
$("#slider").slider("values", 0, 30); // set lower handle
$("#slider").slider("values", [30, 90]); // set both
// Get or set options
$("#slider").slider("option", "max", 200);
$("#slider").slider("option", "disabled", true);
// Disable / enable / destroy
$("#slider").slider("disable");
$("#slider").slider("enable");
$("#slider").slider("destroy");Spinner
Spinner de base
Spinner ajoute des boutons haut/bas à un input texte pour la saisie numérique. L'utilisateur peut taper directement, cliquer les boutons ou employer les flèches du clavier. Maintenir un bouton accélère l'incrément. La valeur de l'input se parse en nombre à chaque changement.
<label for="qty">Quantity:</label>
<input id="qty" type="text" value="1">
<script>
$(function () {
$("#qty").spinner();
});
</script>Options de Spinner
min/max imposent des bornes — les boutons ne dépassent pas. step contrôle la taille de l'incrément (employez des décimaux comme 0.1 pour un contrôle fin). numberFormat avec culture active un formatage localisé (ex. 'C' avec 'ja-JP' montre le yen). Globalize.js doit être chargé pour le support des cultures.
$("#qty").spinner({
min: 0, // minimum value
max: 100, // maximum value
step: 1, // increment size
page: 10, // page up/down increment
numberFormat: "n", // "n" for number, "C" for currency
culture: "en-US", // locale for formatting
disabled: false,
incremental: true, // accelerate while holding
icons: {
up: "ui-icon-triangle-1-n",
down: "ui-icon-triangle-1-s",
},
});Formatage des nombres et culture
Avec Globalize.js chargé, spinner formate les valeurs selon la culture spécifiée — symboles monétaires, séparateurs décimaux et de milliers se localisent tous. numberFormat 'C' est la devise, 'n' le nombre avec compte de décimales optionnel (n2 = 2 décimales). Utile pour les formulaires internationalisés.
<!-- Requires Globalize.js for culture support -->
<script src="globalize.js"></script>
<script src="globalize.culture.ja-JP.js"></script>
<script>
// Currency spinner (Japanese yen)
$("#price").spinner({
numberFormat: "C",
culture: "ja-JP",
step: 100,
min: 0,
});
// Decimal spinner
$("#weight").spinner({
step: 0.01,
numberFormat: "n2", // 2 decimal places
min: 0,
});
</script>Événements de Spinner
spin se déclenche à chaque incrément/décrément (clic bouton ou touche flèche). Renvoyer false annule le changement — idéal pour une validation personnalisée. change au blur ; ui.value est null si l'input ne se parse pas en nombre valide, l'endroit pour montrer les erreurs de validation.
$("#qty").spinner({
spin: function (event, ui) {
// Fires when a button is clicked or arrow pressed
// ui.value is the new value
// Return false to cancel the change
if (ui.value > 10) {
alert("Max 10 per order");
return false;
}
},
change: function (event, ui) {
// Fires when the value changes and input loses focus
// ui.value may be null if invalid
if (ui.value === null) {
alert("Please enter a valid number");
}
},
start: function (event, ui) { /* spin started */ },
stop: function (event, ui) { /* spin stopped */ },
});Pas personnalisé et méthodes
stepUp/stepDown/pageUp/pageDown simulent les pressions de boutons par programme. value() sans argument est un getter ; avec argument un setter qui passe par la validation. Les handlers spin personnalisés permettent de bâtir des spinners non numériques comme des heures, couleurs ou unités personnalisées.
// Time spinner (steps of 15 minutes)
$("#time").spinner({
step: 15,
min: 0,
max: 1439, // 24 * 60 - 1
numberFormat: "n0",
spin: function (event, ui) {
// Wrap around at midnight
if (ui.value > 1439) return false; // or wrap: $(this).spinner("value", 0);
},
});
// Methods
$("#qty").spinner("value"); // get current value
$("#qty").spinner("value", 5); // set value
$("#qty").spinner("stepUp"); // increment by one step
$("#qty").spinner("stepDown"); // decrement by one step
$("#qty").spinner("pageUp"); // increment by 'page' steps
$("#qty").spinner("pageDown");
$("#qty").spinner("disable");
$("#qty").spinner("enable");
$("#qty").spinner("destroy");Validation et parsing personnalisé
Surchargez _parse et _format pour bâtir des spinners pour des valeurs non décimales — couleurs hexa, heures, angles ou toute unité personnalisée. _parse convertit le texte de l'input en nombre ; _format reconvertit pour l'affichage. C'est la façon la plus propre d'étendre spinner aux entrées spécifiques au domaine.
// Custom spinner for hexadecimal colors
$.widget("custom.hexspinner", $.ui.spinner, {
_parse: function (value) {
// String -> number
return parseInt(value, 16);
},
_format: function (value) {
// number -> string
return value.toString(16).toUpperCase().padStart(6, "0");
},
});
$("#color").hexspinner({
min: 0x000000,
max: 0xffffff,
step: 0x10,
});
// Prevent invalid input
$("#qty").on("keydown", function (e) {
if (e.key === "-" && $(this).spinner("option", "min") >= 0) {
e.preventDefault();
}
});Tabs
Tabs de base
Tabs attend un ul de liens pointant vers les IDs des panneaux de contenu, suivi des panneaux eux-mêmes. Les href des liens (#tab-1) relient onglets et panneaux. Le premier onglet est actif par défaut. Les onglets sont navigables au clavier (flèches, Home, End) et conformes ARIA.
<div id="tabs">
<ul>
<li><a href="#tab-1">First</a></li>
<li><a href="#tab-2">Second</a></li>
<li><a href="#tab-3">Third</a></li>
</ul>
<div id="tab-1">Content 1</div>
<div id="tab-2">Content 2</div>
<div id="tab-3">Content 3</div>
</div>
<script>
$(function () {
$("#tabs").tabs();
});
</script>Options de Tabs
active règle l'onglet ouvert initialement par index (ou false pour démarrer replié). heightStyle 'fill' met tous les panneaux à la hauteur du conteneur ; 'content' dimensionne chacun à son contenu (défaut). 'event: mouseover' crée des onglets activés au survol.
$("#tabs").tabs({
active: 0, // index of active tab (false = all hidden)
collapsible: false, // allow closing the active tab
disabled: [], // array of disabled indices
event: "click", // event to switch tabs ("mouseover" etc.)
heightStyle: "content", // "auto", "fill", or "content"
show: { effect: "fadeIn", duration: 200 },
hide: { effect: "fadeOut", duration: 200 },
});Événements de Tabs
beforeActivate est le gardien — renvoyez false pour bloquer le changement (ex. avertissement de modifications non enregistrées). activate se déclenche après la fin du changement. beforeLoad/load servent aux onglets AJAX — beforeLoad permet de personnaliser ou annuler la requête ; load se déclenche au succès.
$("#tabs").tabs({
beforeActivate: function (event, ui) {
// ui.newTab, ui.newPanel (opening)
// ui.oldTab, ui.oldPanel (closing)
// Return false to cancel the switch
if ($(ui.newPanel).find("form").hasUnsavedChanges()) {
return confirm("Discard changes?");
}
},
activate: function (event, ui) {
// Fires after the new tab is shown
console.log("Now on:", ui.newTab.text());
},
beforeLoad: function (event, ui) {
// For AJAX tabs — fires before loading remote content
ui.jqXHR.error(function () {
ui.panel.text("Failed to load content.");
});
},
load: function (event, ui) {
// AJAX content finished loading
},
});Onglets AJAX
Quand le href d'un onglet est une URL (pas une ancre), tabs charge le contenu par AJAX à l'activation. La réponse remplace le panneau. beforeLoad permet de montrer un spinner, configurer la requête AJAX ou l'annuler. Le contenu chargé se met en cache pour la session par défaut en 1.12+.
<div id="tabs">
<ul>
<li><a href="#local">Local</a></li>
<li><a href="remote.html">Remote (AJAX)</a></li>
<li><a href="api/data.json">API Data</a></li>
</ul>
<div id="local">This content is in the page.</div>
<!-- Remote panels are created automatically -->
</div>
<script>
$("#tabs").tabs({
beforeLoad: function (event, ui) {
// Show a loading indicator
ui.panel.html("Loading...");
// Cache the loaded content
ui.ajaxSettings.cache = true;
},
});
</script>Onglets collapsibles et sortables
Avec collapsible: true, cliquer l'onglet actif le ferme (aucun onglet ne reste ouvert). Associer tabs à sortable sur la nav laisse les utilisateurs réordonner les onglets par glissement. Après ajout ou retrait d'onglets/panneaux, appelez refresh() pour que le widget re-lie la nouvelle structure.
// Allow collapsing the active tab
$("#tabs").tabs({ collapsible: true });
// Make tabs reorderable by drag
$("#tabs").tabs().find(".ui-tabs-nav").sortable({
axis: "x",
stop: function () {
$("#tabs").tabs("refresh");
},
});
// Dynamically add a new tab
function addTab(id, label, content) {
var nav = $("#tabs .ui-tabs-nav");
nav.append('<li><a href="#' + id + '">' + label + '</a></li>');
$("#tabs").append('<div id="' + id + '">' + content + '</div>');
$("#tabs").tabs("refresh");
}Méthodes de Tabs
disable/enable acceptent un index ou un tableau d'indices. L'option active est à la fois getter et setter de l'onglet courant — employez-la pour changer par programme. load() recharge le contenu AJAX d'un onglet. refresh() est essentielle après ajout, retrait ou réordonnancement d'onglets.
// Disable / enable specific tabs
$("#tabs").tabs("disable", 1); // disable second tab
$("#tabs").tabs("enable", 1);
$("#tabs").tabs("option", "disabled", [0, 2]); // disable multiple
// Switch to a tab by index
$("#tabs").tabs("option", "active", 2);
// Reload an AJAX tab
$("#tabs").tabs("load", 1);
// Refresh after structural changes
$("#tabs").tabs("refresh");
// Get the active tab index
var active = $("#tabs").tabs("option", "active");
// Destroy
$("#tabs").tabs("destroy");Tooltip
Tooltip de base
Appeler tooltip() sur document remplace tous les tooltips title natifs par des versions thémées jQuery UI. Le contenu de l'attribut title devient le texte du tooltip. Les tooltips apparaissent au survol et disparaissent en sortie de souris, avec animation de fondu par défaut.
<label for="age">Age:</label>
<input id="age" title="Please enter your age in years">
<script>
$(function () {
$(document).tooltip();
});
</script>Options de Tooltip
Surchargez 'content' comme fonction pour générer du HTML de tooltip dynamique (ex. depuis des attributs data ou AJAX). 'items' est un sélecteur contrôlant quels éléments déclenchent des tooltips. 'track: true' fait suivre le curseur au tooltip — utile pour des textes d'aide détaillés sur des diagrammes.
$(document).tooltip({
content: function () {
// Default: returns the element's title attribute
return $(this).attr("title");
},
items: "[title]", // which elements get tooltips
position: { my: "left top+15", at: "left bottom" },
show: { effect: "fadeIn", duration: 200 },
hide: { effect: "fadeOut", duration: 200 },
tooltipClass: "custom-tooltip", // class for the tooltip div
track: false, // follow the mouse cursor
disabled: false,
close: null, // (event defaults handle this)
});Contenu personnalisé
La fonction content permet de bâtir des tooltips riches avec HTML, images ou contenu récupéré par AJAX. Renvoyez une chaîne (HTML admis). tooltipClass ajoute une classe personnalisée pour le style. C'est le pattern standard des aperçus de miniatures ou bulles d'aide sur les champs de formulaire.
<!-- HTML with data attributes -->
<a href="#" class="help" data-help="Click to save your changes">Save</a>
<a href="#" class="help" data-help="Undo the last action">Undo</a>
<script>
$(".help").tooltip({
content: function () {
return "<strong>Help:</strong> " + $(this).data("help");
},
tooltipClass: "help-tooltip",
});
</script>
<!-- With an image preview -->
$(".thumb").tooltip({
content: function () {
var src = $(this).attr("href");
return "<img src='" + src + "' width='200'>";
},
});Événements de Tooltip
open et close se déclenchent quand les tooltips apparaissent et disparaissent. La propriété ui.tooltip donne l'élément tooltip pour la personnalisation. Un pattern courant est de garder le tooltip ouvert tant que l'utilisateur le survole — utile quand il contient du contenu interactif comme des liens.
$(".help").tooltip({
open: function (event, ui) {
// Tooltip just appeared
ui.tooltip; // the tooltip element
},
close: function (event, ui) {
// Tooltip just disappeared
ui.tooltip.one("transitionend", function () {
// Cleanup after the hide animation
});
},
create: function (event, ui) {
// Widget initialized
},
});
// Prevent tooltip from closing on hover
$(".help").tooltip({
close: function (event, ui) {
ui.tooltip.hover(
function () { $(this).stop(true).fadeIn(); },
function () { $(this).fadeOut(); }
);
},
});Position et méthodes
Position emploie l'utilitaire jQuery UI Position : 'my' est l'ancre du tooltip, 'at' celle de la cible. collision gère les cas limites — 'flip' passe de l'autre côté en cas de débordement. open()/close() montrent/masquent les tooltips par programme, utile pour les erreurs de validation.
$("#target").tooltip({
position: {
my: "center top", // tooltip's anchor point
at: "center bottom", // target's anchor point
of: "#target", // optional: position relative to this
collision: "flip", // "flip", "fit", "flipfit", "none"
using: function (pos, feedback) {
$(this).css(pos);
console.log(feedback.horizontal, feedback.vertical);
},
},
});
// Methods
$("#target").tooltip("open"); // show programmatically
$("#target").tooltip("close"); // hide programmatically
$("#target").tooltip("disable");
$("#target").tooltip("enable");
$("#target").tooltip("widget"); // get the tooltip div
$("#target").tooltip("destroy");Tooltips de validation de formulaire
Les tooltips sont une façon propre de montrer les erreurs de validation en ligne. Stockez le message d'erreur dans un attribut data, réglez content pour le lire, et appelez open() pour afficher. Renvoyer false dans le handler open empêche le tooltip quand il n'y a pas d'erreur. Stylez avec tooltipClass pour un style d'erreur rouge.
<!-- Show validation errors as tooltips -->
<form id="form">
<input id="email" type="text" placeholder="Email">
<input id="submit" type="submit" value="Submit">
</form>
<script>
$("#form").tooltip({
items: "input",
content: function () {
return $(this).data("error") || "";
},
position: { my: "left top", at: "left bottom+5" },
tooltipClass: "error-tooltip",
open: function (event, ui) {
var el = $(event.originalEvent.target);
if (!el.data("error")) return false; // don't show if no error
},
});
$("#submit").on("click", function (e) {
var email = $("#email").val();
if (!email.includes("@")) {
e.preventDefault();
$("#email").data("error", "Please enter a valid email")
.tooltip("open");
}
});
</script>Effets
Effets du cœur
jQuery UI étend les show/hide/toggle de jQuery avec des effets nommés et ajoute la méthode .effect() pour les animations sans masquage. Chacun accepte un objet d'options, une durée et un callback. 'transfer' crée un contour d'élément de transfert — utile pour les animations d'ajout au panier.
// Built-in effects (beyond jQuery's show/hide/toggle)
$("#box").hide("fade", {}, 1000); // fade out
$("#box").show("slide", {}, 500); // slide in
$("#box").toggle("explode", {}, 800); // explode toggle
$("#box").effect("bounce", { times: 3 }, 300);
// Available effect names:
// blind, bounce, clip, drop, explode, fade, fold,
// highlight, puff, pulsate, scale, shake, size, slide, transferFonctions d'easing
Le cœur d'effets de jQuery UI ajoute ~30 fonctions d'easing de Robert Penner au-delà des 'swing' et 'linear' par défaut de jQuery. Employez-les dans tout appel .animate(), l'option easing de show/hide/toggle, ou en troisième argument. 'easeOutBounce' et 'easeOutElastic' sont populaires pour des UI ludiques.
// jQuery core provides: swing (default), linear
// jQuery UI adds ~30 more easing functions
$("#box").animate({ width: 500 }, 1000, "easeInOutBounce");
// Available easings (subset):
// easeInQuad, easeOutQuad, easeInOutQuad
// easeInCubic, easeOutCubic, easeInOutCubic
// easeInQuart, easeOutQuart, easeInOutQuart
// easeInExpo, easeOutExpo, easeInOutExpo
// easeInBack, easeOutBack, easeInOutBack
// easeInBounce, easeOutBounce, easeInOutBounce
// easeInElastic, easeOutElastic, easeInOutElasticShow/Hide/Toggle avec effets
Passez un nom d'effet en premier argument à show/hide/toggle pour animer. Le second argument est un objet d'options (direction, distance, percent, etc. selon l'effet). Le troisième est la durée ; le quatrième un callback. Les effets sur des éléments cachés fonctionnent via show().
// show with an effect
$("#box").show("drop", { direction: "left" }, 500);
// hide with an effect
$("#box").hide("puff", {}, 500);
// toggle with an effect
$("#box").toggle("scale", { percent: 0 }, 500);
// With a callback
$("#box").hide("blind", 500, function () {
console.log("Animation complete");
});
// Direction option (where applicable)
$("#box").hide("slide", { direction: "up" });Animation de couleurs
Le cœur de jQuery ne peut animer les couleurs — le cœur d'effets de jQuery UI l'ajoute. backgroundColor, color et borderColor deviennent animables. switchClass et toggleClass acceptent une durée pour passer en douceur entre classes, en interpolant toutes les propriétés CSS changées.
// jQuery UI extends animate() to support colors
$("#box").animate({
backgroundColor: "#ff0000",
color: "#ffffff",
borderColor: "#000000",
}, 1000);
// Animate through the theme states
$("#box").animate(
{ backgroundColor: $.Color("#0a0") },
{ duration: 500 }
);
// Toggle class with smooth transitions
$("#box").switchClass("old-class", "new-class", 500);
$("#box").toggleClass("active", 500); // duration = animatedTransitions de classes
addClass, removeClass et toggleClass gagnent un argument de durée optionnel grâce à jQuery UI — toutes les propriétés CSS différentes entre états s'animent en douceur. switchClass passe explicitement entre deux classes. C'est la façon la plus propre d'animer entre états thémés.
// Add/remove classes with animation
$("#box").addClass("highlight", 500); // animate to new class
$("#box").removeClass("highlight", 500);
$("#box").toggleClass("highlight", 500);
// switchClass: smoothly transition from one class to another
$("#box").switchClass("state-default", "state-active", 500);
// All accept a callback
$("#box").addClass("expanded", 500, function () {
console.log("Done expanding");
});Référence des méthodes d'effet
.effect() applique un effet nommé sans changer la visibilité (shake, bounce, pulsate sont des effets purs). .transfer() anime un contour de boîte d'un élément à l'autre — classique pour le retour « ajouter au panier ». Les tableaux d'easing par propriété permettent des easings différents selon les propriétés.
// .effect() — run an effect without hiding
$("#box").effect("shake", { times: 3 }, 300);
// .transfer() — animate a transfer outline to another element
$("#product").effect("transfer", { to: "#cart" }, 500);
// .animate() with colors and easing
$("#box").animate({ left: 200, opacity: 0.5 }, "slow", "easeOutBounce");
// Custom animation with step
$("#box").animate({
width: ["toggle", "swing"], // [value, easing] per property
height: ["toggle", "linear"],
}, 1000);ThemeRoller
Bases de ThemeRoller
ThemeRoller est l'application web officielle pour bâtir des thèmes jQuery UI personnalisés. Ajustez couleurs, polices, rayon des coins et textures avec aperçu en direct, puis téléchargez un ZIP avec le CSS thémé et les sprites d'images. Des thèmes préconstruits (smoothness, ui-lightness, etc.) sont aussi disponibles sur le CDN.
<!-- Use a prebuilt theme from the CDN -->
<link rel="stylesheet"
href="https://code.jquery.com/ui/1.13.2/themes/smoothness/jquery-ui.css">
<!-- Or a custom theme from ThemeRoller (jqueryui.com/themeroller) -->
<!-- 1. Visit the ThemeRoller app -->
<!-- 2. Customize colors, fonts, corner radius, etc. -->
<!-- 3. Download the generated CSS file -->
<link rel="stylesheet" href="my-custom-theme/jquery-ui.css">Classes du framework CSS
Le framework CSS est indépendant des widgets JavaScript — employez ui-widget, ui-widget-header, ui-widget-content et les classes d'état (ui-state-default, ui-state-hover, ui-state-active) dans votre propre balisage pour coller au style jQuery UI sans aucune initialisation de widget.
<!-- The jQuery UI CSS framework is reusable for custom markup -->
<div class="ui-widget">
<div class="ui-widget-header ui-corner-top">
<h3>Panel Header</h3>
</div>
<div class="ui-widget-content ui-corner-bottom">
<p>Panel content with themed styling.</p>
<button class="ui-button ui-widget ui-state-default ui-corner-all">
<span class="ui-icon ui-icon-gear"></span> Action
</button>
</div>
</div>Variables et structure du thème
Chaque thème définit le même jeu de classes avec couleurs et textures différentes. ui-state-highlight (jaune) sert aux avis ; ui-state-error (rouge) aux erreurs. Les classes de coins (ui-corner-all, ui-corner-top, etc.) rendent le border-radius thémable — ThemeRoller les règle toutes d'un coup.
/* ThemeRoller generates CSS with these key classes */
.ui-widget {
font-family: Arial, sans-serif; /* font family */
font-size: 1em; /* base font size */
}
.ui-widget-content { border: 1px solid #aaa; background: #fff; color: #222; }
.ui-widget-header { border: 1px solid #aaa; background: #ccc; color: #222; }
.ui-state-default { border: 1px solid #d3d3d3; background: #e6e6e6; }
.ui-state-hover { border: 1px solid #999; background: #dadada; }
.ui-state-active { border: 1px solid #aaa; background: #fff; }
.ui-state-focus { border: 1px solid #999; background: #dadada; }
.ui-state-highlight { border: 1px solid #fcefa1; background: #fbf9ee; }
.ui-state-error { border: 1px solid #cd0a0a; background: #fef1ec; }
.ui-corner-all { border-radius: 4px; } /* themable radius */Surcharge de thème personnalisé
Chargez un thème de base puis surchargez avec un CSS de spécificité supérieure. Plus rapide que de relancer ThemeRoller pour de petits ajustements. Ciblez les classes du framework (ui-widget-header, ui-state-default, etc.) pour restyler tous les widgets d'un coup. Retirez le rayon des coins pour un look plat et moderne.
/* Load the base theme first */
@import url("https://code.jquery.com/ui/1.13.2/themes/base/jquery-ui.css");
/* Override specific elements */
.ui-widget-header {
background: linear-gradient(to bottom, #2c3e50, #34495e);
color: #ecf0f1;
}
.ui-state-default {
background: #3498db;
border-color: #2980b9;
color: #fff;
}
.ui-state-hover { background: #2980b9; }
.ui-state-active { background: #1abc9c; border-color: #16a085; }
.ui-corner-all { border-radius: 0; } /* sharper look */Changement de thème à l'exécution
Pour changer de thème à l'exécution, chargez plusieurs fichiers CSS de thème et basculez leur propriété 'disabled' — seul l'activé s'applique. Persistez le choix dans localStorage. Les widgets adoptent immédiatement le nouveau style. Pour une solution à un seul CSS, échangez l'attribut href à la place.
<!-- Two theme stylesheets; toggle the disabled attribute -->
<link id="theme-light" rel="stylesheet"
href="themes/ui-lightness/jquery-ui.css">
<link id="theme-dark" rel="stylesheet"
href="themes/ui-darkness/jquery-ui.css" disabled>
<script>
function switchTheme(name) {
$("#theme-light").prop("disabled", name !== "light");
$("#theme-dark").prop("disabled", name !== "dark");
localStorage.setItem("theme", name);
}
// Restore on load
$(function () {
var saved = localStorage.getItem("theme") || "light";
switchTheme(saved);
});
</script>Thémer des widgets spécifiques
Ciblez les classes propres aux widgets (ui-datepicker, ui-dialog, ui-accordion-header) pour restyler des widgets individuels sans toucher aux autres. L'option 'classes' de 1.12+ est plus propre — elle ajoute des classes personnalisées à des éléments internes précis, que vous stylez dans votre CSS. Préférez-la aux surcharges globales quand possible.
/* Datepicker: style the calendar popup */
.ui-datepicker {
box-shadow: 0 4px 12px rgba(0,0,0,0.2);
border-radius: 0;
}
.ui-datepicker .ui-state-highlight { /* today */ background: #ffd; }
.ui-datepicker .ui-state-active { /* selected */ background: #2c3e50; }
/* Dialog: remove the default rounded corners */
.ui-dialog { border-radius: 0; box-shadow: 0 8px 30px rgba(0,0,0,0.3); }
/* Accordion: modernize the headers */
.ui-accordion .ui-accordion-header {
background: #f5f5f5;
border: none;
border-bottom: 1px solid #ddd;
font-weight: bold;
}
/* Use the 'classes' option (1.12+) for per-widget theming */
$("#dialog").dialog({
classes: { "ui-dialog": "my-dialog", "ui-dialog-titlebar": "my-title" },
});Snippets jQuery UI associés
Copy-paste ready code for common tasks.
Draggable
Make elements draggable with axis, containment, and event callbacks.
Droppable
Create drop targets that accept draggable elements with hover and drop events.
Resizable
Add resize handles with min/max constraints and aspect ratio lock.
Sortable
Reorder list items via drag-and-drop and persist the new order.
Accordion
Collapsible content panels with only one section expanded at a time.
Datepicker
Calendar widget with date range limits, formatting, and inline mode.
Dialog
Modal window with buttons, animations, and dynamic open/close.
Tabs
Tabbed content panels with AJAX loading and event-driven switching.
Was this helpful?