Primeros pasos
Instalación vía CDN
jQuery UI depende del núcleo de jQuery — carga siempre jQuery antes de jquery-ui.js. El CSS proporciona la tematización por defecto y es necesario para que widgets como Datepicker y Dialog se muestren correctamente. La versión 1.13.x soporta 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>Instalación con npm
Instalar vía npm permite hacer tree-shaking importando solo los widgets que necesites (por ejemplo, jquery-ui/ui/widgets/datepicker). Importar el bundle completo 'jquery-ui' incluye cada widget y efecto. El tema CSS debe importarse por separado.
# 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";Inicialización básica de widgets
Cada widget de jQuery UI sigue el mismo patrón de plugin: $(selector).nombreWidget(opciones). Pasa un objeto de opciones para configurar, y llama a funciones con la sintaxis de cadena ('methodName', args...). Envuelve siempre la inicialización en $(function(){}) o coloca el script al final del 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);
});Patrón de funciones de widget
La API basada en cadenas es consistente en cada widget. 'option' como getter/setter, 'enable'/'disable', 'widget' (devuelve el elemento más externo) y 'destroy' (restaura el marcado original) están soportados por cada widget. Usa destroy al eliminar elementos para evitar fugas de memoria.
// 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 entirelyConfiguración del tema
jQuery UI incluye ~24 temas precompilados. El tema 'base' es el predeterminado. ThemeRoller (themroller.jqueryui.com) genera temas personalizados. Carga tu propio CSS después del base para sobrescribir clases concretas como .ui-widget-header o .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">Convención de nombres de clases
El framework CSS usa una convención de nombres ui-* consistente. Los estados de interacción (default, hover, active, focus) se aplican automáticamente por los widgets. Puedes usar estas clases directamente en tu propio marcado para igualar el estilo de 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 básico
Hacer un elemento arrastrable es una sola llamada. El elemento puede moverse entonces con el ratón. La clase ui-widget-content aplica el estilo del tema por defecto. Draggable hereda el posicionamiento — relative/absolute/absolute se aplica según convenga.
<!-- HTML -->
<div id="box" class="ui-widget-content" style="width:100px;height:100px;">
Drag me
</div>
<!-- JS -->
<script>
$(function () {
$("#box").draggable();
});
</script>Opciones de Draggable
Las opciones controlan cómo se comporta el arrastre. 'axis' limita el movimiento a un eje, 'containment' restringe la región de arrastre, 'grid' ajusta a intervalos, y 'revert' devuelve el elemento a su posición inicial. 'helper: clone' arrastra una copia en lugar del 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
});Eventos de arrastre
Tres eventos se disparan durante un arrastre: 'start' (una vez al principio), 'drag' (continuamente mientras se mueve) y 'stop' (una vez al final). El objeto ui proporciona position (relativa al padre) y offset (relativa a la página). El trabajo pesado en 'drag' puede perjudicar el rendimiento.
$("#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 y cancel
'handle' restringe el inicio del arrastre a un elemento hijo concreto — útil cuando toda la caja debería poder moverse pero solo mediante una barra de título. 'cancel' impide arrastrar desde ciertos elementos como inputs o textareas donde la interacción con el ratón es necesaria para editar.
<!-- 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>Restringir el movimiento
Containment restringe dónde puede arrastrarse el elemento. 'parent', 'window', 'document', un selector o un array explícito [x1,y1,x2,y2] valen por igual. Combinado con 'grid', puedes crear un posicionamiento preciso y ajustado para editores de layout o 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] });Ajuste a elementos
'snap' hace que el draggable salte para alinearse con los elementos objetivo cuando está lo bastante cerca. 'snapMode' controla la alineación: 'inner' (dentro del objetivo), 'outer' (fuera del objetivo) o 'both'. Útil para construir herramientas de diagramas o layouts de dashboard donde los elementos deban alinearse.
$(".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 básico
Droppable define un área objetivo que acepta elementos arrastrados. El callback 'drop' se dispara cuando un draggable se suelta sobre él. La propiedad ui.draggable da una referencia al elemento arrastrado para poder moverlo o procesarlo.
<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>Opciones de Droppable
'accept' filtra qué draggables se permiten — un selector o una función. 'activeClass' y 'hoverClass' proporcionan retroalimentación visual. 'greedy: true' impide que droppables anidados reciban ambos el evento drop, útil para zonas de soltado anidadas.
$("#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
});Eventos de soltado
Cinco eventos cubren el ciclo de vida completo del soltado. 'activate'/'deactivate' se disparan cuando un arrastre coincidente empieza/termina. 'over'/'out' se disparan cuando el draggable entra/sale de la zona. 'drop' se dispara solo en una suelta exitosa. Úsalos para retroalimentación visual progresiva.
$("#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);
},
});Selector accept
'accept' puede ser una cadena de selector o una función que devuelve booleano. La función recibe el elemento arrastrado y corre para cada candidato, permitiéndote aplicar lógica en tiempo de ejecución como atributos de datos o estados calculados. Los draggables no aceptados no dispararán eventos drop.
<!-- 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>Modos de tolerancia
La tolerancia define cuánto solapamiento se exige para registrar un soltado. 'fit' es la más estricta (el elemento entero dentro). 'pointer' se basa en el cursor del ratón. 'intersect' (50% de solapamiento) es un buen equilibrio para la mayoría de UIs. 'touch' es la más permisiva.
$("#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",
});Retroalimentación visual con clases
Combina activeClass (mostrada siempre que haya un arrastre aceptado en curso) y hoverClass (mostrada cuando el draggable está sobre la zona) para dar retroalimentación clara a los usuarios. En el manejador de drop, normalmente añades el draggable para reasignarlo a la zona de soltado.
<!-- 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 básico
Resizable añade tiradores de redimensionado a un elemento. Por defecto aparece un tirador en la esquina inferior derecha (se). El elemento debe tener posicionamiento aplicado (relative/absolute) para que los tiradores se anclen correctamente.
<div id="box" class="ui-widget-content">
Resize me from the corner
</div>
<script>
$(function () {
$("#box").resizable();
});
</script>Tiradores de redimensionado
'handles' controla qué bordes/esquinas reciben agarres de redimensionado. Usa direcciones de brújula: n, e, s, w, ne, se, sw, nw. El valor por defecto es 'e, s, se'. Puedes proporcionar elementos de tirador personalizados por selector para control total del estilo.
$("#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",
},
});Opciones de Resizable
Las opciones acotan y personalizan el redimensionado. 'aspectRatio' mantiene las proporciones (genial para imágenes/vídeo). 'alsoResize' sincroniza otro elemento. 'ghost' muestra una vista previa tenue durante el redimensionado, aplicando el tamaño real al soltar. Las dimensiones min/max imponen límites.
$("#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
});Eventos de redimensionado
Como draggable, resize dispara start/resize/stop. El objeto ui tiene 'size' (width, height) y 'position' (left, top). Al redimensionar desde los bordes norte u oeste cambian tanto el tamaño como la posición. Usa el evento resize para actualizar la UI dependiente, como una vista previa en vivo.
$("#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);
},
});Relación de aspecto y restricciones
Usa aspectRatio (un número o booleano true para bloquear la proporción actual) para imágenes y medios. Combinado con restricciones min/max, puedes evitar tamaños incómodos. El ajuste a cuadrícula alinea a intervalos — útil para interfaces de editor y herramientas de layout.
// 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] });Modos animate y ghost
'animate' transiciona suavemente al nuevo tamaño tras soltar el ratón. 'ghost' muestra una vista previa semitransparente durante el arrastre, aplicando el cambio real solo al soltar. Juntos crean una experiencia de redimensionado pulida y sin tirones.
// 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 básico
Selectable convierte una lista de hijos en un grupo seleccionable. Haz clic para seleccionar, o arrastra un lazo para seleccionar varios. Mantén Ctrl/Cmd para añadir a la selección, Shift para seleccionar un rango. Los ítems seleccionados reciben automáticamente la clase 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>Opciones de Selectable
'filter' restringe qué hijos participan. 'tolerance' controla el comportamiento del lazo: 'touch' selecciona ante cualquier solapamiento (por defecto), 'fit' exige el encierro completo. Fija 'autoRefresh: false' para listas grandes y mejorar el rendimiento — llama a $(...).selectable('refresh') manualmente tras cambios de layout.
$("#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
});Eventos de selección
Los eventos se disparan durante el ciclo de vida de la selección: 'selecting'/'unselecting' mientras se arrastra, 'selected'/'unselected' una vez confirmado, y 'start'/'stop' para la operación global. Cada objeto ui tiene el elemento relevante (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 */ },
});Filtrar ítems
Usa 'filter' para permitir que solo hijos concretos sean seleccionables, y 'cancel' para excluir a otros. Es útil para galerías donde algunos ítems (bloqueados, de solo lectura) no deberían participar. El lazo simplemente ignorará los elementos que no coincidan.
<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>Estilizar ítems seleccionados
jQuery UI aplica automáticamente las clases ui-selecting (durante el arrastre) y ui-selected (tras soltar). Estilízalas para dar retroalimentación. Lee la selección actual en cualquier momento vía $('.ui-selected') dentro del contenedor — práctico para toolbars y acciones masivas.
/* 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);Selección programática
Llama a 'refresh' tras añadir/quitar ítems para que el hit-testing del lazo siga siendo preciso. No hay función 'select' integrada, pero puedes alternar la clase ui-selected manualmente. Limpia quitando esa clase de cada ítem.
// 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 básico
Sortable hace que los ítems de una lista se puedan reordenar arrastrando. Los ítems se mueven visualmente durante el arrastre y el orden del DOM se actualiza al soltar. Útil para listas de tareas, galerías de fotos y cualquier contenido ordenado por prioridad.
<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>Opciones de Sortable
Las opciones afinan el comportamiento de ordenación. 'placeholder' estiliza el hueco que queda detrás; forcePlaceholderSize garantiza que coincida con las dimensiones del ítem. 'axis' restringe a horizontal/vertical. 'handle' designa un agarre de arrastre — ideal cuando todo el ítem tiene hijos interactivos.
$("#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
});Eventos de ordenación
Eventos clave: 'start'/'stop' acotan la ordenación. 'change' se dispara cuando la posición del ítem cambia durante el arrastre. 'update' se dispara solo cuando el orden final difiere del inicial — aquí es donde persistes el nuevo orden, a menudo vía toArray() que devuelve los IDs de los ítems en orden.
$("#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);
},
});Listas conectadas
'connectWith' vincula varios sortables para que los ítems puedan arrastrarse entre ellos — genial para tableros Kanban o gestores de pipeline. Cada lista sigue siguiendo su propio orden vía toArray(). Usa los eventos receive/remove para reaccionar a transferencias entre listas.
<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 y helper
El placeholder es el espacio vacío mostrado donde aterrizará el ítem — estilízalo para dar una retroalimentación de soltado clara. forcePlaceholderSize es importante cuando los ítems tienen alturas variables. Una función helper personalizada te permite mostrar una vista previa simplificada mientras arrastras.
$("#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" });Funciones de ordenación
toArray() devuelve los IDs en el orden actual — lo más útil para persistencia. serialize() construye una query string cuando los IDs siguen la convención 'nombre_numero'. cancel() deshace la ordenación más reciente. Llama a refresh() tras añadir ítems programáticamente.
// 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 básico
Accordion espera pares de elementos encabezado + contenido (el encabezado debe ir primero). Por defecto solo una sección está abierta a la vez. El elemento de encabezado por defecto es h3 pero puede cambiarse vía la opción header. Los paneles de contenido siguen a cada encabezado.
<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>Opciones de Accordion
Fija 'collapsible: true' para permitir que cada panel esté cerrado (por defecto se fuerza uno abierto). 'heightStyle: content' dimensiona cada panel a su contenido; 'fill' hace que los paneles igualen la altura del contenedor; 'auto' usa la altura del panel más alto.
$("#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
});Eventos de Accordion
beforeActivate te permite vetar un cambio de panel devolviendo false — útil para avisos de cambios sin guardar. activate se dispara tras completarse la animación. El objeto ui da los elementos de encabezado y panel antiguos/nuevos para ambos eventos.
$("#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());
},
});Iconos personalizados
icons mapea las clases de icono cerrado (header) y abierto (activeHeader). Pasa false para desactivar los iconos. Puedes usar cualquier librería de iconos (FontAwesome, Material Icons) proporcionando los nombres de clase adecuados — el span del icono se crea automáticamente.
$("#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 y múltiples secciones
Para un acordeón verdadero de 'varios abiertos a la vez', el accordion de jQuery UI no lo soporta de forma nativa — en su lugar inicializa accordions collapsible separados por sección, o usa tabs. La opción 'collapsible: true' solo permite cerrar el panel actualmente abierto.
// 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 dinámico
Llama a refresh() tras añadir o quitar paneles para que el widget re-enlace. Usa la opción active para abrir programáticamente un panel por índice. El patrón beforeActivate es una forma limpia de cargar con pereza el contenido del panel vía AJAX solo al abrirse por primera vez.
// 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 básico
Pasa un array simple de cadenas a 'source' para sugerencias estáticas. El widget filtra por subcadena a medida que el usuario escribe. Las sugerencias aparecen en un desplegable; elegir una rellena el input. La lista también puede contener objetos {label, value} para una visualización más rica.
<label for="city">City:</label>
<input id="city" type="text">
<script>
$(function () {
var cities = ["London", "Paris", "Berlin", "Madrid", "Rome"];
$("#city").autocomplete({ source: cities });
});
</script>Fuente de datos remota
Cuando source es una URL, autocomplete envía una petición GET con ?term= y el texto escrito, esperando un array JSON. minLength difiere la petición hasta que se hayan escrito suficientes caracteres para reducir la carga del servidor. La opción delay aplica debounce a la escritura rápida.
$("#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" }]Opciones de Autocomplete
autoFocus: true resalta la primera sugerencia para que pulsar Enter la seleccione de inmediato. position configura la colocación del menú respecto al input usando jQuery UI Position. appendTo es útil cuando el input está en un contenedor posicionado absolutamente con problemas de 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,
});Función de fuente personalizada
Una fuente de tipo función da control total — útil para cachear, filtrar a medida o combinar múltiples endpoints. DEBES llamar a response(resultados) con un array, aunque esté vacío. Cada ítem puede tener campos arbitrarios además de label/value, accesibles en el manejador 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);
},
});Eventos de Autocomplete
focus se dispara a medida que el usuario recorre las sugerencias (teclado o hover). select se dispara cuando se elige un ítem. change se dispara al perder el foco y es el lugar adecuado para validar que el valor final existe en la fuente. Devolver false impide el comportamiento por defecto de rellenar el 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);
}
},
});Categorías y renderizado personalizado
Sobrescribe _renderMenu o _renderItem para personalizar el layout del desplegable. Este ejemplo agrupa las sugerencias por categoría con filas de encabezado. El patrón $.widget extiende el autocomplete base, así que todas las opciones y eventos originales siguen funcionando. Común en interfaces de búsqueda.
$.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 básico
Hacer clic o enfocar el input abre un popup de calendario. La fecha seleccionada rellena el input como texto. El calendario muestra el mes actual con flechas de navegación al mes anterior/siguiente. Por defecto las fechas usan el formato estadounidense (mm/dd/yy).
<label for="date">Pick a date:</label>
<input type="text" id="date">
<script>
$(function () {
$("#date").datepicker();
});
</script>Opciones de Datepicker
minDate/maxDate aceptan un objeto Date, un número (días desde hoy) o una cadena ('+1M +1W'). numberOfMonths muestra varios meses — útil para selectores de rango de fechas. changeMonth/changeYear añaden desplegables para saltar a años lejanos.
$("#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
});Formato de fecha
La opción dateFormat usa tokens estilo PHP. 'yy' significa año de cuatro dígitos (la y extra es intencional). Usa la función formatDate() para convertir un Date a una cadena con los mismos tokens, y parseDate() para lo inverso.
$("#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, 2026Fechas min/max y rangos
Para un selector de rango de fechas, enlaza dos datepickers: cuando se elige el inicio, fija el minDate del fin; cuando se elige el fin, fija el maxDate del inicio. beforeShowDay te permite deshabilitar o estilizar días concretos — noWeekends es una integrada que bloquea sábados y domingos.
// 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,
});Localización
jQuery UI incluye archivos regionales en la carpeta i18n para ~40 locales. Carga el archivo y aplícalo con $.datepicker.regional['fr']. También puedes sobrescribir cadenas individuales en línea. El archivo regional fija a la vez los nombres de mes, los nombres de día, firstDay y 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 en línea y eventos
Aplica datepicker a un div en lugar de a un input para un calendario en línea siempre visible — genial para interfaces de reservas. onSelect se dispara al elegir una fecha, onChangeMonthYear al navegar entre meses. getDate/setDate trabajan con objetos Date para control programático.
<!-- 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 básico
El atributo title del elemento se convierte en la barra de título del diálogo. El diálogo se abre automáticamente por defecto y es arrastrable/redimensionable. El elemento se mueve a un envoltorio de jQuery UI con apilamiento de z-index adecuado. Cierra vía el botón X o pulsando Escape.
<div id="dialog" title="Basic dialog">
<p>This is a simple dialog window.</p>
</div>
<script>
$(function () {
$("#dialog").dialog();
});
</script>Opciones de Dialog
Fija autoOpen: false para crear el diálogo oculto, y luego llama a dialog('open') cuando lo necesites — este es el patrón estándar para diálogos bajo demanda. modal añade una capa que bloquea la interacción con la página. position usa la utilidad Position de jQuery UI para una colocación precisa.
$("#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 },
});Botones del diálogo
buttons acepta un array (preferido, permite iconos y opciones por botón) o un objeto (texto: manejador). Dentro de un manejador, 'this' es el elemento del diálogo — llama a $(this).dialog('close') para cerrarlo. Los botones se tematizan automáticamente y quedan alineados a la derecha por defecto.
$("#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"); },
},
});Eventos del diálogo
beforeClose es el guardián — devuelve false para mantener el diálogo abierto (útil para avisos de cambios sin guardar). close se dispara después de descartar el diálogo, el lugar adecuado para reiniciar el estado del formulario o liberar recursos. Los eventos drag/resize reflejan los de las interacciones subyacentes.
$("#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 */ },
});Diálogo modal y de confirmación
Crea un diálogo a partir de un elemento construido dinámicamente para confirmaciones puntuales. La capa modal impide la interacción con el resto de la página. Destruye y elimina siempre el elemento en el manejador de close para no filtrar nodos del DOM cuando el diálogo se descarta.
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();
});Contenido AJAX y funciones
Usa el evento open para cargar contenido vía AJAX e inicializar cualquier widget anidado. Limpia siempre el contenido al cerrar para que la próxima apertura sea fresca. moveToTop sube el diálogo por encima de otros en z-index — útil para diálogos apilados. isOpen es un getter booleano para lógica condicional.
// 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 básica
Progressbar muestra una barra horizontal rellena hasta un porcentaje (0-100). La opción value fija el progreso actual. La barra se tematiza automáticamente con el estilo de jQuery UI. El ancho del contenedor determina el ancho total de la barra — fíjalo vía CSS.
<div id="progress"></div>
<script>
$(function () {
$("#progress").progressbar({ value: 37 });
});
</script>Modo indeterminado
Fjar value en false pone la barra en modo indeterminado — una franja animada indica que 'algo está pasando' sin un porcentaje específico. Úsalo cuando el total es desconocido (por ejemplo, esperando al servidor). Vuelve a un número en cuanto puedas seguir el progreso.
<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>Opciones de Progressbar
La opción 'max' permite usar escalas que no sean 100 (por ejemplo, max: 1000 para una descarga en KB). El valor se interpreta como fracción del max. La opción classes (1.12+) permite añadir clases personalizadas a elementos internos concretos para una tematización fina.
$("#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",
},
});Actualizar el valor
Actualiza la barra fijando la opción value. Un bucle setInterval simula el progreso para subidas o tareas largas. Para subidas reales, usa el evento de progreso de subida de XHR para actualizar value según los bytes transferidos. Limpia siempre el temporizador al terminar.
// 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");Evento change y etiquetas personalizadas
change se dispara cada vez que se actualiza el valor, y complete al llegar al 100% — ambos son útiles para estilos dinámicos o etiquetas. Para mostrar el texto del porcentaje, añade una etiqueta posicionada absolutamente sobre la barra. Actualízala dentro del manejador change para mantenerla sincronizada.
$("#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 básico
Slider crea un tirador arrastrable sobre una pista horizontal. El rango por defecto es 0-100 con el tirador empezando en 0. La pista está totalmente tematizada. Fija las dimensiones vía CSS en el contenedor — width para sliders horizontales, height para los verticales.
<div id="slider"></div>
<script>
$(function () {
$("#slider").slider();
});
</script>Opciones de Slider
Usa 'values' (array) en lugar de 'value' para un slider de rango con dos tiradores. 'range: true' sombrea el área entre tiradores; 'range: min' sombrea desde el tirador hasta el mínimo; 'range: max' sombrea desde el tirador hasta el máximo. 'step' debe dividir exactamente (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
});Eventos de Slider
slide se dispara continuamente durante el arrastre — ideal para actualizar una etiqueta en vivo. Devolver false dentro de slide cancela el movimiento, útil para acotar valores dinámicamente. change se dispara tras soltar y ante cambios programáticos de opciones; úsalo para persistir el valor.
$("#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 rango
Un slider de rango con dos tiradores se construye fijando range: true y proporcionando un array de values. ui.values[0] es el tirador inferior, ui.values[1] el superior. Los tiradores no pueden cruzarse. Es el patrón clásico para filtros de precio o rango de fechas.
<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 y orientaciones
Los sliders verticales necesitan una altura explícita fijada vía CSS — width se aplica al eje transversal. El tirador se mueve arriba/abajo en lugar de izquierda/derecha. El sombreado de rango funciona igual. Útil para mezcladores de audio, ecualizadores o cualquier UI donde la orientación vertical es más natural.
// 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>Funciones de Slider
Para sliders de rango, usa values() (sin argumentos) para obtener un array, values(índice, valor) para fijar un tirador, o values(array) para fijar ambos. Fijar opciones como min/max/step en tiempo de ejecución reposiciona automáticamente los tiradores dentro de los nuevos límites.
// 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 básico
Spinner añade botones arriba/abajo a un input de texto para entrada numérica. Los usuarios pueden escribir directamente, hacer clic en los botones o usar las teclas de flecha. Mantener pulsado un botón acelera el incremento. El valor del input se parsea como número en cada cambio.
<label for="qty">Quantity:</label>
<input id="qty" type="text" value="1">
<script>
$(function () {
$("#qty").spinner();
});
</script>Opciones de Spinner
min/max imponen límites — los botones no los sobrepasarán. step controla el tamaño del incremento (usa decimales como 0.1 para control fino). numberFormat con culture habilita el formato localizado (por ejemplo, 'C' con 'ja-JP' muestra yenes). Globalize.js debe cargarse para soporte de culture.
$("#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",
},
});Formato numérico y cultura
Con Globalize.js cargado, spinner formatea los valores según la cultura especificada — símbolos de moneda, separadores decimales y agrupación se localizan por completo. numberFormat 'C' es moneda, 'n' es número con conteo decimal opcional (n2 = 2 decimales). Útil para formularios internacionalizados.
<!-- 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>Eventos de Spinner
spin se dispara en cada incremento/decremento (clic de botón o tecla de flecha). Devolver false cancela el cambio — ideal para validación personalizada. change se dispara al perder el foco; ui.value es null si el input no se parsea como número válido, el lugar para mostrar errores de validación.
$("#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 */ },
});Step personalizado y funciones
stepUp/stepDown/pageUp/pageDown simulan pulsaciones de botón programáticamente. value() sin argumento es un getter; con argumento es un setter que pasa por la validación. Los manejadores spin personalizados te permiten construir spinners no numéricos como horas, colores o unidades personalizadas.
// 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");Validación y parseo personalizado
Sobrescribe _parse y _format para construir spinners de valores no decimales — colores hex, horas, ángulos o cualquier unidad personalizada. _parse convierte el texto de entrada a número; _format lo convierte de vuelta para mostrarlo. Es la forma más limpia de extender spinner para entradas específicas del dominio.
// 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 básicas
Tabs espera un ul de enlaces apuntando a IDs de paneles de contenido, seguido por los paneles en sí. Los href de los enlaces (#tab-1) conectan pestañas con paneles. La primera pestaña está activa por defecto. Las pestañas son navegables por teclado (flechas, Home, End) y cumplen 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>Opciones de Tabs
active fija la pestaña abierta inicialmente por índice (o false para empezar colapsado). heightStyle 'fill' hace que cada panel iguale la altura del contenedor; 'content' dimensiona cada uno a su propio contenido (por defecto). 'event: mouseover' crea pestañas activadas al pasar el ratón.
$("#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 },
});Eventos de Tabs
beforeActivate es el guardián — devuelve false para bloquear el cambio (por ejemplo, aviso de cambios sin guardar). activate se dispara tras completarse el cambio. beforeLoad/load son para pestañas AJAX — beforeLoad te permite personalizar o cancelar la petición; load se dispara en caso de éxito.
$("#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
},
});Pestañas AJAX
Cuando el href de una pestaña es una URL (no un ancla), tabs carga el contenido vía AJAX al activarse. La respuesta reemplaza el panel. beforeLoad te permite mostrar un spinner, configurar la petición AJAX o cancelarla. El contenido cargado se cachea para la sesión por defecto 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>Pestañas collapsible y ordenables
Con collapsible: true, hacer clic en la pestaña activa la cierra (no queda ninguna pestaña abierta). Emparéjar tabs con sortable en la nav permite a los usuarios reordenar las pestañas arrastrando. Tras añadir o quitar pestañas/paneles, llama a refresh() para que el widget re-enlace la nueva estructura.
// 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");
}Funciones de Tabs
disable/enable aceptan un índice o un array de índices. La opción active es a la vez getter y setter de la pestaña actual — úsala para cambiar programáticamente. load() recarga el contenido AJAX de una pestaña. refresh() es esencial tras añadir, quitar o reordenar pestañas.
// 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 básico
Llamar a tooltip() en document reemplaza cada tooltip nativo de title por versiones tematizadas de jQuery UI. El contenido del atributo title se convierte en el texto del tooltip. Los tooltips aparecen al pasar el ratón y desaparecen al salir, con una animación de fundido suave por defecto.
<label for="age">Age:</label>
<input id="age" title="Please enter your age in years">
<script>
$(function () {
$(document).tooltip();
});
</script>Opciones de Tooltip
Sobrescribe 'content' como función para generar HTML de tooltip dinámico (por ejemplo, desde atributos de datos o AJAX). 'items' es un selector que controla qué elementos disparan tooltips. 'track: true' hace que el tooltip siga al cursor — útil para texto de ayuda detallado en diagramas.
$(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)
});Contenido personalizado
La función content te permite construir tooltips ricos con HTML, imágenes o contenido obtenido por AJAX. Devuelve una cadena (se permite HTML). tooltipClass añade una clase personalizada para estilizar. Es el patrón estándar para vistas previas de miniaturas o burbujas de ayuda en campos de formulario.
<!-- 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'>";
},
});Eventos de Tooltip
open y close se disparan a medida que los tooltips aparecen y desaparecen. La propiedad ui.tooltip da el elemento del tooltip para personalizarlo. Un patrón común es mantener el tooltip abierto mientras el usuario pasa sobre él — útil cuando el tooltip contiene contenido interactivo como enlaces.
$(".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(); }
);
},
});Posición y funciones
Position usa la utilidad Position de jQuery UI: 'my' es el ancla del tooltip, 'at' es la del objetivo. collision maneja los casos límite — 'flip' pasa al otro lado si se desbordaría. open()/close() muestran/ocultan tooltips programáticamente, útil para errores de validación.
$("#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 validación de formularios
Los tooltips son una forma limpia de mostrar errores de validación en línea. Guarda el mensaje de error en un atributo de datos, fija content para leerlo, y llama a open() para mostrarlo. Devolver false en el manejador open evita el tooltip cuando no hay error. Estiliza con tooltipClass para el estilo de error en rojo.
<!-- 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>Efectos
Efectos principales
jQuery UI extiende los show/hide/toggle de jQuery con efectos con nombre y añade la función .effect() para animaciones que no ocultan. Cada uno acepta un objeto de opciones, una duración y un callback. 'transfer' crea un contorno de elemento de transferencia — útil para animaciones de arrastrar al carrito.
// 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, transferFunciones de easing
El núcleo de efectos de jQuery UI añade ~30 funciones de easing de Robert Penner además del 'swing' y 'linear' por defecto de jQuery. Úsalas en cualquier llamada .animate(), en la opción easing de show/hide/toggle, o como tercer argumento. 'easeOutBounce' y 'easeOutElastic' son populares en UIs juguetonas.
// 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 con efectos
Pasa un nombre de efecto como primer argumento a show/hide/toggle para animar. El segundo argumento es un objeto de opciones (direction, distance, percent, etc. según el efecto). El tercero es la duración; el cuarto es un callback. Los efectos sobre elementos ocultos siguen funcionando vía 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" });Animación de colores
El núcleo de jQuery no puede animar colores — el núcleo de efectos de jQuery UI lo añade. backgroundColor, color y borderColor se vuelven animables. switchClass y toggleClass aceptan una duración para transicionar entre clases suavemente, interpolando todas las propiedades CSS cambiadas.
// 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 = animatedTransiciones de clase
addClass, removeClass y toggleClass ganan un argumento opcional de duración de jQuery UI — todas las propiedades CSS que difieren entre estados se animan suavemente. switchClass transiciona explícitamente entre dos clases. Es la forma más limpia de animar entre estados tematizados.
// 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");
});Referencia de funciones de efectos
.effect() aplica un efecto con nombre sin cambiar la visibilidad (shake, bounce, pulsate son efectos puros). .transfer() anima un contorno de caja de un elemento a otro — clásico para la retroalimentación de 'añadir al carrito'. Los arrays de easing por propiedad permiten que distintas propiedades usen easings distintos.
// .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
Fundamentos de ThemeRoller
ThemeRoller es la app web oficial para construir temas personalizados de jQuery UI. Ajusta colores, fuentes, radios de esquina y texturas con vista previa en vivo, y luego descarga un ZIP con el CSS tematizado y los sprites de imagen. Los temas precompilados (smoothness, ui-lightness, etc.) también están disponibles en el 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">Clases del framework CSS
El framework CSS es independiente de los widgets de JavaScript — usa ui-widget, ui-widget-header, ui-widget-content y las clases de estado (ui-state-default, ui-state-hover, ui-state-active) en tu propio marcado para igualar el estilo de jQuery UI sin ninguna inicialización 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 y estructura del tema
Cada tema define el mismo conjunto de clases con colores y texturas distintos. ui-state-highlight (amarillo) es para avisos; ui-state-error (rojo) para errores. Las clases de esquina (ui-corner-all, ui-corner-top, etc.) hacen tematable el border-radius — ThemeRoller las fija todas a la vez.
/* 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 */Anulación de tema personalizado
Carga un tema base y luego sobrescribe con CSS de mayor especificidad. Es más rápido que volver a ejecutar ThemeRoller para ajustes pequeños. Apunta a las clases del framework (ui-widget-header, ui-state-default, etc.) para restilizar el conjunto de widgets a la vez. Elimina el radio de esquina para un aspecto plano y moderno.
/* 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 */Cambio de tema en tiempo de ejecución
Para cambiar de tema en tiempo de ejecución, carga varios archivos CSS de tema y alterna su propiedad 'disabled' — solo se aplica el activado. Persiste la elección en localStorage. Los widgets recogen de inmediato el nuevo estilo. Para una solución de un solo CSS, intercambia el atributo href en su lugar.
<!-- 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>Tematizar widgets concretos
Apunta a las clases específicas de widget (ui-datepicker, ui-dialog, ui-accordion-header) para restilizar widgets individuales sin afectar a los demás. La opción 'classes' de 1.12+ es más limpia — añade clases personalizadas a elementos internos concretos, que estilizas en tu CSS. Úsala en lugar de anulaciones globales cuando puedas.
/* 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" },
});Fragmentos de jQuery UI relacionados
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?