Einstieg
Installation via CDN
jQuery UI hängt von jQuery core ab — immer zuerst jQuery laden, dann jquery-ui.js. Das CSS liefert das default theming und ist Pflicht, damit widgets wie Datepicker und Dialog korrekt erscheinen. Version 1.13.x unterstützt 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>npm Installation
Installation via npm erlaubt tree-shaking, indem nur die benötigten widgets importiert werden (z. B. jquery-ui/ui/widgets/datepicker). Das volle 'jquery-ui'-Bundle enthält jedes widget und jeden effect. Das CSS theme muss separat importiert werden.
# 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";Grundlegende widget-initialisierung
Alle jQuery UI widgets folgen demselben plugin muster: $(selector).widgetName(options). Ein options-objekt zur konfiguration übergeben, methoden über die string-syntax aufrufen ('methodName', args...). Initialisierung immer in $(function(){}) wickeln oder das skript an das ende von body stellen.
$(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);
});widget methoden-muster
Die string-basierte api ist über alle widgets hinweg konsistent. 'option' getter/setter, 'enable'/'disable', 'widget' (gibt das äußerste element zurück) und 'destroy' (stellt das original markup wieder her) unterstützt jedes widget. destroy beim entfernen von elementen nutzen, um speicherlecks zu vermeiden.
// 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 entirelytheme konfiguration
jQuery UI bringt ~24 vorgebaute themes mit. Das 'base'-theme ist der default. ThemeRoller (themroller.jqueryui.com) erzeugt eigene themes. das eigene CSS nach dem base laden, um konkrete klassen wie .ui-widget-header oder .ui-state-default zu übersteuern.
<!-- 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">klassen-namenskonvention
Das CSS framework nutzt eine konsistente ui-*-namenskonvention. interaktions-zustände (default, hover, active, focus) wenden widgets automatisch an. diese klassen lassen sich direkt im eigenen markup verwenden, um dem jQuery UI styling zu entsprechen.
/* 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
einfacher draggable
Ein element draggable zu machen ist ein einzelner aufruf. das element lässt sich dann mit der maus bewegen. die klasse ui-widget-content wendet das default theme styling an. draggable übernimmt die positionierung — relative/absolute wird je bedarf angewandt.
<!-- HTML -->
<div id="box" class="ui-widget-content" style="width:100px;height:100px;">
Drag me
</div>
<!-- JS -->
<script>
$(function () {
$("#box").draggable();
});
</script>draggable optionen
optionen steuern das ziehverhalten. 'axis' begrenzt die bewegung auf eine achse, 'containment' den zieh-bereich, 'grid' rastet auf intervalle, und 'revert' bringt das element zur startposition zurück. 'helper: clone' zieht eine kopie statt des originals.
$("#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
});drag events
drei events feuern während des ziehens: 'start' (einmal am anfang), 'drag' (fortlaufend bei bewegung) und 'stop' (einmal am ende). das ui objekt liefert position (relativ zum parent) und offset (relativ zur seite). schwere arbeit in 'drag' kostet performance.
$("#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 & cancel
'handle' beschränkt den zieh-start auf ein konkretes kind-element — nützlich, wenn die ganze box beweglich sein soll, aber nur über eine titelleiste. 'cancel' verhindert das ziehen von bestimmten elementen wie inputs oder textareas, wo die maus-interaktion fürs bearbeiten gebraucht wird.
<!-- 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>bewegung begrenzen
containment beschränkt, wohin das element gezogen werden kann. 'parent', 'window', 'document', ein selektor oder ein explizites [x1,y1,x2,y2]-array funktionieren. mit 'grid' kombiniert entstehen präzise, gerastete positionierungen für layout editoren oder 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] });an elemente snappen
'snap' lässt den draggable auf ziel-elemente einrasten, wenn er nah genug ist. 'snapMode' steuert die ausrichtung: 'inner' (innerhalb des ziels), 'outer' (außerhalb) oder 'both'. nützlich für diagramm-werkzeuge oder dashboard layouts, wo sich elemente ausrichten sollen.
$(".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
einfacher droppable
droppable definiert eine ziel-fläche, die gezogene elemente akzeptiert. der 'drop' callback feuert, wenn ein draggable darüber losgelassen wird. ui.draggable liefert eine referenz auf das gezogene element, um es zu bewegen oder zu verarbeiten.
<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>droppable optionen
'accept' filtert, welche draggables erlaubt sind — ein selektor oder eine funktion. 'activeClass' und 'hoverClass' liefern visuelles feedback. 'greedy: true' verhindert, dass verschachtelte droppables beide das drop event erhalten — praktisch für verschachtelte drop-zonen.
$("#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
});drop events
fünf events decken den ganzen drop lebenszyklus ab. 'activate'/'deactivate' feuern, wenn ein passender drag beginnt/endet. 'over'/'out' feuern, wenn der draggable die zone betritt/verlässt. 'drop' feuert nur bei erfolgreichem loslassen. damit progressives visuelles feedback bauen.
$("#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);
},
});accept selektor
'accept' kann ein selektor-string oder eine funktion sein, die einen boolean liefert. die funktion erhält das gezogene element und läuft für jeden kandidaten — so sind runtime-logiken wie data attribute oder berechnete zustände möglich. nicht akzeptierte draggables triggern keine drop events.
<!-- 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>toleranz-modi
tolerance definiert, wie viel überlappung für einen drop nötig ist. 'fit' ist am strengsten (ganzes element innen). 'pointer' richtet sich nach dem maus-cursor. 'intersect' (50% überlappung) ist ein guter mittweg für die meisten UIs. 'touch' ist am großzügigsten.
$("#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",
});visuelles feedback mit klassen
activeClass (erscheint, solange ein akzeptierter drag läuft) und hoverClass (erscheint, wenn der draggable über der zone ist) kombinieren, um nutzern klares feedback zu geben. im drop handler hängt man den draggable typischerweise an, um ihn in die drop zone umzuhängen.
<!-- 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
einfacher resizable
resizable ergänzt resize griffe an einem element. per default erscheint ein griff an der ecke unten rechts (se). das element braucht positionierung (relative/absolute), damit die griffe korrekt verankern.
<div id="box" class="ui-widget-content">
Resize me from the corner
</div>
<script>
$(function () {
$("#box").resizable();
});
</script>resize griffe
'handles' steuert, welche kanten/ecken resize-grips bekommen. himmelsrichtungen nutzen: n, e, s, w, ne, se, sw, nw. der default ist 'e, s, se'. eigene handle elemente per selektor liefern für volle stil-kontrolle.
$("#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",
},
});resizable optionen
optionen begrenzen und passen das resizen an. 'aspectRatio' hält die proportionen (super für bilder/video). 'alsoResize' synchronisiert ein weiteres element. 'ghost' zeigt während des resizens einen schwachen preview, die echte größe greift beim loslassen. min/max maße erzwingen grenzen.
$("#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
});resize events
wie draggable feuert resize start/resize/stop. das ui objekt hat 'size' (width, height) und 'position' (left, top). beim resizen von nord- oder westkanten ändern sich size und position. das resize event nutzen, um abhängige UI wie eine live preview zu aktualisieren.
$("#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);
},
});aspect ratio & constraints
aspectRatio (eine zahl oder boolean true zum fixieren des aktuellen verhältnisses) für bilder und medien nutzen. kombiniert mit min/max-constraints lassen sich unpassende größen verhindern. grid snapping richtet auf intervalle aus — nützlich für editor-interfaces und layout werkzeuge.
// 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] });animate & ghost modi
'animate' transitioniert nach dem loslassen geschmeidig zur neuen größe. 'ghost' zeigt während des ziehens einen halbtransparenten preview und wendet die echte änderung erst beim loslassen an. zusammen entsteht ein poliertes, ruckelfreies resize-erlebnis.
// 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
einfacher selectable
selectable macht eine liste von kindern zu einer auswählbaren gruppe. klicken wählt aus, oder ein lasso ziehen wählt mehrere. ctrl/cmd ergänzt zur auswahl, shift wählt einen bereich. ausgewählte items bekommen automatisch die klasse 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>selectable optionen
'filter' beschränkt, welche kinder teilnehmen. 'tolerance' steuert das lasso-verhalten: 'touch' wählt bei jeder überlappung (default), 'fit' verlangt volle umschließung. 'autoRefresh: false' bei großen listen setzen für bessere performance — danach $(...).selectable('refresh') manuell nach layout-änderungen aufrufen.
$("#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
});select events
events feuern während des auswahl-lebenszyklus: 'selecting'/'unselecting' beim ziehen, 'selected'/'unselected' nach bestätigung, und 'start'/'stop' für die gesamtoperation. jedes ui objekt hat das relevante element (selecting, selected usw.).
$("#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 */ },
});items filtern
'filter' erlaubt nur konkrete kinder zur auswahl, 'cancel' schließt andere aus. nützlich für galerien, bei denen manche items (gesperrt, schreibgeschützt) nicht teilnehmen sollen. das lasso ignoriert nicht passende elemente einfach.
<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>ausgewählte items stylen
jQuery UI wendet automatisch die klassen ui-selecting (beim ziehen) und ui-selected (nach dem loslassen) an. diese stylen, um feedback zu geben. die aktuelle auswahl jederzeit über $('.ui-selected') innerhalb des containers lesen — praktisch für toolbars und massenaktionen.
/* 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);programmatische auswahl
'refresh' nach dem ergänzen/entfernen von items aufrufen, damit das lasso hit-testing korrekt bleibt. eine eingebaute 'select'-methode gibt es nicht, aber die klasse ui-selected lässt sich manuell togglen. leeren durch entfernen der klasse an allen 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
einfacher sortable
sortable macht listen-items per drag umsortierbar. items werden beim ziehen visuell bewegt und die DOM reihenfolge beim loslassen aktualisiert. nützlich für task listen, foto-galerien und jeden inhalt mit prioritäts-reihenfolge.
<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>sortable optionen
optionen verfeinern das sortierverhalten. 'placeholder' stylt die hinterlassene lücke; forcePlaceholderSize stellt sicher, dass sie den item-maßen entspricht. 'axis' begrenzt auf horizontal/vertikal. 'handle' legt einen zieh-griff fest — ideal, wenn das ganze item interaktive kinder hat.
$("#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
});sort events
kern-events: 'start'/'stop' umschließen das sortieren. 'change' feuert, wenn sich die position des items beim ziehen ändert. 'update' feuert nur, wenn die endgültige reihenfolge von der anfangs abweicht — hier die neue reihenfolge persistieren, meist via toArray(), das die item IDs in ordnung liefert.
$("#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);
},
});verbundene listen
'connectWith' verknüpft mehrere sortables, sodass items zwischen ihnen gezogen werden können — super für kanban boards oder pipeline manager. jede liste verfolgt weiterhin ihre eigene reihenfolge via toArray(). die receive/remove events nutzen, um auf listen-übergreifende verschiebungen zu reagieren.
<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>Platzhalter & Helper
der placeholder ist der leere raum, an dem das item landen wird — stylen für klares drop feedback. forcePlaceholderSize ist wichtig, wenn items verschiedene höhen haben. eine eigene helper funktion erlaubt einen vereinfachten preview beim ziehen.
$("#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" });sort methoden
toArray() liefert IDs in aktueller reihenfolge — am nützlichsten für persistenz. serialize() baut einen query string, wenn IDs der 'name_number'-konvention folgen. cancel() macht den letzten sort rückgängig. refresh() nach programmatischem ergänzen von items aufrufen.
// 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
einfaches accordion
accordion erwartet paare aus header + inhalt-elementen (der header muss zuerst kommen). per default ist nur ein abschnitt gleichzeitig offen. das default header element ist h3, änderbar über die header option. inhalt-panels folgen jeweils einem header.
<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>accordion optionen
'collapsible: true' setzen, um alle panels geschlossen zu erlauben (default erzwingt ein offenes). 'heightStyle: content' misst jedes panel an seinem inhalt; 'fill' macht alle panels gleich hoch wie der container; 'auto' nutzt die höhe des größten panels.
$("#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
});accordion events
beforeActivate erlaubt es, einen panelwechsel durch false zurückgeben zu verweigern — nützlich bei warnungen vor ungespeicherten änderungen. activate feuert nach ablauf der animation. das ui objekt liefert alte/neue header- und panel-elemente für beide events.
$("#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());
},
});eigene icons
icons mappt die icon-klassen für geschlossen (header) und offen (activeHeader). false übergeben schaltet icons ab. jede icon bibliothek (fontawesome, material icons) ist nutzbar, indem die passenden klassennamen geliefert werden — der icon span entsteht automatisch.
$("#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 & mehrere abschnitte
für ein echtes 'mehrere gleichzeitig offen'-accordion: jQuery UIs accordion unterstützt das nativ nicht — stattdessen je abschnitt separate collapsible accordions initialisieren oder tabs nutzen. 'collapsible: true' erlaubt nur, das aktuell offene panel zu schließen.
// 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",
});
});dynamisches accordion
refresh() nach dem ergänzen oder entfernen von panels aufrufen, damit das widget neu bindet. die active option öffnet ein panel programmatisch per index. das beforeActivate muster ist ein sauberer weg, panel-inhalt per AJAX erst beim ersten öffnen nachzuladen.
// 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
einfaches autocomplete
ein einfaches array von strings an 'source' übergeben für statische vorschläge. das widget filtert per teilstring, während der nutzer tippt. vorschläge erscheinen in einem dropdown; eine auswahl füllt das input. die liste kann auch {label, value}-objekte enthalten für reichhaltigere anzeige.
<label for="city">City:</label>
<input id="city" type="text">
<script>
$(function () {
var cities = ["London", "Paris", "Berlin", "Madrid", "Rome"];
$("#city").autocomplete({ source: cities });
});
</script>remote datenquelle
ist source eine URL, sendet autocomplete eine GET anfrage mit ?term= dem getippten text und erwartet ein JSON array. minLength schiebt die anfrage auf, bis genug zeichen getippt sind, und senkt die server-last. die delay option debounct schnelles tippen.
$("#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" }]autocomplete optionen
autoFocus: true hebt den ersten vorschlag hervor, sodass enter ihn sofort wählt. position konfiguriert die menü-platzierung relativ zum input über jQuery UI position. appendTo ist nützlich, wenn das input in einem absolut positionierten container mit overflow-problemen liegt.
$("#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,
});eigene source funktion
eine funktions-source gibt volle kontrolle — nützlich für caching, eigene filterung oder das kombinieren mehrerer endpunkte. response(results) MUSS mit einem array aufgerufen werden, auch wenn es leer ist. jedes item darf felder jenseits von label/value tragen, erreichbar im select handler.
$("#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);
},
});autocomplete events
focus feuert, während der nutzer durch die vorschläge wandert (tastatur oder hover). select feuert, wenn ein item gewählt wird. change feuert beim blur und ist der richtige ort zu prüfen, ob der endgültige wert in der source existiert. false zurückgeben verhindert das default eingabefüllen.
$("#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);
}
},
});kategorien & eigenes rendering
_renderMenu oder _renderItem übersteuern, um das dropdown-layout anzupassen. dieses beispiel gruppiert vorschläge nach kategorie mit header-zeilen. das $.widget muster erweitert das basis-autocomplete, also funktionieren alle original optionen und events weiter. üblich bei such-interfaces.
$.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
einfacher datepicker
ein klick oder der fokus aufs input öffnet ein kalender-popup. das gewählte datum füllt das input als text. der kalender zeigt den aktuellen monat mit navigations-pfeilen für vorigen/nächsten monat. per default nutzen daten das US format (mm/dd/yy).
<label for="date">Pick a date:</label>
<input type="text" id="date">
<script>
$(function () {
$("#date").datepicker();
});
</script>datepicker optionen
minDate/maxDate akzeptieren ein date objekt, eine zahl (tage ab heute) oder einen string ('+1M +1W'). numberOfMonths zeigt mehrere monate — hilfreich für datums-bereichs-picker. changeMonth/changeYear ergänzen dropdowns zum springen zu fernen jahren.
$("#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
});datumsformat
die dateFormat option nutzt PHP-artige tokens. 'yy' bedeutet vierstelliges jahr (das zusätzliche y ist beabsichtigt). die methode formatDate wandelt ein date in einen string mit denselben tokens, parseDate kehrt das um.
$("#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, 2026min/max daten & bereiche
für einen datums-bereichs-picker zwei datepicker verknüpfen: wird der start gewählt, minDate des endes setzen; wird das ende gewählt, maxDate des starts setzen. beforeShowDay erlaubt es, einzelne tage zu deaktivieren oder zu stylen — noWeekends ist ein eingebauter blocker für samstag und sonntag.
// 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,
});lokalisation
jQuery UI bringt regionale dateien im i18n ordner für ~40 locales mit. die datei laden und mit $.datepicker.regional['fr'] anwenden. einzelne strings lassen sich auch inline übersteuern. die regionale datei setzt monatsnamen, tagesnamen, firstDay und dateFormat auf einmal.
// 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>inline datepicker & events
datepicker auf ein div statt ein input anwenden für einen immer sichtbaren inline kalender — super für buchungs-interfaces. onSelect feuert bei datumsauswahl, onChangeMonthYear beim navigieren der monate. getDate/setDate arbeiten mit date objekten für programmatische kontrolle.
<!-- 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
einfacher dialog
das title attribut des elements wird zur dialog titelleiste. der dialog öffnet sich per default automatisch und ist draggable/resizable. das element wandert in einen jQuery UI wrapper mit korrektem z-index stacking. schließen über den x-button oder escape.
<div id="dialog" title="Basic dialog">
<p>This is a simple dialog window.</p>
</div>
<script>
$(function () {
$("#dialog").dialog();
});
</script>dialog optionen
autoOpen: false erzeugt den dialog verborgen, dann bei bedarf dialog('open') aufrufen — das standardmuster für bedarfsgesteuerte dialogs. modal ergänzt ein overlay, das seiteninteraktion blockiert. position nutzt das jQuery UI position utility für präzise platzierung.
$("#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 },
});dialog buttons
buttons akzeptiert ein array (bevorzugt, erlaubt icons und optionen je button) oder ein objekt (text: handler). innerhalb eines handlers ist 'this' das dialog element — $(this).dialog('close') aufrufen zum schließen. buttons werden automatisch themt und rechtsbündig ausgerichtet.
$("#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"); },
},
});dialog events
beforeClose ist der wächter — false zurückgeben hält den dialog offen (nützlich bei warnungen vor ungespeicherten änderungen). close feuert nach dem schließen, der richtige ort, um formularzustand zurückzusetzen oder ressourcen freizugeben. drag/resize events spiegeln die zugrunde liegenden interaktionen.
$("#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 */ },
});modal & bestätigungsdialog
einen dialog aus einem dynamisch gebauten element für einmalige bestätigungen erzeugen. das modal overlay verhindert interaktion mit dem rest der seite. im close handler das element immer destroyen und entfernen, um beim schließen keine DOM nodes zu leaken.
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();
});AJAX inhalt & methoden
das open event nutzen, um inhalt per AJAX zu laden und verschachtelte widgets zu initialisieren. den inhalt beim schließen immer leeren, damit das nächste öffnen frisch ist. moveToTop hebt den dialog im z-index über andere — praktisch bei gestapelten dialogs. isOpen ist ein boolean getter für bedingte logik.
// 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
einfache progressbar
progressbar zeigt einen horizontalen balken, gefüllt bis zu einem prozentwert (0-100). die value option setzt den aktuellen fortschritt. der balken themt sich automatisch im jQuery UI stil. die breite des containers bestimmt die gesamtbreite des balkens — per CSS setzen.
<div id="progress"></div>
<script>
$(function () {
$("#progress").progressbar({ value: 37 });
});
</script>indeterminierter modus
value auf false gesetzt versetzt den balken in den indeterminierten modus — ein animierter streifen zeigt 'es passiert etwas' ohne konkreten prozentwert. nutzen, wenn die gesamtmenge unbekannt ist (z. b. warten auf einen server). sobald der fortschritt verfolgbar ist, wieder auf eine zahl wechseln.
<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>progressbar optionen
die 'max' option erlaubt nicht-100-skalen (z. b. max: 1000 für einen download in KB). der wert wird als anteil von max interpretiert. die classes option (1.12+) erlaubt es, eigene klassen an konkrete interne elemente zu hängen für feingranulares theming.
$("#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",
},
});wert aktualisieren
den balken über das setzen der value option aktualisieren. ein setInterval loop simuliert fortschritt für uploads oder langlaufende aufgaben. bei echten uploads das XHR upload progress event nutzen, um value je übertragener bytes zu setzen. den timer am ende immer leeren.
// 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");change event & eigene labels
change feuert bei jeder wert-aktualisierung, complete bei 100% — beide nützlich für dynamisches styling oder labels. um den prozenttext zu zeigen einen absolut positionierten label über den balken legen. im change handler aktualisieren, damit er synchron bleibt.
$("#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
einfacher slider
slider erzeugt einen ziehbaren griff auf einer horizontalen spur. der default bereich ist 0-100, der griff startet bei 0. die spur ist voll themt. maße per CSS am container setzen — width für horizontale, height für vertikale slider.
<div id="slider"></div>
<script>
$(function () {
$("#slider").slider();
});
</script>slider optionen
'values' (array) statt 'value' für einen zweigriff-range slider nutzen. 'range: true' schattiert die fläche zwischen den griffen; 'range: min' vom griff zum minimum; 'range: max' vom griff zum maximum. 'step' muss sich gleichmäßig in (max - min) teilen.
$("#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
});slider events
slide feuert fortlaufend beim ziehen — ideal, um ein label live zu aktualisieren. false innerhalb von slide bricht die bewegung ab — nützlich, um werte dynamisch zu begrenzen. change feuert nach dem loslassen und bei programmatischen option-änderungen; damit den wert persistieren.
$("#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
},
});range slider
ein zweigriff-range slider entsteht durch range: true und ein values array. ui.values[0] ist der untere griff, ui.values[1] der obere. die griffe können sich nicht kreuzen. das klassische muster für preis- oder datums-bereichs-filter.
<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>vertikal & ausrichtungen
vertikale slider brauchen eine explizite höhe per CSS — width wirkt auf die querachse. der griff bewegt sich auf/ab statt links/rechts. die range-schattierung funktioniert genauso. nützlich für audio mixer, equalizer oder jede UI, wo vertikale ausrichtung natürlicher ist.
// 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>slider methoden
bei range sliders values() (ohne argumente) für ein array nutzen, values(index, value) für einen griff, oder values(array) für beide. min/max/step zur laufzeit zu setzen positioniert die griffe automatisch innerhalb der neuen grenzen um.
// 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
einfacher spinner
spinner ergänzt auf/ab buttons an einem text input für numerische eingabe. nutzer tippen direkt, klicken die buttons oder nutzen die pfeiltasten. gehaltener button beschleunigt die schrittweite. der wert des inputs wird bei jeder änderung als zahl geparst.
<label for="qty">Quantity:</label>
<input id="qty" type="text" value="1">
<script>
$(function () {
$("#qty").spinner();
});
</script>spinner optionen
min/max erzwingen grenzen — die buttons gehen nicht darüber hinaus. step steuert die schrittweite (dezimalen wie 0.1 für feine kontrolle). numberFormat mit culture aktiviert lokalisierte formatierung (z. b. 'C' mit 'ja-JP' zeigt yen). globalize.js muss für culture support geladen sein.
$("#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",
},
});zahlenformatierung & culture
mit geladenem globalize.js formatiert spinner werte je angegebener culture — währungssymbole, dezimaltrenner und gruppierung lokalisieren sich alle. numberFormat 'C' ist währung, 'n' eine zahl mit optionaler dezimalzahl (n2 = 2 dezimalen). nützlich für internationalisierte formulare.
<!-- 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>spinner events
spin feuert bei jedem increment/decrement (button klick oder pfeiltaste). false zurückgeben bricht die änderung ab — ideal für eigene validierung. change feuert beim blur; ui.value ist null, wenn sich der input nicht als gültige zahl parsen lässt — der ort für validierungsfehler.
$("#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 */ },
});eigene schritte & methoden
stepUp/stepDown/pageUp/pageDown simulieren button drücke programmatisch. value() ohne argument ist ein getter; mit argument ein setter, der durch die validierung läuft. eigene spin handler erlauben nicht-numerische spinner wie zeiten, farben oder eigene einheiten.
// 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");validierung & eigenes parsen
_parse und _format übersteuern, um spinner für nicht-dezimale werte zu bauen — hex farben, zeiten, winkel oder jede eigene einheit. _parse wandelt den input-text in eine zahl; _format für die anzeige zurück. der sauberste weg, spinner für domänenspezifische inputs zu erweitern.
// 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
einfache tabs
tabs erwartet ein ul mit links auf inhalts-panel IDs, gefolgt von den panels selbst. die link hrefs (#tab-1) verbinden tabs mit panels. der erste tab ist per default aktiv. tabs sind tastaturnavigierbar (pfeile, home, end) und ARIA-konform.
<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>tabs optionen
active setzt den anfangs offenen tab per index (oder false für zusammengeklappten start). heightStyle 'fill' macht alle panels so hoch wie der container; 'content' misst jedes an seinem inhalt (default). 'event: mouseover' erzeugt hover-aktivierte tabs.
$("#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 },
});tabs events
beforeActivate ist der wächter — false zurückgeben blockiert den wechsel (z. b. warnung bei ungespeicherten änderungen). activate feuert nach abgeschlossenem wechsel. beforeLoad/load sind für AJAX tabs — beforeLoad erlaubt es, die anfrage anzupassen oder abzubrechen; load feuert bei erfolg.
$("#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
},
});AJAX tabs
ist der href eines tabs eine URL (kein anker), lädt tabs den inhalt bei aktivierung per AJAX. die antwort ersetzt das panel. beforeLoad erlaubt einen spinner zu zeigen, die AJAX anfrage zu konfigurieren oder abzubrechen. geladener inhalt wird ab 1.12+ für die sitzung gecacht.
<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>collapsible & sortable tabs
mit collapsible: true schließt ein klick auf den aktiven tab ihn (kein tab bleibt offen). tabs mit sortable an der nav gepaart erlauben das umordnen der tabs durch ziehen. nach dem ergänzen oder entfernen von tabs/panels refresh() aufrufen, damit das widget die neue struktur neu bindet.
// 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");
}tabs methoden
disable/enable akzeptieren einen index oder ein array von indizes. die active option ist getter und setter für den aktuellen tab — damit programmatisch wechseln. load() lädt AJAX inhalt eines tabs neu. refresh() ist pflicht nach dem ergänzen, entfernen oder umordnen von tabs.
// 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
einfacher tooltip
tooltip() am document aufzurufen ersetzt alle nativen title tooltips durch themte jQuery UI versionen. der inhalt des title attributs wird zum tooltip text. tooltips erscheinen beim hover und verschwinden bei mouseout, per default mit geschmeidiger fade animation.
<label for="age">Age:</label>
<input id="age" title="Please enter your age in years">
<script>
$(function () {
$(document).tooltip();
});
</script>tooltip optionen
'content' als funktion übersteuern, um dynamischen tooltip HTML zu erzeugen (etwa aus data attribute oder AJAX). 'items' ist ein selektor, der steuert, welche elemente tooltips auslösen. 'track: true' lässt den tooltip dem cursor folgen — nützlich für detaillierte hilfetexte an diagrammen.
$(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)
});eigener inhalt
die content funktion erlaubt reiche tooltips mit HTML, bildern oder AJAX-geladenem inhalt. einen string zurückgeben (HTML erlaubt). tooltipClass ergänzt eine eigene klasse fürs styling. das standardmuster für thumbnail previews oder hilfe-bubbles an formularfeldern.
<!-- 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'>";
},
});tooltip events
open und close feuern, wenn tooltips erscheinen und verschwinden. ui.tooltip liefert das tooltip element zur anpassung. ein übliches muster ist, den tooltip offen zu halten, solange der nutzer über ihn hovert — nützlich, wenn der tooltip interaktiven inhalt wie links enthält.
$(".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 & methoden
position nutzt das jQuery UI position utility: 'my' ist der anker des tooltips, 'at' der des ziels. collision behandelt randfälle — 'flip' wechselt die seite, wenn es überlaufen würde. open()/close() zeigen/verbergen tooltips programmatisch — praktisch für validierungsfehler.
$("#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");formular-validierungs-tooltips
tooltips sind ein sauberer weg, inline validierungsfehler zu zeigen. die fehlermeldung in einem data attribut speichern, content zum lesen setzen und open() aufrufen. false im open handler verhindert den tooltip, wenn kein fehler vorliegt. mit tooltipClass für rotes fehler-styling arbeiten.
<!-- 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>Effekte
core effekte
jQuery UI erweitert jQuerys show/hide/toggle um benannte effekte und ergänzt die methode .effect() für nicht-verbergende animationen. jeder nimmt ein options-objekt, eine dauer und einen callback. 'transfer' erzeugt einen transfer element umriss — nützlich für drag-zum-warenkorb-Animationen.
// 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, transfereasing funktionen
jQuery UIs effects core ergänzt ~30 robert penner easing funktionen über jquerys default 'swing' und 'linear' hinaus. nutzbar in jedem .animate() aufruf, der easing option von show/hide/toggle oder als drittes argument. 'easeOutBounce' und 'easeOutElastic' sind beliebt für verspielte UIs.
// 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 mit effekten
einen effekt-namen als erstes argument an show/hide/toggle übergeben, um zu animieren. das zweite argument ist ein options-objekt (direction, distance, percent usw., je effekt). das dritte ist die dauer; das vierte ein callback. effekte an verborgenen elementen wirken weiterhin 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" });farb-animationen
jquery core kann farben nicht animieren — jQuery UIs effects core ergänzt das. backgroundColor, color und borderColor werden animierbar. switchClass und toggleClass akzeptieren eine dauer, um geschmeidig zwischen klassen zu transitionieren und alle geänderten CSS eigenschaften zu interpolieren.
// 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 = animatedklassen-transitions
addClass, removeClass und toggleClass bekommen durch jQuery UI ein optionales dauer-argument — alle CSS eigenschaften, die zwischen zuständen abweichen, animieren geschmeidig. switchClass transitioniert explizit zwischen zwei klassen. der sauberste weg, zwischen themten zuständen zu animieren.
// 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");
});effekt methoden referenz
.effect() wendet einen benannten effekt an, ohne die sichtbarkeit zu ändern (shake, bounce, pulsate sind reine effekte). .transfer() animiert einen box umriss von einem element zu einem anderen — klassisch für 'in den warenkorb'-feedback. easing arrays je eigenschaft erlauben verschiedene easings für verschiedene eigenschaften.
// .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
ThemeRoller grundlagen
ThemeRoller ist die offizielle web app zum bauen eigener jQuery UI themes. farben, fonts, eckenradius und texturen mit live preview anpassen, dann ein ZIP mit dem themten CSS und den image sprites herunterladen. vorgebaute themes (smoothness, ui-lightness usw.) sind auch auf dem CDN verfügbar.
<!-- 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">CSS framework klassen
das CSS framework ist unabhängig von den javascript widgets — ui-widget, ui-widget-header, ui-widget-content und die zustands-klassen (ui-state-default, ui-state-hover, ui-state-active) im eigenen markup nutzen, um dem jQuery UI styling zu entsprechen, ganz ohne widget-initialisierung.
<!-- 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>theme variablen & struktur
jedes theme definiert dieselbe klassenmenge mit verschiedenen farben und texturen. ui-state-highlight (gelb) ist für hinweise; ui-state-error (rot) für fehler. die corner klassen (ui-corner-all, ui-corner-top usw.) machen den border-radius thembar — ThemeRoller setzt alle auf einmal.
/* 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 */eigenes theme übersteuern
ein base theme laden, dann mit spezifischerer CSS übersteuern. das ist schneller als ThemeRoller erneut laufen zu lassen für kleine anpassungen. die framework klassen zielen (ui-widget-header, ui-state-default usw.), um alle widgets auf einmal umzustylten. den eckenradius entfernen für einen flachen, modernen look.
/* 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 */theme wechsel zur laufzeit
um themes zur laufzeit zu wechseln mehrere theme CSS dateien laden und deren 'disabled'-eigenschaft togglen — nur die aktive greift. die wahl im localStorage persistieren. die widgets übernehmen das neue styling sofort. für eine single-CSS lösung stattdessen das href attribut tauschen.
<!-- 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>konkrete widgets themen
widget-spezifische klassen zielen (ui-datepicker, ui-dialog, ui-accordion-header), um einzelne widgets umzustylten, ohne andere zu berühren. die 'classes'-option ab 1.12+ ist sauberer — sie ergänzt eigene klassen an konkrete interne elemente, die man im eigenen CSS stylt. wo möglich statt globaler overrides nutzen.
/* 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" },
});Verwandte jQuery UI-Snippets
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?