Skip to content

jQuery Spickzettel

Schnelle, kleine und funktionsreiche JavaScript-Bibliothek.

01

Einstieg

jQuery einbinden

jQuery über ein CDN einbinden für schnelles, gecachtes Laden. Die minifizierte Version (.min.js) ist für Produktion; die unkomprimierte zum Debuggen. Immer einen lokalen Fallback vorsehen, falls das CDN nicht erreichbar ist. Mit npm lässt sich jQuery als Modul importieren — praktisch für Bundler wie Webpack/Vite. jQuery 3.7.x ist die aktuelle Linie; altes IE wird nicht mehr unterstützt.

jquery
<!-- Production (CDN, minified) -->
<script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>

<!-- Development (CDN, uncompressed) -->
<script src="https://code.jquery.com/jquery-3.7.1.js"></script>

<!-- Fallback: load local if CDN fails -->
<script>
window.jQuery || document.write(
  '<script src="js/jquery-3.7.1.min.js"><\/script>'
)
</script>

<!-- npm install -->
<!-- npm install jquery -->

document ready

DOM-Manipulationscode in $(document).ready() wickeln, damit er erst nach dem Parsen des DOM-Baums läuft (nicht auf Bilder warten). $(fn) ist die Kurzfassung. Steht dein <script> am Ende von <body>, ist das DOM schon da — ready entfällt. jQuerys ready ähnelt DOMContentLoaded — es feuert vor window.load (das auf Bilder/iframes wartet).

jquery
// run code after DOM is fully parsed
$(document).ready(function () {
  console.log('DOM ready')
})

// shorter equivalent
$(function () {
  console.log('DOM ready')
})

// modern preferred (no ready needed at end of body)
// <script> at the end of <body> runs after DOM exists

// pass a function to $ — jQuery treats it as ready handler
$(function () {
  $('.btn').on('click', function () {
    alert('clicked')
  })
})

Das jQuery-Objekt ($)

$ ist nur ein Alias für jQuery — beide identisch. Als Funktion wählt $ Elemente aus (gibt eine jQuery-Sammlung zurück). Als Namensraum liefert $.foo Utility-Methoden. Nutzt eine andere Bibliothek $, gibt $.noConflict() sie frei; weiterhin jQuery nutzen oder $ in einen ready-callback reichen, um es lokal zu aliasieren.

jquery
// $ is an alias for jQuery
console.log($ === jQuery)  // true

// $ as a function: select elements
$('p')             // all paragraphs
$('#main')         // element with id main
$('.btn.primary')  // elements with class btn and primary

// $ as a namespace: utility methods
$.each([1, 2, 3], function (i, v) { console.log(i, v) })
$.extend({}, defaults, options)
$.type([])         // 'array'

// noConflict: release $ back to other libraries
$.noConflict()
jQuery(function ($) { /* $ available here */ })

Methoden verketten

Die meisten jQuery-Methoden geben dieselbe jQuery-Sammlung zurück, also lassen sich Aufrufe verketten — jQuerys Markenzeichen. Mit .end() nach einer Traversierungsmethode (.find(), .filter()) zur vorigen Menge zurückspringen. Einrückung macht verkettete Traversierungen lesbar. Überlange Ketten vermeiden — sie werden schwer zu debuggen. Bei nicht verkettbaren Methoden (etwa .width() getter) bricht die Kette, weil sie einen Wert statt der Sammlung zurückgeben.

jquery
// most methods return the jQuery object, enabling chains
$('.box')
  .addClass('active')
  .css('color', 'red')
  .slideDown(300)
  .text('Hello')

// break across lines for readability
$('#nav')
  .find('.item')
    .addClass('highlight')
    .end()
  .find('.link')
    .attr('target', '_blank')

// .end() pops the current filter back to previous set

no-conflict-Modus

$.noConflict() gibt die Kontrolle über $ an die Bibliothek zurück, die sie zuerst definierte. Danach den vollen Namen jQuery nutzen oder jQuery einer eigenen Variable zuweisen. Das IIFE-Muster (function($){...})(jQuery) ist der klassische Weg, $ als lokalen Alias im Modul zu behalten, während das globale $ anderen Bibliotheken bleibt — Pflicht in WordPress und Legacy-Umgebungen.

jquery
// release $ to other libraries (e.g., Prototype)
$.noConflict()

// use jQuery full name
jQuery('.btn').on('click', function () { /* ... */ })

// or assign jQuery to a custom alias
const jq = $.noConflict()
jq('.btn').hide()

// IIFE pattern: keep $ inside a local scope
(function ($) {
  $('.btn').on('click', function () { /* ... */ })
})(jQuery)
02

Selektoren

Grundlegende Selektoren

jQuery nutzt CSS-Selektoren (meist kompatibel mit querySelectorAll). Die großen drei: tag name, #id, .class. Komma kombiniert Selektoren (Vereinigung). #id ist am schnellsten (nutzt getElementById). Universales * ist langsam — bei großen Dokumenten vermeiden. Selektor-Ergebnisse sind immer eine jQuery-Sammlung (array-artig), selbst bei 0 oder 1 Treffern.

jquery
// element selector
$('div')          // all <div> elements
$('p')            // all <p> elements

// id selector
$('#header')      // element with id="header"

// class selector
$('.btn')         // all elements with class="btn"
$('.btn.primary') // .btn AND .primary

// multiple (comma = OR)
$('div, p, .btn') // divs, paragraphs, and .btn

// universal
$('*')            // all elements (slow — avoid)

Hierarchie & Combinators

Combinators beschreiben Beziehungen: Leerzeichen (Nachfahre), > (direktes Kind), + (angrenzendes Geschwister), ~ (allgemeines Geschwister). Auswertung von rechts nach links: $('ul li') findet zuerst alle <li>, filtert dann auf die in <ul> — konkrete rechte Selektoren performen besser. Tiefe combinators bei riesigen Dokumenten vermeiden; auf einen Container scopen via $(container).find(...) für bessere Performance.

jquery
// descendant: space (any depth)
$('ul li')        // <li> anywhere inside <ul>

// child: > (direct children only)
$('ul > li')      // <li> directly inside <ul>

// adjacent sibling: + (immediately next)
$('h2 + p')       // <p> right after <h2>

// general sibling: ~ (all following siblings)
$('h2 ~ p')       // all <p> siblings after <h2>

// multiple levels
$('#nav .item > a span')

Attribut-Selektoren

Attribut-Selektoren zielen auf Elemente nach Attributwerten: [attr] (Vorhandensein), [attr=val] (exakt), [attr^=val] (beginnt), [attr$=val] (endet), [attr*=val] (enthält), [attr~=val] (Wort). Werte zur Sicherheit quoten. [attr!=val] ist eine jQuery-only-Erweiterung (für CSS-Konformität .not('[attr=val]')). Nützlich für Formulare (input-Typen), links (href-Muster) und data-* attribute.

jquery
// has attribute
$('[href]')                 // any element with href
$('[data-id]')              // any element with data-id

// exact value
$('[type="text"]')          // type="text"
$('[href="https://example.com"]')

// substring matches
$('[href^="https"]')        // starts with "https"
$('[href$=".pdf"]')         // ends with ".pdf"
$('[href*="example"]')      // contains "example"

// whitespace-separated word
$('[class~="active"]')      // class contains word "active"

// inequality (jQuery extension, not CSS)
$('[href!="https://x.com"]')

Formular- & input-Selektoren

Formular-Pseudoselektoren (:input, :text, :checked usw.) sind jQuery-Erweiterungen — nicht Teil von CSS, also ohne den schnellen querySelectorAll-Pfad. Für Performance bei großen Formularen $('input[type=text]') statt $(':text'). :checked und :selected sind Pflicht zum Lesen des Formularzustands. Sie sind dynamisch — sie werten bei jedem Zugriff neu aus.

jquery
// :input matches all form controls
$(':input')         // input, textarea, select, button

// by type
$(':text')          // <input type="text">
$(':password')
$(':checkbox')
$(':radio')
$(':submit')
$(':file')

// by state
$(':checked')       // checked checkbox/radio or selected option
$(':selected')      // selected <option>
$(':disabled')
$(':enabled')
$(':focus')

// combined with class
$('input.required:visible')

Filter- & Inhalts-Selektoren

Filter verengen eine Auswahl: :first/:last, :even/:odd (0-indexiert), :eq(n), :gt(n), :lt(n). Inhaltsfilter (:contains, :has, :empty, :parent) matchen nach Inhalt. :visible und :hidden beruhen auf offsetWidth/Height und CSS (Hinweis: Elemente mit visibility:hidden sind in jQuery 3+ :hidden; früher waren sie :visible). Viele davon sind jQuery-Erweiterungen — für bessere Performance die Methoden .filter(), .first(), .eq() bevorzugen.

jquery
// basic filters
$('li:first')         // first <li>
$('li:last')          // last <li>
$('li:even')          // even-indexed (0, 2, 4...)
$('li:odd')           // odd-indexed
$('li:eq(2)')         // 3rd <li> (0-indexed)
$('li:gt(2)')         // <li> after index 2
$('li:lt(2)')         // <li> before index 2

// content filters
$('div:contains("Hello")')  // divs containing text "Hello"
$('div:empty')              // divs with no children
$('div:has(p)')             // divs containing <p>
$('div:parent')             // divs that have children

// visibility
$(':visible')
$(':hidden')
03

Events

Events mit .on() binden

.on() ist der moderne All-in-one-event-binder (ersetzt .bind/.delegate/.live). Event-Namen und handler übergeben. 'this' im handler ist das DOM-Element (nicht jQuery-umwickelt — bei Bedarf $(this)). Event-namespaces (click.myapp) nutzen, um konkrete handler zu entbinden, ohne andere zu berühren. Mehrere events können sich einen handler teilen (leerzeichengetrennt) oder eigene haben (Objektform).

jquery
// basic binding
$('.btn').on('click', function (e) {
  console.log('clicked!', this)  // 'this' is the DOM element
})

// multiple events, same handler
$('.box').on('mouseenter mouseleave', function () {
  $(this).toggleClass('hover')
})

// multiple events, different handlers
$('.input').on({
  focus: function () { $(this).addClass('focused') },
  blur: function () { $(this).removeClass('focused') }
})

// named events (for targeted unbinding)
$('.btn').on('click.myapp', handler)
$('.btn').off('click.myapp')  // only removes this one

Event delegation

Event delegation bindet einen handler an ein parent, das events von Kindern via bubbling fängt. Der zweite Selektor an .on() ('li') filtert, welche Kinder den handler auslösen. Vorteile: ein handler statt N, automatische Unterstützung dynamisch ergänzter Elemente, weniger Speicher. Pflicht bei langen Listen oder SPAs. 'this' ist das passende Kind (das li), nicht das parent. e.delegateTarget für den Zugriff auf das parent.

jquery
// delegate: handle events on children, now or future
$('#list').on('click', 'li', function (e) {
  // 'this' is the <li> that was clicked
  $(this).toggleClass('done')
})

// works for <li> added AFTER binding too
$('#list').append('<li>New item (also clickable)</li>')

// WHY: instead of binding to each <li>,
// bind ONCE to the parent; clicks bubble up
// - 1 handler instead of N
// - works for dynamically added elements
// - lower memory, faster setup

Event-Objekt & Methoden

Das event-Objekt (e) trägt Infos und Steuermethoden. preventDefault stoppt den Browser-default (link navigation, form submit). stopPropagation stoppt bubbling; stopImmediatePropagation stoppt zusätzlich andere handler am selben Element. e.target ist das tatsächlich geklickte Element (evtl. ein Kind); e.currentTarget das Element mit dem handler (= this). Daten an handler über das optionale zweite Argument an .on() reichen.

jquery
$('.link').on('click', function (e) {
  e.preventDefault()      // stop default action (e.g., navigation)
  e.stopPropagation()     // stop bubbling to parents
  e.stopImmediatePropagation() // stop other handlers on same element

  console.log(e.type)         // 'click'
  console.log(e.target)       // the actual clicked element
  console.log(e.currentTarget) // the element with the handler (= this)
  console.log(e.which)        // mouse button or key code
  console.log(e.pageX, e.pageY) // mouse coordinates

  // data passed via .on(name, data, handler)
})

$('.btn').on('click', { greeting: 'hi' }, function (e) {
  console.log(e.data.greeting)  // 'hi'
})

Kurzform-Event-Methoden

Kurzmethoden (.click, .focus, .submit usw.) binden mit einer Funktion einen handler, ohne Funktion triggern sie das event. .hover(enter, leave) ist der Komfort für mouseenter+mouseleave. Äquivalent zu .on('event', fn), nur kürzer. Manche Kurzformen (.load, .error) wurden in jQuery 3 entfernt — statt dessen .on('load', ...). Für neuen Code .on() bevorzugen; expliziter und delegation-fähig.

jquery
// shorthand: bind a handler (or trigger if no handler)
$('.btn').click(function () { /* ... */ })
$('.btn').click()  // trigger click

// common shorthands
$('.box').hover(enterFn, leaveFn)   // mouseenter + mouseleave
$('.input').focus(function () { /* ... */ })
$('.input').blur(function () { /* ... */ })
$('.form').submit(function (e) {
  e.preventDefault()
  /* ... */
})
$('.el').mouseenter(fn).mouseleave(fn).mousemove(fn)
$(window).resize(fn).scroll(fn)

// deprecated: .load(), .unload(), .error() (removed in jQuery 3)

triggern & Einmal-Events

.trigger('event') feuert handler UND natives Verhalten (etwa navigation); .triggerHandler() feuert nur jQuery-gebundene handler und gibt deren Rückgabewert zurück (nicht verkettbar). .one() bindet einen handler, der sich nach dem ersten Aufruf selbst entfernt — perfekt für Erst-Klick-Hinweise, einmaliges Setup. Eigene events lassen Komponenten kommunizieren: $(document).trigger('myapp:ready'), Listener abonnieren mit .on('myapp:ready', fn).

jquery
// trigger an event programmatically
$('.btn').trigger('click')
$('.btn').click()  // shorthand

// trigger with extra data
$('.box').trigger('custom', [1, 2, 3])

// custom events
$('.box').on('custom', function (e, a, b, c) {
  console.log(a, b, c)  // 1 2 3
})

// fire handler only once
$('.btn').one('click', function () {
  alert('This fires only once')
})

// trigger only native handlers, not custom
$('.link').triggerHandler('click')
04

DOM-Manipulation

Inhalt lesen & setzen

.html() arbeitet mit HTML-markup (wie innerHTML) — tags werden geparst. .text() ist für plain text — tags werden escapet und wörtlich angezeigt (sicherer gegen XSS bei nutzer-Input). .val() ist für form controls (input, select, textarea). Alle drei sind getter (geben den Wert des ersten Elements) ohne Argument und setter (wirken auf alle passenden Elemente) mit Argument. Setter akzeptieren einen callback (index, oldValue) => newValue.

jquery
// .html(): get or set HTML content
$('#box').html()                    // get innerHTML
$('#box').html('<p>Hello</p>')      // set innerHTML

// .text(): get or set text (HTML-escaped)
$('#box').text()                    // get text content
$('#box').text('<p>Not parsed</p>') // displays literally

// setter with callback (index, old value)
$('p').text(function (i, oldText) {
  return i + ': ' + oldText
})

// .val(): form value
$('input').val()                    // get
$('input').val('new value')         // set
$('select').val()                   // get selected value
$('select').val(['a', 'b'])         // multi-select

Elemente einfügen

Elemente erzeugen, indem man HTML an $() übergibt: $('<div class="x">...</div>'). append/prepend fügen innen ein (am Ende/Anfang); before/after außen (als Geschwister). Die 'To'-Varianten (appendTo, prependTo, insertBefore, insertAfter) kehren das Subjekt um — praktisch, um am neuen Element zu verketten. Frisch eingefügte Elemente erben event handler bei delegation-Bindung, nicht bei direkter Bindung vor dem Einfügen.

jquery
// create new element
const $li = $('<li class="item">New item</li>')

// add as last child of each matched element
$('ul').append($li)
$('ul').append('<li>Direct string</li>')

// add as first child
$('ul').prepend('<li>First</li>')

// insert before/after matched elements
$('.box').before('<hr>')
$('.box').after('<hr>')

// reverse direction (insert target into container)
$('<p>Hi</p>').appendTo('#main')   // same as $('#main').append(...)
$('<p>Hi</p>').insertBefore('#nav')

Entfernen & Ersetzen

.remove() löscht Elemente und räumt ihre daten/events auf. .detach() entfernt aus dem DOM, erhält aber daten/events — nützlich für temporäres Umlagern. .empty() leert die kinder, behält das Element. .replaceWith() tauscht jedes Element gegen neuen Inhalt. .unwrap() entfernt das parent und holt das Element nach oben. Immer .remove() oder .detach() — niemals nur .html('') am parent, das daten/events der kinder leakst.

jquery
// remove element (and its data + events)
$('.box').remove()

// detach: remove but keep events/data (for re-insertion)
const $el = $('.box').detach()
// ... later
$('body').append($el)  // events still work

// empty: remove all children (keep element)
$('.box').empty()

// replace with new content
$('.old').replaceWith('<div class="new">New</div>')

// unwrap: remove parent (keep element)
$('.box').unwrap()

Umwickeln & Klonen

.wrap() umwickelt jedes Element einzeln; .wrapAll() die ganze Menge als eine Gruppe; .wrapInner() den Inhalt (nicht das Element selbst). .clone() erzeugt eine tiefe Kopie — mit true auch event handler und daten klonen (default false, handler feuern also nicht auf der Kopie). .unwrap() entfernt das unmittelbare parent. Mächtig, um markup umzubauen, ohne HTML-Strings neu zu schreiben.

jquery
// wrap each element in a structure
$('p').wrap('<div class="wrapper"></div>')
// each <p> becomes <div class="wrapper"><p>...</p></div>

// wrap all matched elements together
$('p').wrapAll('<div class="all"></div>')

// wrap inner contents
$('p').wrapInner('<span></span>')
// <p><span>...</span></p>

// clone (with events)
const $copy = $('.box').clone(true)  // true = clone events too
$('body').append($copy)

// unwrap (remove wrapper)
$('.box').unwrap()

Iterieren & Filtern

.each() iteriert — 'this' ist das rohe DOM-Element; false zurückgeben bricht ab, alles andere läuft weiter. .map() transformiert in eine neue jQuery-Sammlung; .get() zu einem plain array wandeln. .filter() verengt per Selektor oder callback; .not() ist das Gegenteil. .is() gibt einen boolean zurück (passt irgendein Element?) — praktisch für Bedingungen. for-Loops mit .eq(i) vermeiden; idiomatisch .each() oder .map().

jquery
// .each: iterate (this = DOM element, i = index)
$('li').each(function (i, el) {
  console.log(i, this, el)  // el === this
  if (i === 2) return false  // break
  // return true to continue
})

// .map: transform to new array
const ids = $('li').map(function (i, el) {
  return $(el).data('id')
}).get()  // .get() converts to plain array

// .filter: keep matching
$('li').filter('.active').addClass('on')
$('li').filter(function (i) { return i % 2 === 0 })

// .not: remove matching
$('li').not('.active').addClass('off')

// .is: returns boolean (does ANY match?)
if ($('li').is('.active')) { /* at least one is active */ }
05

CSS-Manipulation

CSS-Eigenschaften lesen & setzen

.css() liest berechnete Stile (immer den aufgelösten Wert, auch aus CSS-regeln) oder setzt inline styles. Für getter einen einzelnen Eigenschaftsnamen übergeben (gibt einen String). Für setter (prop, value) oder ein Objekt aus prop:value-Paaren. Eigenschaftsnamen in camelCase oder kebab-case (letzteres braucht quotes). Zahlenwerte defaulten bei den meisten Eigenschaften auf Pixel. .css() für layout vermeiden — klassen und stylesheets sind wartbarer.

jquery
// get computed style (first matched element)
$('.box').css('color')           // 'rgb(255, 0, 0)'
$('.box').css('font-size')       // '14px'

// set single property
$('.box').css('color', 'red')

// set multiple properties
$('.box').css({
  color: 'red',
  'background-color': '#eee',  // kebab-case needs quotes
  fontSize: '16px',            // or use camelCase
  marginTop: '10px'
})

// setter with callback (index, old value)
$('div').css('width', function (i, old) {
  return (parseInt(old) + 50) + 'px'
})

Klassen-Manipulation

Klassen-Methoden sind der bevorzugte Weg, Elemente zu stylen — die Darstellung bleibt im CSS, nicht im JS. .addClass, .removeClass, .toggleClass akzeptieren leerzeichengetrennte Klassenlisten. .toggleClass(name, bool) ergänzt/entfernt nach dem boolean — praktisch für zustandsgetriebene UI. .hasClass(name) gibt einen boolean zurück (prüft nur das erste Element). Für Performance sind Klassen deutlich schneller als .css() bei nicht-trivialem Styling — sie batchen Änderungen und lassen den Browser optimieren.

jquery
// add class
$('.box').addClass('active')

// remove class
$('.box').removeClass('active')

// toggle (add if absent, remove if present)
$('.box').toggleClass('active')

// toggle based on boolean
$('.box').toggleClass('active', isValid)

// add/remove multiple (space-separated)
$('.box').addClass('active highlighted urgent')
$('.box').removeClass('active highlighted')

// check if has class (boolean)
if ($('.box').hasClass('active')) { /* ... */ }

// callback form (index, hasClass)
$('div').toggleClass('even', function (i) {
  return i % 2 === 0
})

width & height

.width()/.height() = content box (ohne padding/border). .innerWidth()/.innerHeight() = content + padding. .outerWidth()/.outerHeight() = content + padding + border. .outerWidth(true) inkl. margin. Setter nehmen eine Zahl (px) oder einen String. Für window/document $(window) für den viewport und $(document) für die ganze Seite. Diese geben Zahlen zurück (nicht Strings wie .css('width')) — bequem für Mathematik.

jquery
// content size (excludes padding, border, margin)
$('.box').width()          // e.g., 200
$('.box').width(300)       // set content width to 300px
$('.box').height()

// inner (content + padding)
$('.box').innerWidth()
$('.box').innerHeight()

// outer (content + padding + border)
$('.box').outerWidth()
$('.box').outerHeight()

// outer including margin
$('.box').outerWidth(true)

// window & document
$(window).width()    // viewport width
$(document).height() // full document height

position & offset

.offset() gibt {top, left} relativ zum Dokument zurück (nützlich für absolute positionierung oder drag-drop). .position() liefert Koordinaten relativ zum offset parent (der nächste Vorfahre mit position: relative/absolute/fixed). .scrollTop()/.scrollLeft() lesen oder setzen die scroll-position — $(window).scrollTop(0) scrollt nach oben. .offsetParent() findet den positionierten Vorfahren. Pflicht für Animationen, drag-drop und infinite scroll.

jquery
// .offset(): position relative to document
const off = $('.box').offset()
console.log(off.left, off.top)  // e.g., 100, 50
$('.box').offset({ top: 200, left: 100 })  // set

// .position(): position relative to offset parent
const pos = $('.box').position()
console.log(pos.left, pos.top)

// .scrollTop() / .scrollLeft(): scroll position
$(window).scrollTop()       // how far scrolled down
$(window).scrollTop(0)      // scroll to top
$('.container').scrollTop(100)

// .offsetParent(): nearest positioned ancestor
$('.box').offsetParent()

scroll & Koordinaten

scroll-Behandlung ist üblich für sticky navs, infinite scroll und scroll-getriggerte Animationen. $('html, body').animate({scrollTop: n}) scrollt geschmeidig. Für Performance scroll handler drosseln (sie feuern oft je scroll). Der isVisible helper prüft, ob ein Element im viewport liegt — nützlich für lazy-loading von Bildern oder Animationstrigger. Modernes IntersectionObserver ist effizienter für Sichtbarkeitserkennung; bei neuen Projekten erwägen.

jquery
// scroll to top smoothly
$('html, body').animate({ scrollTop: 0 }, 500)

// scroll to an element
const top = $('#section').offset().top
$('html, body').animate({ scrollTop: top }, 500)

// detect scroll position
$(window).on('scroll', function () {
  const scrolled = $(window).scrollTop()
  if (scrolled > 100) {
    $('.nav').addClass('fixed')
  } else {
    $('.nav').removeClass('fixed')
  }
})

// check if element is in viewport
function isVisible($el) {
  const t = $el.offset().top
  const h = $el.outerHeight()
  const wTop = $(window).scrollTop()
  const wH = $(window).height()
  return t >= wTop && (t + h) <= (wTop + wH)
}
06

AJAX

$.ajax (volle Kontrolle)

$.ajax ist die low-level, vollkontrollierte Methode. method/http verb, data (als query bei GET oder body bei POST gesendet), dataType deutet die erwartete Antwort an (automatisch geparst). success/error/complete sind die legacy callback hooks. beforeSend erlaubt das Verändern des xhr (header ergänzen). timeout bricht nach N ms ab. Für modernen Code fetch() oder $.ajax mit .done()/.fail()-promises statt success/error callbacks bevorzugen.

jquery
$.ajax({
  url: '/api/users',
  method: 'GET',                // or 'POST', 'PUT', 'DELETE'
  data: { page: 1, limit: 10 }, // query string or body
  dataType: 'json',             // expected response type
  contentType: 'application/json',
  timeout: 5000,                // ms
  headers: { 'X-Token': 'abc' },
  beforeSend: function (xhr) { /* ... */ },
  success: function (data, status, xhr) {
    console.log('got', data)
  },
  error: function (xhr, status, error) {
    console.error('failed', status, error)
  },
  complete: function (xhr, status) {
    // runs on both success and error
  }
})

Kurzfassung: $.get & $.post

$.get und $.post sind Kurzfassungen für einfache GET/POST-Anfragen. Das promise-artige interface (.done/.fail/.always) ist sauberer als success/error callbacks — und erlaubt mehrere .done handler zu verketten. Für JSON-request bodies contentType: 'application/json' setzen UND die daten mit JSON.stringify versehen (jQuery stringifiziert Objekte nicht automatisch als JSON). Hinweis: jQuerys promise ist ein Deferred, kein natives Promise, verhält sich aber für die meisten Fälle ähnlich.

jquery
// GET request
$.get('/api/users', { page: 1 }, function (data) {
  console.log(data)
}, 'json')

// promise-based (preferred)
$.get('/api/users', { page: 1 })
  .done(function (data) { console.log(data) })
  .fail(function (xhr, status, err) { console.error(err) })

// POST request
$.post('/api/users', { name: 'Alice' })
  .done(function (data) { /* created */ })

// POST JSON
$.ajax({
  url: '/api/users',
  method: 'POST',
  contentType: 'application/json',
  data: JSON.stringify({ name: 'Alice' })
})

HTML in Elemente laden

.load() ist eine spezialisierte Kurzfassung: HTML von einer URL holen und in passende Elemente injizieren. Die 'url #fragment'-Syntax lädt nur einen Teil der Antwort (den auf #fragment passenden). .load() eignet sich für Teilseiten-Updates ohne vollen reload — üblich in legacy SPAs. GET per default, POST bei data. Der callback erhält (responseText, status, xhr). Für moderne apps fetch + manuelles DOM-update bevorzugen.

jquery
<!-- load HTML from server into element -->
<div id="content">Loading...</div>

<script>
$('#content').load('/partials/header.html')

// load a fragment (selector after URL space)
$('#content').load('/page.html #main')

// with callback (response, status, xhr)
$('#content').load('/page.html', function (resp, status, xhr) {
  if (status === 'error') {
    $('#content').html('Failed to load')
  }
})

// POST with data
$('#content').load('/api', { id: 5 })
</script>

getJSON & getScript

$.getJSON ist die Kurzfassung von $.ajax mit dataType:'json' — parst die Antwort automatisch. Der '?callback=?'-Trick aktiviert JSONP für cross-domain-Anfragen (legacy — heute CORS nutzen). $.getScript holt und führt eine JavaScript-Datei aus — praktisch zum lazy-loading von plugins oder analytics auf Abruf. Beide geben jqXHR-(promise-artige-)Objekte zurück. Für cross-domain heute sicherstellen, dass der Server CORS-Header sendet; JSONP ist ein pre-CORS-Ausweg mit Sicherheitsvorbehalten.

jquery
// fetch and parse JSON
$.getJSON('/api/users', { page: 1 })
  .done(function (data) {
    console.log(data.users)
  })
  .fail(function (xhr, status, err) {
    console.error('JSON fetch failed:', err)
  })

// fetch and execute a script
$.getScript('/js/analytics.js')
  .done(function (script, status) {
    console.log('analytics loaded')
    // script is now available
  })
  .fail(function () {
    console.error('script failed')
  })

// JSONP (cross-domain, legacy)
$.getJSON('https://api.example.com/data?callback=?')
  .done(function (data) { /* ... */ })

Globale AJAX-Events & Setup

Globale AJAX-events (ajaxStart, ajaxStop, ajaxComplete, ajaxError, ajaxSuccess) feuern für jede AJAX-Anfrage — perfekt für globale loader und Fehlerbehandlung. $.ajaxSetup setzt defaults für alle folgenden AJAX-Aufrufe (URL base, header, timeout). .serialize() macht aus einem Formular einen query string; .serializeArray() liefert ein Array aus {name, value}-Objekten — praktisch für JSON oder eigene payloads. Bei zustandsändernden Anfragen immer ein CSRF-token mitgeben.

jquery
// global ajax event handlers (bind on document)
$(document)
  .ajaxStart(function () { $('#loader').show() })
  .ajaxStop(function () { $('#loader').hide() })
  .ajaxError(function (e, xhr, settings, error) {
    console.error('AJAX error:', settings.url, error)
  })

// default settings for all AJAX
$.ajaxSetup({
  baseURL: '/api',
  timeout: 10000,
  headers: { 'X-CSRF-Token': $('meta[name=csrf]').attr('content') }
})

// now $.get('/users') -> GET /api/users with the headers
$.get('/users').done(/* ... */)

// serialize a form for AJAX
const data = $('form').serialize()       // "name=Alice&age=30"
const arr = $('form').serializeArray()   // [{name, value}, ...]
07

Effekte & Animationen

show/hide Grundlagen

.show()/.hide()/.toggle() ändern display. Ohne Argumente instant ein-/ausblenden. Mit Dauer animieren sie width/height/opacity. 'slow' = 600ms, 'fast' = 200ms, oder eine Zahl in ms. Der callback feuert nach Ende der Animation. jQuery-Animationen nutzen per default requestAnimationFrame (ohne Jank). Hinweis: .hide() setzt display:none; .show() stellt den originalen display-Wert wieder her. Für mehr Kontrolle direkt .animate().

jquery
// instantly show/hide/toggle
$('.box').show()
$('.box').hide()
$('.box').toggle()

// animated (duration in ms or 'slow'/'fast')
$('.box').show(400)         // fade in over 400ms
$('.box').hide('slow')      // ~600ms
$('.box').toggle(300)

// with callback (runs when animation completes)
$('.box').hide(300, function () {
  console.log('hidden')
})

// easing (default 'swing', also 'linear' with plugin)
$('.box').hide({ duration: 300, easing: 'linear' })

Fading

Fade-Animationen ändern nur opacity (display bleibt). .fadeTo(animiert zu einer konkreten opacity — nützlich, um Elemente abzudunkeln, ohne sie ganz zu verbergen. Animationen reihen sich pro Element: verkettete .fadeOut().fadeIn() laufen sequenziell, nicht gleichzeitig. Für Parallelität .animate() mit mehreren Eigenschaften oder der queue-Option nutzen. Fading ist geschmeidiger als show/hide für opacity-getriebene UI wie Benachrichtigungen.

jquery
// fade in / out / toggle (opacity only)
$('.box').fadeIn(400)
$('.box').fadeOut(400)
$('.box').fadeToggle(400)

// fade to a specific opacity (0.0 - 1.0)
$('.box').fadeTo(400, 0.5)  // 50% opacity

// with callback
$('.box').fadeOut(300, function () {
  // runs after fade out completes
  $(this).remove()
})

// sequence: fade out, then fade in
$('.box')
  .fadeOut(300)
  .fadeIn(300)  // queued automatically

Sliding

Sliding animiert height (und display). .slideDown enthüllt ein Element (von display:none zu seiner natürlichen Höhe), .slideUp verbirgt es (kollabiert auf 0, dann display:none), .slideToggle kehrst den zustand um. Perfekt für accordions, dropdowns und zusammenklappbare panels. Mit siblings() für accordion-verhalten kombinieren (andere schließen, wenn eines öffnet). Sliding ist die häufigste jQuery-Animation — geschmeidig und barrierefreiheitsfreundlich mit passendem ARIA.

jquery
// slide down (reveal) / up (hide) / toggle
$('.panel').slideDown(400)
$('.panel').slideUp(400)
$('.panel').slideToggle(400)

// accordion pattern
$('.accordion .header').on('click', function () {
  $(this).next('.content').slideToggle(300)
       .siblings('.content').slideUp(300)
})

// callback after slide completes
$('.panel').slideUp(300, function () {
  console.log('panel closed')
})

Eigenes .animate()

.animate() tweened numerische CSS-Eigenschaften über eine Dauer. Relative Werte ('+=50') für schrittweise Änderungen. Eigenschaftsnamen in camelCase (marginLeft, nicht margin-left). Farben brauchen das jQuery Color plugin oder jQuery UI — core jQuery animiert nur Zahlen. Die options-Form gibt mehr Kontrolle: queue:false läuft parallel statt sequenziell. Easing defaultet auf 'swing' (ease-out); 'linear' ist gleichmäßig. Viele Eigenschaften in einem Aufruf animierbar.

jquery
// animate numeric CSS properties
$('.box').animate({
  width: '+=50',       // relative: add 50px
  height: '300px',
  opacity: 0.5,
  marginLeft: '20px',  // camelCase for hyphenated props
  fontSize: '20px'
}, 800, 'swing', function () {
  console.log('animation done')
})

// options object form
$('.box').animate({
  left: 500
}, {
  duration: 1000,
  easing: 'linear',
  complete: function () { /* done */ },
  queue: false  // run immediately, not queued
})

// NOTE: colors can't be animated without jQuery UI / color plugin

Stoppen & Verketten

.stop() hält Animationen an; (clearQueue, jumpToEnd) gibt Kontrolle. Ohne stop stapeln sich bei schnellem hover Animationen (das Element animiert lange nach dem Verlassen weiter) — .stop(true) vor .animate() verhindert das. .finish() springt alle eingereihten Animationen sofort an ihr Ende. .delay(ms) fügt in die animations queue eine Pause ein — praktisch für Sequenzierung. hover-Animationen immer mit .stop() paaren, um ruckelnden Aufbau zu vermeiden.

jquery
// .stop(): stop current animation
$('.box').stop()              // stop, leave at current state
$('.box').stop(true)          // clear queue too
$('.box').stop(true, true)    // clear queue AND jump to end

// prevent animation buildup on rapid hover
$('.box').hover(function () {
  $(this).stop(true).animate({ width: 300 }, 200)
}, function () {
  $(this).stop(true).animate({ width: 100 }, 200)
})

// .finish(): jump all queued animations to end state
$('.box').finish()

// .delay(): pause between queued animations
$('.box')
  .fadeOut(300)
  .delay(500)        // wait 500ms
  .fadeIn(300)
08

Traversieren

Nach oben (parents)

Traversieren nach oben: .parent() (unmittelbares parent), .parents() (alle Vorfahren bis zum document), .parents(selector) filtert sie, .closest(selector) geht nach oben und gibt den ersten Treffer zurück (inkl. self — am häufigsten, um ein umschließendes Bauteil zu finden). .parentsUntil(selector) liefert Vorfahren bis zum (ausschließlich) Treffer. .closest() ist das Arbeitstier der event delegation — vom geklickten Element zur umschließenden card/row/komponente.

jquery
// direct parent
$('#item').parent()

// all ancestors (up to <html> or selector)
$('#item').parents()              // all ancestors
$('#item').parents('.container')  // first .container ancestor

// closest ancestor (incl. self) matching selector
$('#item').closest('.box')  // very common - find enclosing box

// parentsUntil: ancestors up to (not including) match
$('#item').parentsUntil('.wrapper')

// offsetParent: nearest positioned ancestor
$('#item').offsetParent()

Nach unten (kinder)

.children() gibt nur direkte kinder zurück (eine Ebene); .find() steigt durch alle Ebenen. .find() ist am häufigsten — von einem container passende Nachfahren finden (etwa alle formularfelder in einem formular). .children() ist schneller, wenn nur direkte kinder nötig sind. .contents() umfasst text nodes und comment nodes (praktisch für Textverarbeitung oder iframes). Beide mit einem selektor filtern. Traversierungen immer mit .find() scopen, um nicht das ganze Dokument zu scannen.

jquery
// direct children (optionally filtered)
$('#list').children()             // all direct children
$('#list').children('.item')      // direct children with class .item

// all descendants (filtered)
$('#list').find('li')             // all <li> anywhere inside
$('#list').find('.active')        // all .active descendants

// contents: children including text/comment nodes
$('#box').contents()

// first/last child
$('#list').children().first()
$('#list').children().last()

Seitwärts (geschwister)

Geschwister-Traversierung: .siblings() (alle), .next()/.prev() (unmittelbar), .nextAll()/.prevAll() (alle in eine Richtung), .nextUntil()/.prevUntil() (bis zu einem Treffer). Mit einem selektor filtern. Das klassische aktive-tab-muster ($(this).addClass('active').siblings().removeClass('active')) nutzt siblings zum Zurücksetzen der geschwister. Geschwister teilen dasselbe parent — anders verschachtelte Elemente sind keine geschwister.

jquery
// all siblings (excluding self)
$('#item').siblings()
$('#item').siblings('.active')  // siblings with class .active

// next/prev: immediate sibling
$('#item').next()
$('#item').prev()

// nextAll/prevAll: all following/preceding siblings
$('#item').nextAll()
$('#item').prevAll('.item')

// nextUntil/prevUntil: siblings up to a match
$('#item').nextUntil('.stop')

// common: highlight active tab
$('.tab').on('click', function () {
  $(this).addClass('active').siblings().removeClass('active')
})

Eine Auswahl filtern

Filtern verengt die aktuelle Menge, ohne das DOM neu abzufragen. .filter(selector) behält Treffer; .not(selector) ist das Gegenteil. .has(selector) behält Elemente mit passendem Nachfahren. .eq(n) reduziert auf ein Element (negatives n zählt vom Ende). .first()/.last() sind Komfort. .slice(start, end) nimmt einen Bereich. Diese nutzen, um nach der Traversierung zu verfeinern statt komplexe Selektoren zu schreiben — oft klarer und schneller.

jquery
// .filter: keep matching
$('li').filter('.active')
$('li').filter(function (i) { return i % 2 === 0 })  // even index

// .not: remove matching (inverse of filter)
$('li').not('.active')
$('li').not(':first')

// .has: keep elements that contain a descendant
$('div').has('p')  // divs that contain <p>

// .eq: reduce to one element by index
$('li').eq(2)      // 3rd <li> (0-indexed)
$('li').eq(-1)     // last <li>

// .first / .last
$('li').first()
$('li').last()

// .slice: range
$('li').slice(2, 5)  // indices 2, 3, 4

Verketten mit .end() & .addBack()

.end() poppt den Traversierungs-stack und kehrt zur vorigen Menge zurück — Pflicht für lesbare Ketten, die traversieren und dann am Original weiterarbeiten. .addBack() (früher .andSelf) verschmilzt die aktuelle mit der vorigen Menge, sodass das original element an Folgeoperationen teilnimmt. So entstehen mächtige Einzeiler: kinder finden, verändern, end() zurück zum parent, das parent verändern. Ketten einrücken, um die Traversierungsstruktur klar zu machen.

jquery
// .end(): pop back to previous set after a traversal
$('ul')              // [ul]
  .find('li')        // [li, li, li]
    .addClass('item')
    .end()           // back to [ul]
  .addClass('has-items')

// .addBack(): include previous set in current
$('ul')
  .children('li')    // [li, li]
    .addClass('item')
    .addBack()       // [li, li, ul]
  .addClass('related')

// without .addBack, the ul would not get .related
// .andSelf (old name) is deprecated, use .addBack
09

Utility-Funktionen

Iteration: $.each & $.map

$.each iteriert arrays (index, value) oder objekte (key, value) — die Reihenfolge der Argumente ist gegenüber Array.forEach vertauscht. false zurückgeben bricht ab. $.map transformiert jedes item in ein neues array (null zurückgeben überspringt). $.grep filtert ein array. Das sind jQuerys vor-ES5-Iterations-utilities; moderner Code nutzt meist native Array-Methoden (forEach, map, filter). Hauptgrund für $.each bleibt das Iterieren von plain objekten (modern: Object.entries).

jquery
// $.each: iterate arrays or objects (returns the collection)
$.each([10, 20, 30], function (index, value) {
  console.log(index, value)  // 0 10, 1 20, 2 30
  if (value === 20) return false  // break
})

$.each({ a: 1, b: 2 }, function (key, value) {
  console.log(key, value)  // 'a' 1, 'b' 2
})

// $.map: transform to a new array
const doubled = $.map([1, 2, 3], function (value, index) {
  return value * 2  // [2, 4, 6]
})

// return null/undefined to skip
const evens = $.map([1, 2, 3, 4], function (v) {
  return v % 2 === 0 ? v : null  // [2, 4]
})

// $.grep: filter an array
const evens = $.grep([1, 2, 3, 4], function (v) { return v % 2 === 0 })
// [2, 4]

Typ-Prüfung

$.type gibt einen kleingeschriebenen Typ-String zurück (granularer als typeof). $.isArray, $.isFunction, $.isPlainObject, $.isEmptyObject, $.isWindow, $.isNumeric sind Komfort-booleans. $.isPlainObject unterscheidet plain {} von instanzen wie new Date oder window. $.isNumeric gibt true für endliche Zahlen und numerische strings (in neuerem jQuery nicht für hex wie '0x1F'). Im modernen JS decken Array.isArray und typeof das meiste ab, aber $.isPlainObject bleibt praktisch für deep-extend-Sicherheit.

jquery
// $.type: detailed type
$.type([])         // 'array'
$.type({})         // 'object'
$.type('hi')       // 'string'
$.type(null)       // 'null'
$.type(undefined)  // 'undefined'
$.type(/regex/)    // 'regexp'

// specific checks (all return boolean)
$.isArray([])           // true
$.isFunction(fn => {})  // true
$.isEmptyObject({})     // true
$.isPlainObject({})     // true (created by {} or new Object)
$.isPlainObject([])     // false
$.isWindow(window)      // true
$.isNumeric('42')       // true (also '0x1F')
$.isNumeric('abc')      // false

// $.isEmptyObject: no own enumerable props
$.isEmptyObject({ a: 1 })  // false

Objekt- & array-utilities

$.extend merge objekte — spätere eigenschaften übersteuern frühere. true als erstes Argument für tiefes (rekursives) merge; sonst flach. Immer {} als erstes Argument, um die quelle nicht zu mutieren. $.merge verkettet arrays (mutiert das erste). $.inArray ist indexOf (gibt -1 zurück, wenn nicht gefunden). $.makeArray wandelt array-ähnliche objekte (NodeList, arguments) in echte arrays — modern: Array.from oder spread [...nl].

jquery
// $.extend: merge objects (mutates first unless deep copy flag)
const defaults = { a: 1, b: 2 }
const options = { b: 3, c: 4 }
const merged = $.extend({}, defaults, options)
// { a: 1, b: 3, c: 4 }  (later overrides earlier)

// deep merge (recurses into nested objects)
const deep = $.extend(true, {},
  { nested: { x: 1, y: 2 } },
  { nested: { y: 3, z: 4 } }
)
// { nested: { x: 1, y: 3, z: 4 } }

// $.merge: combine two arrays (mutates first)
const combined = $.merge([1, 2], [3, 4])  // [1, 2, 3, 4]

// $.inArray: find index (-1 if not found)
const idx = $.inArray(2, [1, 2, 3])  // 1

// $.makeArray: convert array-like to true array
const arr = $.makeArray(document.querySelectorAll('li'))

string & daten utilities

$.trim entfernt whitespace (modern: str.trim()). $.parseHTML wandelt einen HTML-string in ein Array von DOM-nodes — sicherer als $.fn.html für untrustetem input (vermeidet script ausführung). $.param serialisiert ein objekt zu einem query string (das Gegenteil von parse). $.now ist Date.now(). $.unique dedupliziert DOM-element-arrays (heute selten nötig). Die meisten haben moderne native Pendants; am nützlichsten bleiben $.param (für AJAX-daten) und $.parseHTML.

jquery
// $.trim: remove leading/trailing whitespace
$.trim('  hello  ')  // 'hello'  (use str.trim() in modern code)

// $.parseHTML: parse string to DOM nodes
const nodes = $.parseHTML('<div><p>Hi</p></div>')
// [div] — array of DOM nodes

// $.parseJSON: parse JSON string (use JSON.parse instead)
const obj = $.parseJSON('{"a":1}')

// $.param: serialize object to query string
$.param({ name: 'Alice', age: 30 })
// 'name=Alice&age=30'
$.param({ tags: ['a', 'b'] })
// 'tags%5B%5D=a&tags%5B%5D=b'

// $.now: current timestamp (Date.now equivalent)
$.now()  // 1700000000000

// $.unique: remove duplicates from DOM element array
$.unique($('.box').get())

daten-speicher ($.data)

$.data / .data() speichert beliebige werte an elemente gebunden in einem internen cache (nicht im DOM sichtbar, schneller als attribute). .data() liest zudem automatisch data-* attribute (mit typkonvertierung: zahlen, booleans, JSON). Wichtig: .data(name, value) schreibt in den cache, NICHT in das data-* attribut — um das attribut selbst zu aktualisieren .attr('data-name', val) nutzen. .removeData leert den cache-eintrag. Der cache wird beim .remove() der elemente aufgeräumt und verhindert leaks.

jquery
// store data on an element (private, won't appear in DOM)
$.data(document.getElementById('box'), 'key', { count: 1 })

// read it back
const v = $.data(el, 'key')  // { count: 1 }

//.data() method form (more common)
$('.box').data('key', { count: 1 })
$('.box').data('key')        // { count: 1 }

// auto-parses data-* attributes
// <div class="box" data-id="42" data-name="alice"></div>
$('.box').data('id')    // 42 (auto-cast to number)
$('.box').data('name')  // 'alice'

// remove data
$('.box').removeData('key')

// note: .data() does NOT write back to data-* attrs
// use .attr('data-key', val) to update the attribute
10

plugins & extensions

ein plugin schreiben

plugins erweitern $.fn (jQuerys prototype) und sind damit auf sammlungen aufrufbar. Immer this zurückgeben (oder das ergebnis einer methode an this) für verkettbarkeit. Innerhalb des plugins ist 'this' die jQuery-sammlung; innerhalb von .each() ein rohes DOM-element. In ein IIFE wickeln, um $ sicher über jQuery zu aliasieren. Das $.extend defaults muster ist der standardweg, um optionen mit sinnvollen defaults zu akzeptieren. plugins über npm oder als eigenständige skripte veröffentlichen.

jquery
// basic plugin pattern
(function ($) {
  $.fn.highlight = function (color) {
    // 'this' is the jQuery collection
    return this.css('background', color || 'yellow')
  }
}(jQuery))

// usage
$('.box').highlight('red')
$('.box').highlight()  // default 'yellow'

// options pattern
$.fn.tooltip = function (options) {
  const settings = $.extend({
    position: 'top',
    delay: 200
  }, options)

  return this.each(function () {
    // 'this' is a DOM element here
    // ... tooltip logic ...
  })
}

plugin mit methoden

Das boilerplate-plugin muster nutzt ein methods objekt, das das erste argument verteilt: $('.c').counter({ start: 5 }) für init, $('.c').counter('increment') zum methodenaufruf. der zustand liegt in $.data. dieses muster war vor vue/react populär für komponenten wie sliders, modals, datepickers. heute ist ein framework (vue/react) meist die bessere wahl für zustandsbehaftete UI; zum aufstocken von legacy jquery seiten bleibt das muster nützlich und gut verstanden.

jquery
// stateful plugin using data + methods
(function ($) {
  $.fn.counter = function (method) {
    const methods = {
      init: function (options) {
        return this.each(function () {
          const $el = $(this)
          $el.data('count', options?.start || 0)
          $el.text($el.data('count'))
        })
      },
      increment: function () {
        return this.each(function () {
          const $el = $(this)
          const c = $el.data('count') + 1
          $el.data('count', c).text(c)
        })
      },
      reset: function () {
        return this.each(function () {
          $(this).data('count', 0).text(0)
        })
      }
    }

    if (methods[method]) {
      return methods[method].apply(this, Array.prototype.slice.call(arguments, 1))
    } else if (typeof method === 'object' || !method) {
      return methods.init.apply(this, arguments)
    } else {
      $.error('Method ' + method + ' does not exist')
    }
  }
}(jQuery))

beliebte plugins nutzen

jQuery UI ist die offizielle begleitbibliothek für widgets (datepicker, accordion, autocomplete, dialog) und interaktionen (draggable, droppable, sortable). weitere beliebte plugins: DataTables (funktionsreiche tabellen), Select2 (verbesserte selects), Slick (carousels), Magnific Popup (modals). plugin CSS und JS nach jQuery einbinden. auf DOM ready initialisieren. viele plugins bieten eine methoden-api wie $('#x').plugin('method', args) und options-updates via plugin('option', name, val).

jquery
<!-- jQuery UI (interactions, widgets, effects) -->
<link rel="stylesheet" href="https://code.jquery.com/ui/1.13.2/themes/base/jquery-ui.css">
<script src="https://code.jquery.com/ui/1.13.2/jquery-ui.min.js"></script>

<script>
// datepicker
$('#date').datepicker({ dateFormat: 'yy-mm-dd' })

// draggable / droppable / sortable
$('.item').draggable()
$('.list').sortable()

// dialog
$('<div>Hello</div>').dialog({ modal: true })
</script>

<!-- Other common plugins -->
<!-- DataTables: tables with sorting, search, pagination -->
<!-- Select2: enhanced <select> with search -->
<!-- Slick: carousel/slider -->
<!-- Magnific Popup: lightbox/modal -->

widget factory (jQuery UI)

die jQuery UI widget factory ($.widget) ist ein strukturierter weg, zustandsbehaftete, vererbungsfreundliche plugins zu bauen. sie liefert _create (konstruktor), _destroy (aufräumen), _setOption, _on (event binding mit automatischem aufräumen), _trigger (eigene events). optionen sind über die methoden-api erreichbar: $el.widget('option', name, value). eigene events feuern als widgetname + eventname. für komplexe zustandsbehaftete UI in jquery ist die widget factory das robusteste muster — für neuen code aber einen wechsel zu vue/react erwägen.

jquery
// create a reusable widget with state + inheritance
$.widget('my.counter', {
  options: { start: 0 },

  _create: function () {
    this.count = this.options.start
    this._refresh()
    this._on(this.element, { click: 'increment' })
  },

  increment: function () {
    this.count++
    this._refresh()
    this._trigger('changed', null, { count: this.count })
  },

  _refresh: function () {
    this.element.text(this.count)
  },

  _destroy: function () {
    this.element.text('')
  }
})

// usage
$('#el').counter({ start: 5 })  // init
$('#el').counter('increment')   // call method
$('#el').on('counterchanged', function (e, data) {
  console.log('count is', data.count)
})
$('#el').counter('destroy')     // cleanup

plugin best practices

plugin best practices: (1) immer this zurückgeben für verkettbarkeit; (2) in ein IIFE wickeln für $-sicherheit; (3) .each() nutzen, damit das plugin auf mehr-element-auswahlen funktioniert; (4) events namespacen (click.myplugin), damit nutzer entbinden können, ohne andere zu berühren; (5) optionen mit $.extend merge und defaults exponieren, damit nutzer global übersteuern können; (6) beim destroy aufräumen (events, daten, DOM-änderungen); (7) den plugin-namen namespacen, um kollisionen zu vermeiden; (8) öffentliche methoden und defaults exponieren für flexibilität.

jquery
// 1. always return this for chainability
$.fn.green = function () { return this.css('color', 'green') }

// 2. use IIFE for $ safety
(function ($) { /* plugin */ })(jQuery)

// 3. iterate with .each() for multi-element support
$.fn.x = function () { return this.each(function () { /* per element */ }) }

// 4. namespace events so users can unbind cleanly
this._on(this.element, { 'click.myplugin': 'handler' })

// 5. accept options via $.extend
const opts = $.extend({}, $.fn.x.defaults, options)
$.fn.x.defaults = { color: 'red' }

// 6. clean up on destroy (events, data, DOM)
// 7. namespace your plugin name to avoid collisions
// 8. provide public methods + defaults accessible for override
11

attribute & properties

attribute getter & setter

.attr() liest/schreibt HTML attribute (die markup-werte, immer strings). .prop() liest/schreibt DOM properties (der aktuelle zustand — etwa die checked property einer checkbox kann sich vom checked attribut unterscheiden, nachdem der nutzer interagiert hat). .prop() für boolesche attribute (checked, disabled, selected) und .attr() für andere (href, src, alt, data-*). .data() liest data-*, speichert werte aber in einem internen cache mit typ-erhaltung — um das DOM attribut selbst zu ändern .attr('data-*') nutzen.

jquery
// .attr: HTML attribute (what's in the markup)
$('img').attr('src')              // get
$('img').attr('src', 'new.jpg')   // set
$('img').attr({                   // set multiple
  src: 'new.jpg',
  alt: 'Photo',
  width: 200
})

// .removeAttr: remove attribute entirely
$('img').removeAttr('alt')

// .prop: DOM property (current state, may differ from attr)
$('input').prop('checked')        // true/false (current state)
$('input').prop('checked', true)  // check it
$('input').prop('disabled', true)

// data-* attributes
$('div').attr('data-id', 42)      // sets the attribute (string)
$('div').data('id', 42)           // stores in cache (typed)

daten attribute

.data(name) liest data-* attribute mit automatischer typkonvertierung (zahlen, booleans, JSON). .data(name, value) schreibt in einen internen cache, NICHT in das attribut — .attr('data-name') liefert also weiterhin das original. um das tatsächliche DOM attribut zu aktualisieren (etwa für CSS selektoren oder serverseitiges lesen) .attr('data-name', value) nutzen. dieser unterschied verursacht bugs bei verwirrung. .removeData leert den cache. camelcase-namen: data-foo-bar wird .data('fooBar').

jquery
<!-- HTML -->
<div class="box" data-id="42" data-name="alice" data-active="true" data-config='{"x":1}'></div>

<script>
// .data() reads data-* with auto type conversion
$('.box').data('id')       // 42 (number, not string)
$('.box').data('name')     // 'alice'
$('.box').data('active')   // true (boolean)
$('.box').data('config')   // { x: 1 } (parsed JSON)

// set data (stored in cache, NOT the attribute)
$('.box').data('id', 99)
$('.box').data('id')       // 99
$('.box').attr('data-id')  // still '42' (attribute unchanged)

// to update the attribute itself, use .attr
$('.box').attr('data-id', 99)

// remove data
$('.box').removeData('id')
</script>

formular properties

für den formularzustand .prop() (boolesche DOM properties) nutzen — .prop('checked') spiegelt den aktuellen zustand, während .attr('checked') das anfängliche HTML attribut zurückgibt (aktualisiert sich bei nutzerinteraktion nicht). .val() liest/setzt formularwerte einheitlich. bei radios das :checked finden und dessen .val() lesen. bei multi-select gibt .val() ein array zurück. .is(':checked') ist ein sauberer boolean-check. diese unterschiede zählen bei formularvalidierung und serialisierung.

jquery
// checkbox state
$('input[type=checkbox]').prop('checked')     // true/false
$('input[type=checkbox]').prop('checked', true)
$('input[type=checkbox]').is(':checked')      // boolean

// disabled / readonly
$('input').prop('disabled', true)
$('input').prop('readOnly', true)  // note: camelCase

// select value
$('select').val()                  // selected value
$('select').val('option2')         // set selected
$('select option:selected').text() // selected text

// multiple select
$('select[multiple]').val()        // ['a', 'b'] array

// radio: value of checked
$('input[name=gender]:checked').val()

//.prop vs .attr for checkboxes:
// .prop('checked') = current state (changes when clicked)
// .attr('checked') = initial HTML value (doesn't change)

klasse vs. attribut

drei wege, den elementzustand für CSS und JS zu exponieren: klassen (bekannt, .hasClass), data-* attribute (abfragbar, wert-tragend) und ARIA attribute (für screenreader zugänglich). für visuellen zustand sind klassen am einfachsten. für mehrwertigen zustand (data-state='loading|success|error') sind data-* sauberer. für barrierefreiheit aria-* (aria-pressed, aria-expanded, aria-busy) — sie überlappen oft mit visuellem zustand, also paaren. moderne frameworks erleichtern das, aber in jquery bewusst wählen.

jquery
// adding behavior tags via class
$('.btn').addClass('loading')
// CSS: .btn.loading { opacity: 0.5; pointer-events: none; }

// via data attribute (cleaner for state)
$('.btn').attr('data-state', 'loading')
// CSS: .btn[data-state="loading"] { ... }

// via aria (accessible)
$('.btn').attr('aria-busy', 'true')

// choosing:
// - class: many CSS hooks, well-known
// - data-*: cleaner for state values, queryable
// - aria-*: exposes state to screen readers

// toggling example
$('.btn').on('click', function () {
  const $b = $(this)
  $b.attr('aria-pressed', $b.attr('aria-pressed') !== 'true')
})

wert (formularfelder)

.val() ist der universelle getter/setter für formularwerte — text inputs, textareas, selects und (bei radios/checkboxes) der wert des angekreuzten. .serialize() liefert einen URL-kodierten string; .serializeArray() ein {name, value}-array — zu einem plain objekt mit .serializeArray().reduce((o, p) => (o[p.name] = p.value, o), {}). um ein formular zurückzusetzen die native .reset()-methode am rohen DOM element aufrufen (jquery hat keine .reset()-methode).

jquery
// text input
$('input[type=text]').val()              // get current value
$('input[type=text]').val('new value')   // set

// textarea
$('textarea').val()

// select
$('select').val()                        // selected value
$('select').val('opt2')                  // set
$('select').val(['a', 'b'])              // multi-select set

// checkbox (use prop for state)
$('input[type=checkbox]').prop('checked')

// radio
$('input[type=radio][name=g]:checked').val()

// serialize whole form
$('form').serialize()                    // 'name=Alice&age=30'
$('form').serializeArray()               // [{name, value}]

// reset form
$('form')[0].reset()
12

maße & position

width & height methoden

width/height methoden geben zahlen (px) zurück, anders als .css('width'), das strings mit einheiten liefert. .width() = content box (CSS width). .innerWidth() = content + padding. .outerWidth() = content + padding + border. .outerWidth(true) inkl. margin. für window/document ist $(window).width() der viewport (sichtbare fläche); $(document).height() die gesamte seitenhöhe (kann beim scrollen größer als der viewport sein). setter nehmen zahlen (px) oder strings ('50%', '10em').

jquery
// content box (no padding, border, margin)
$('.box').width()       // 200 (number, px)
$('.box').width(300)    // set to 300px

// inner (content + padding)
$('.box').innerWidth()
$('.box').innerHeight()

// outer (content + padding + border)
$('.box').outerWidth()
$('.box').outerHeight()

// outer + margin
$('.box').outerWidth(true)
$('.box').outerHeight(true)

// window & document
$(window).width()       // viewport width
$(window).height()      // viewport height
$(document).height()    // document height (may exceed viewport)

position vs. offset

.offset() ist dokument-relativ (absolute koordinaten — nützlich für drag-drop, tooltips an der maus). .position() ist relativ zum offset parent (der nächste vorfahre mit position:relative/absolute/fixed) — nützlich zum umpositionieren innerhalb eines containers. .offsetParent() findet diesen vorfahren. .scrollTop()/.scrollLeft() lesen oder setzen die scroll position — $(window).scrollTop() ist der seitenscroll. der unterschied zwischen offset (dokument) und position (parent) ist entscheidend für korrekte positionierungs-mathematik.

jquery
// .offset(): relative to document (top-left of page)
const o = $('.box').offset()
console.log(o.left, o.top)         // e.g., 100, 200
$('.box').offset({ top: 0, left: 0 })  // move to top-left of page

// .position(): relative to offset parent
const p = $('.box').position()
console.log(p.left, p.top)         // position within parent

// .scrollTop() / .scrollLeft()
$(window).scrollTop()              // how far page is scrolled down
$(window).scrollTop(0)             // scroll to top
$('.container').scrollTop(100)     // scroll inner container

// .offsetParent(): nearest positioned ancestor
$('.box').offsetParent()           // the element .position() is relative to

responsive layout helfer

resize feuert beim ziehen häufig — mit setTimeout debouncen, um performance-probleme zu vermeiden. body klassen ergänzen (mobile/desktop) lässt CSS reagieren via body.mobile .nav { ... }. für modernen responsiven code CSS media queries fürs styling und window.matchMedia() im JS bevorzugen — performanter und an CSS breakpoints angeglichen. jquerys resize ansatz ist für legacy code okay, aber CSS + matchMedia ist der moderne standard.

jquery
// check viewport width on resize
$(window).on('resize', function () {
  const w = $(window).width()
  if (w < 768) {
    $('body').addClass('mobile').removeClass('desktop')
  } else {
    $('body').addClass('desktop').removeClass('mobile')
  }
}).resize()  // trigger once to initialize

// debounced resize (avoid firing hundreds of times)
let timer
$(window).on('resize', function () {
  clearTimeout(timer)
  timer = setTimeout(function () {
    console.log('resize settled')
  }, 200)
})

// match media (preferred for responsive checks)
if (window.matchMedia('(max-width: 768px)').matches) {
  // mobile
}

element-sichtbarkeit erkennen

:visible/:hidden prüfen display, visibility, opacity und maße — jquery 3+ behandelt visibility:hidden und opacity:0 als verborgen (ältere versionen als sichtbar). für die viewport-erkennung vergleicht der inViewport helper elementgrenzen mit der scroll position. moderner code nutzt dafür IntersectionObserver — deutlich effizienter (der browser rechnet, callbacks nur bei änderungen) und ohne scroll listener. der jquery ansatz funktioniert, feuert aber bei jedem scroll event.

jquery
// :visible / :hidden pseudo-classes
$('.box').is(':visible')   // boolean
$('.box:visible').doSomething()

// note: visibility:hidden is now :hidden in jQuery 3+
// (display:none, opacity:0, width:0/height:0 are also :hidden)

// is element in viewport?
function inViewport($el) {
  const elTop = $el.offset().top
  const elBottom = elTop + $el.outerHeight()
  const docTop = $(window).scrollTop()
  const docBottom = docTop + $(window).height()
  return elBottom >= docTop && elTop <= docBottom
}

// scroll-triggered reveal
$(window).on('scroll', function () {
  $('.reveal').each(function () {
    if (inViewport($(this))) {
      $(this).addClass('shown')
    }
  })
})

scroll position & animation

smooth scrolling: scrollTop an html und body animieren (browserübergreifend). bei fixen navs die header-höhe abziehen. infinite scroll: liegt scroll position + viewport höhe innerhalb von N pixeln an der dokumenthöhe, weiteren inhalt laden. parallax: elemente anhand der scroll position verschieben. scroll handler immer drosseln (sie feuern Dutzende male je sekunde) — mit _.throttle, einem timer-basierten debounce oder requestAnimationFrame. moderne alternativen: CSS scroll-behavior:smooth fürs scrollen, IntersectionObserver für trigger.

jquery
// current scroll position
const scrollTop = $(window).scrollTop()

// smooth scroll to top
$('html, body').animate({ scrollTop: 0 }, 500)

// smooth scroll to element
function scrollTo($el, duration) {
  const top = $el.offset().top - 20  // 20px offset for fixed header
  $('html, body').animate({ scrollTop: top }, duration || 500)
}
scrollTo($('#section2'))

// infinite scroll: load more when near bottom
$(window).on('scroll', function () {
  if ($(window).scrollTop() + $(window).height() >= $(document).height() - 100) {
    loadMore()
  }
})

// parallax (simple)
$(window).on('scroll', function () {
  const y = $(window).scrollTop()
  $('.hero').css('transform', 'translateY(' + (y * 0.5) + 'px)')
})
13

deferred & promises

ein deferred erzeugen

$.Deferred ist jquerys promise implementierung (vor dem nativen Promise). eines erzeugen, dann .resolve(value) oder .reject(reason) zum abschluss. .promise() gibt eine nur-lesende sicht zurück (konsumenten können nicht auflösen). die legacy api nutzt .done/.fail/.always statt .then/.catch. jquery 3+ deferreds sind thenable, also funktioniert await und Promise.resolve damit. für neuen code natives Promise bevorzugen — deferred ist vor allem für AJAX und legacy apis relevant.

jquery
// create a Deferred (jQuery's promise source)
const deferred = $.Deferred()

// resolve or reject it later
setTimeout(function () {
  if (Math.random() > 0.5) {
    deferred.resolve('success data')
  } else {
    deferred.reject(new Error('failed'))
  }
}, 1000)

// get the promise (read-only view)
const promise = deferred.promise()

// consume it
promise
  .done(function (data) { console.log('done:', data) })
  .fail(function (err) { console.log('fail:', err) })
  .always(function () { console.log('settled') })

when (parallel async)

$.when(deferreds...) wartet, bis mehrere deferreds/promises alle auflösen, und ruft dann .done mit arrays der ergebnisse auf. lehnt irgendeines ab, feuert .fail sofort. das parallel-async muster (wie Promise.all). der callback erhält je input deferred ein array (bei AJAX je [data, status, xhr]). für modernen code ist Promise.all + fetch sauberer und liefert aufgelöste werte direkt. $.when bleibt in jquery-lastigen codebasen nützlich.

jquery
// run multiple async ops in parallel, wait for all
$.when(
  $.get('/api/users'),
  $.get('/api/posts'),
  $.get('/api/comments')
).done(function (usersResp, postsResp, commentsResp) {
  // each arg is [data, status, xhr]
  const users = usersResp[0]
  const posts = postsResp[0]
  console.log('all loaded:', users, posts)
}).fail(function (err) {
  console.error('one failed:', err)
})

// modern equivalent
Promise.all([
  fetch('/api/users').then(r => r.json()),
  fetch('/api/posts').then(r => r.json())
]).then(([users, posts]) => {
  console.log('all loaded:', users, posts)
})

.then() verketten

jquery 3+ hat .then an die Promises/A+ spec angeglichen — es nimmt (onFulfilled, onRejected) und gibt ein neues promise zurück, genau wie natives Promise.then. async operationen lassen sich verketten und werte transformieren. ein promise aus .then zurückgegeben wird abgewartet; ein wert geht downstream. .catch ist in 3+ ebenfalls unterstützt. in jquery 1.x/2.x hatte .then nicht-standard verhalten — stattdessen .pipe. wenn möglich auf 3+ heben und .then/.catch für sauberen async code nutzen.

jquery
// jQuery 3+: .then follows Promises/A+ (like native then)
$.get('/api/users')
  .then(function (users) {
    // transform or chain another async
    return $.get('/api/users/' + users[0].id)
  })
  .then(function (userDetail) {
    console.log('detail:', userDetail)
    return userDetail.name  // pass value downstream
  })
  .then(function (name) {
    console.log('name:', name)
  })
  .catch(function (err) {
    console.error('any error in chain:', err)
  })

// in jQuery 1.x/2.x, .then had different semantics
// use .done/.pipe for old code; .then for new

AJAX promise interface

alle $.ajax aufrufe (und $.get/$.post) geben ein jqXHR objekt zurück, das promise-artig ist (.done/.fail/.always unterstützt) und (in jquery 3+) thenable (also await und Promise.resolve). mehrere .done callbacks können angehängt werden — alle feuern bei erfolg. .abort() bricht die anfrage ab (triggert .fail mit status 'abort'). für neuen code await $.ajax(...) oder mit Promise.resolve() wickeln, um sauber in native promise ketten und async/await zu integrieren.

jquery
// $.ajax returns a jqXHR (promise-like)
const req = $.ajax({ url: '/api/data', method: 'GET' })

// multiple callbacks on same request
req.done(function (data) { console.log('handler 1', data) })
req.done(function (data) { console.log('handler 2', data) })
req.fail(function (xhr, status, err) { console.error(err) })
req.always(function () { console.log('settled') })

// abort an in-flight request
req.abort()

// convert to native Promise (jQuery 3+)
Promise.resolve(req).then(function (data) {
  console.log('via native promise:', data)
})

// use with async/await (jQuery 3+)
async function getData() {
  try {
    const data = await $.ajax({ url: '/api/data' })
    console.log(data)
  } catch (err) {
    console.error(err)
  }
}

eigene promise pipeline

jede async operation in ein deferred wickeln, um ein promise zu bekommen: erzeugen, später resolve/reject, .promise() zurückgeben. jquery sammlungen exponieren ebenfalls .promise(), das auflöst, wenn alle eingereihten animationen der elemente fertig sind — nützlich, um code nach einer animations-batch auszulösen. das überbrückt jquerys animations queue mit promise-basiertem code, sodass sich animationen awaiten oder sauber mit AJAX oder anderer async arbeit verketten lassen.

jquery
// wrap a callback-based API in a promise
function delay(ms) {
  const d = $.Deferred()
  setTimeout(function () { d.resolve() }, ms)
  return d.promise()
}

// use it
delay(500).then(function () { console.log('500ms passed') })

// animate then continue
$('.box').fadeOut(300).promise().done(function () {
  console.log('fade done')
})

// queue of animations on multiple elements
$('.box').each(function (i) {
  $(this).delay(i * 100).fadeIn().promise()
})

// when animations on a set are done
$('.box').fadeOut().promise().done(function () {
  console.log('all boxes faded')
})
14

formulare

formular events

submit feuert beim absenden des formulars — für AJAX immer preventDefault. input feuert bei jedem tastendruck (text) oder wertwechsel — ideal für live validierung oder search-as-you-type. change feuert bei text inputs erst beim blur, bei checkboxes, radios und selects sofort. focus/blur feuern beim feldfokus. event delegation am formular nutzen für dynamisch ergänzte felder. der unterschied 'change' vs. 'input' zählt: 'input' ist live, 'change' wenn der nutzer die bearbeitung abschließt.

jquery
// submit event
$('form').on('submit', function (e) {
  e.preventDefault()  // stop page reload
  const data = $(this).serialize()
  $.post('/api/save', data)
})

// input event (fires on every keystroke/change)
$('input').on('input', function () {
  console.log('current value:', $(this).val())
})

// change event (fires on blur for text, immediately for checkbox/select)
$('select').on('change', function () {
  console.log('selected:', $(this).val())
})

// focus / blur
$('input').on('focus', function () { $(this).addClass('focused') })
$('input').on('blur', function () { $(this).removeClass('focused') })

// delegated (works for dynamically added fields)
$('form').on('input', '.field', function () { /* ... */ })

formulardaten serialisieren

.serialize() liefert einen URL-kodierten string, bereit für AJAX daten. .serializeArray() gibt ein {name, value}-array — mit reduce zu einem plain objekt wandeln. beide respektieren den aktuellen formularezustand (checkboxes nur, wenn angekreuzt; selects die gewählte option). bei checkboxes ist der wert per default 'on', außer value='something' ist gesetzt. deaktivierte felder werden ausgeschlossen. der standardweg, formulardaten für AJAX-einreichung ohne vollen reload zu sammeln.

jquery
<!-- form -->
<form id="f">
  <input name="name" value="Alice">
  <input name="email" value="[email protected]">
  <select name="role"><option value="admin" selected>Admin</option></select>
  <input type="checkbox" name="agree" checked>
</form>

<script>
// serialize: URL-encoded string
$('#f').serialize()
// 'name=Alice&email=a%40b.com&role=admin&agree=on'

// serializeArray: array of {name, value}
$('#f').serializeArray()
// [{ name: 'name', value: 'Alice' }, ...]

// convert to plain object
const obj = {}
$('#f').serializeArray().forEach(p => { obj[p.name] = p.value })
// { name: 'Alice', email: '[email protected]', role: 'admin', agree: 'on' }

// or one-liner reduce
const obj2 = $('#f').serializeArray().reduce((o, p) =>
  (o[p.name] = p.value, o), {})
</script>

formularvalidierung

manuelle validierung: pflichtfelder iterieren, .val() prüfen, eine 'invalid'-klasse fürs CSS styling togglen. email regex ist ein basaler plausibilitätscheck (die volle RFC 5322 regex wäre übertrieben). bei komplexen formularen das jquery validation plugin nutzen, das deklarative regeln liefert (class='required email') und einheitliche fehlermeldungen. immer clientseitig für die UX UND serverseitig für die sicherheit validieren — client validierung ist umgehbar. HTML5 attribute (required, type='email', pattern) sind die moderne basis.

jquery
// simple validation
function validate($form) {
  let valid = true
  $form.find('[data-required]').each(function () {
    const $f = $(this)
    if (!$f.val()) {
      $f.addClass('invalid')
      valid = false
    } else {
      $f.removeClass('invalid')
    }
  })
  $form.find('[type=email]').each(function () {
    if (!/^[^@]+@[^@]+\.[^@]+$/.test($(this).val())) {
      $(this).addClass('invalid')
      valid = false
    }
  })
  return valid
}

$('form').on('submit', function (e) {
  e.preventDefault()
  if (validate($(this))) {
    $.post('/api/save', $(this).serialize())
  }
})

dynamische formularfelder

formularfelder dynamisch ergänzen/entfernen, indem elemente mit $() erzeugt und angehängt werden. array-artige namen nutzen (tags[]), damit der server ein array erhält. event delegation (on('click', '.remove', ...)) behandelt klicks auf dynamisch ergänzte remove buttons. bei umsortierbaren feldern (mit auf/ab buttons oder drag-drop) die namen nach jeder änderung neu nummerieren, damit der server eine saubere sequenz sieht. dieses muster ist bei tag inputs, dynamischen positionen und konfigurationsformularen üblich.

jquery
// add a new field
$('.add-field').on('click', function () {
  const $field = $('<input>', {
    type: 'text',
    name: 'tags[]',
    class: 'tag-input',
    placeholder: 'Tag'
  })
  $('#fields').append($field)
})

// remove a field
$('#fields').on('click', '.remove', function () {
  $(this).closest('.field-row').remove()
})

// array field names (tags[]) — server receives an array
// PHP/Rails auto-parse 'name[]' into arrays

// re-number fields after add/remove
function renumber() {
  $('#fields .field').each(function (i) {
    $(this).find('input').attr('name', 'item_' + i)
  })
}

AJAX formular-einreichung

ein wiederverwendbarer AJAX formular handler: das formular serialisieren, an seine action URL POSTen, erfolg/fehler behandeln. den submit button während der anfrage deaktivieren, um doppelte einreichungen zu verhindern. eigene events triggern (ajax:success, ajax:error), damit anderer code reagieren kann. bei erfolg das formular zurücksetzen. serverseitige validierungsfehler zeigen, indem feldnamen auf fehlermeldungen gemappt werden. dieses muster macht jedes formular per class='ajax' zu einem AJAX formular — ein verbreiteter progressive enhancement.

jquery
// generic AJAX form submission
$('form.ajax').on('submit', function (e) {
  e.preventDefault()
  const $form = $(this)
  const data = $form.serialize()
  const url = $form.attr('action') || window.location.href
  const method = $form.attr('method') || 'POST'

  // show loading state
  $form.find('button').prop('disabled', true).addClass('loading')

  $.ajax({
    url: url,
    method: method,
    data: data,
    dataType: 'json'
  })
  .done(function (resp) {
    $form.trigger('ajax:success', [resp])
    $form[0].reset()
  })
  .fail(function (xhr) {
    $form.trigger('ajax:error', [xhr])
    const errors = xhr.responseJSON?.errors
    if (errors) showErrors($form, errors)
  })
  .always(function () {
    $form.find('button').prop('disabled', false).removeClass('loading')
  })
})
15

iteration & loops

$.each vs. .each()

$.each ist ein generisches utility, das arrays (index, value) oder plain objekte (key, value) iteriert. .each() ist eine methode an jquery sammlungen — 'this' ist das rohe DOM element. beide akzeptieren return false zum abbrechen und alles andere zum weiterlaufen. die argumentreihenfolge ist (index, value) — umgekehrt zu Array.forEachs (value, index). für modernen code sind natives forEach/map/for...of bevorzugt; .each() bleibt nützlich bei jquery sammlungen, wenn das element als 'this' gebraucht wird.

jquery
// $.each: generic iterator (arrays AND objects)
$.each([10, 20, 30], function (index, value) {
  console.log(index, value)  // 0 10, 1 20, 2 30
})

$.each({ a: 1, b: 2 }, function (key, value) {
  console.log(key, value)  // 'a' 1, 'b' 2
})

// .each(): method on jQuery collections only
$('li').each(function (index, element) {
  // 'this' is the DOM element (= element)
  // wrap with $(this) for jQuery methods
  $(this).text(index + ': ' + $(this).text())
})

// breaking out
$('li').each(function (i) {
  if (i === 3) return false  // stop iteration
  // return true (or nothing) to continue
})

$.map vs. .map()

$.map transformiert ein array/objekt in ein neues array (null zurückgeben überspringt, ein array zurückgeben glättet). die argumentreihenfolge ist (value, index) — umgekehrt zu $.each. .map() an jquery sammlungen gibt eine neue jquery sammlung zurück (.get() aufrufen, um zu einem plain array zu wandeln). null/undefined aus .map() schließt das item aus. diese datieren vor natives Array.map; moderner code nutzt natives map, aber jquerys .map() bleibt praktisch, um werte aus DOM sammlungen zu extrahieren.

jquery
// $.map: transform an array or object
const doubled = $.map([1, 2, 3], function (value, index) {
  return value * 2  // [2, 4, 6]
})

// returning null/undefined removes the item
const evens = $.map([1, 2, 3, 4], function (v) {
  return v % 2 === 0 ? v : null  // [2, 4]
})

// returning an array flattens it
const flat = $.map([1, 2], function (v) {
  return [v, v * 10]  // [1, 10, 2, 20]
})

// .map() on jQuery collections
const ids = $('li').map(function (index, el) {
  return $(el).data('id')  // jQuery collection of ids
}).get()  // .get() converts to plain array [1, 2, 3]

loops mit for/while

für rohe performance bei großen sammlungen einen klassischen for loop mit $items[i] (rohes DOM element) statt $items.eq(i) (jquery-umwickelt) nutzen — vermeidet ein neues jquery objekt je iteration. die .length eigenschaft wirkt direkt. for...of funktioniert an jquery sammlungen (sie sind iterable). trotzdem .each() für lesbarkeit bevorzugen, solange kein gemessenes performance problem vorliegt — der unterschied fällt erst bei tausenden elementen auf.

jquery
// classic for loop with .eq(i)
const $items = $('li')
for (let i = 0; i < $items.length; i++) {
  const $item = $items.eq(i)
  $item.text('Item ' + i)
}

// or use the raw DOM elements (faster, no jQuery wrapping)
for (let i = 0; i < $items.length; i++) {
  $items[i].textContent = 'Item ' + i  // raw DOM
}

// while loop
let i = 0
while (i < $items.length) {
  $($items[i]).addClass('item-' + i)
  i++
}

// for...of (modern, on the collection)
for (const el of $items) {
  $(el).addClass('processed')
}

filtern während der iteration

vor dem iterieren filtern für saubereren code — $('li').filter('.active').each(...) ist idiomatischer als bedingungen innerhalb von .each(). um eine teilmenge zu sammeln, passende rohe DOM elemente in ein array pushen und am ende mit $() umwickeln. zum wert-extrahieren ist .map().get() das sauberste muster. jquery sammlungen in loops aufbauen vermeiden (jeder $()-aufruf kostet) — rohe elemente sammeln, einmal umwickeln.

jquery
// filter then iterate
$('li').filter('.active').each(function () {
  $(this).addClass('highlighted')
})

// iterate with conditional logic
$('li').each(function (i) {
  if (i % 2 === 0) {
    $(this).addClass('even')
  } else {
    $(this).addClass('odd')
  }
})

// collect matching items
const active = []
$('li').each(function () {
  if ($(this).hasClass('active')) {
    active.push(this)  // push raw DOM element
  }
})
const $active = $(active)  // wrap in jQuery

// or use .map().get()
const ids = $('li.active').map(function () {
  return $(this).data('id')
}).get()

verschachtelung & komplexe iteration

verschachtelte .each() behandelt gitter/matrices. beim DOM-aufbau aus daten an ein document fragment anhängen und einmal einfügen (deutlich schneller als je item anhängen — jedes append triggert reflow). $(document.createDocumentFragment()) erzeugt ein jquery-umwickeltes fragment. bei sehr großen listen string verkettung + .html() (am schnellsten) oder eine templating bibliothek erwägen. moderne frameworks (vue/react) handhaben das deklarativ, aber das fragment muster bleibt eine nützliche jquery optimierung.

jquery
// nested iteration over rows and cells
$('table tr').each(function (rowIdx, row) {
  $(row).find('td').each(function (colIdx, cell) {
    $(cell).text('R' + rowIdx + 'C' + colIdx)
  })
})

// iterate over a JSON response and build DOM
$.get('/api/users').done(function (users) {
  const $list = $('#users')
  $.each(users, function (i, user) {
    $list.append(
      $('<li>').text(user.name).data('id', user.id)
    )
  })
})

// build with a document fragment (faster)
const $frag = $(document.createDocumentFragment())
$.each(users, function (i, user) {
  $frag.append('<li>' + user.name + '</li>')
})
$('#users').append($frag)  // one DOM update
16

daten-speicher & caching

$.data vs. .data()

$.data(el, key, val) ist die low-level funktion an einem rohen DOM element; .data() die bequeme methode an jquery sammlungen. beide speichern werte in einem internen cache (nicht im DOM), also schneller als attribut-zugriff. .data() liest zudem automatisch data-* attribute mit typkonvertierung (zahlen, booleans, JSON). .data(key, val) aktualisiert das data-* attribut NICHT — dafür .attr('data-key', val). zum leeren $.removeData(el, key) oder .removeData(key).

jquery
// $.data: low-level, on raw DOM element
const el = document.getElementById('box')
$.data(el, 'count', 1)
$.data(el, 'count')       // 1
$.data(el, 'count', 2)
$.data(el, 'count')       // 2
$.removeData(el, 'count')

// .data(): method on jQuery collection (more common)
$('.box').data('count', 1)
$('.box').data('count')   // 1
$('.box').removeData('count')

// auto-reads data-* attributes (with type conversion)
// <div data-id="42" data-active="true"></div>
$('.box').data('id')      // 42 (number)
$('.box').data('active')  // true (boolean)

zustand je element speichern

zustand je element ist das killer-feature von .data() — config, zähler, flags oder objekte je element speichern, ohne das DOM zu verschmutzen. .data() ohne argumente gibt alle gespeicherten daten als objekt zurück. ein gespeichertes objekt zu mutieren mutiert die gespeicherte referenz (kein erneutes setzen nötig). der interne cache wird automatisch aufgeräumt, wenn elemente via .remove() entfernt werden — aber nicht bei roher DOM entfernung (parentNode.removeChild).

jquery
// store per-element state on plugin init
$('.counter').each(function () {
  $(this).data('count', 0)
})

// increment on click
$('.counter').on('click', function () {
  const $el = $(this)
  const c = $el.data('count') + 1
  $el.data('count', c)
  $el.text('Count: ' + c)
})

// retrieve all data
const all = $('.counter').data()  // { count: 5, ... }

// store objects
$('.box').data('config', { color: 'red', size: 10 })
$('.box').data('config').color = 'blue'  // mutates the stored object
$('.box').data('config').color  // 'blue'

auswahlen cachen

jquery auswahlen zu cachen vermeidet erneutes DOM abfragen — ein deutlicher performance gewinn in loops oder häufigen handlern. konvention: gecachte jquery objekte mit $ präfixieren ($boxes, $nav), um sie von rohen DOM elementen zu unterscheiden. vorsicht: gecachte auswahlen werden veraltet, wenn sich das DOM ändert (passende elemente kommen/gehen). nach dynamischem inhaltseinfügen neu abfragen. bei event handlern außerhalb des handlers cachen (im selben scope), um je event nicht neu abzufragen.

jquery
// BAD: re-querying the DOM on every use
function update() {
  $('.box').text('updated')     // queries every call
  $('.box').addClass('done')    // queries again
}

// GOOD: cache the selection
const $boxes = $('.box')        // query once
function update() {
  $boxes.text('updated')
  $boxes.addClass('done')
}

// re-query when content changes
$('#container').load('/partial', function () {
  // $boxes is stale — re-query
  const $newBoxes = $('.box')
})

// convention: prefix cached jQuery objects with $
const $nav = $('#nav')
const $items = $('.item')

HTML5 data-* attribute

data-* attribute erlauben es, config deklarativ in HTML einzubetten — perfekt für progressive enhancement (der server rendert config, JS liest sie). .data() liest mit typkonvertierung (zahlen, booleans, JSON objekte); .attr() liest den rohen string. mehrwortige namen nutzen kebab-case im HTML (data-foo-bar) und camelCase im JS (.data('fooBar')). für JSON werte im HTML einfache anführungszeichen um das JSON nutzen (das doppelte verwendet). data-* via .attr() zu aktualisieren persistiert im DOM; .data() schreibt nur in den cache.

jquery
<!-- declarative config in HTML -->
<div class="widget"
     data-id="42"
     data-mode="advanced"
     data-config='{"timeout":5000,"retries":3}'
     data-enabled="true">
  Widget
</div>

<script>
// .data() reads with type conversion
const $w = $('.widget')
$w.data('id')        // 42 (number)
$w.data('mode')      // 'advanced'
$w.data('config')    // { timeout: 5000, retries: 3 } (parsed JSON)
$w.data('enabled')   // true (boolean)

// .attr() reads raw strings
$w.attr('data-id')   // '42' (string)
$w.attr('data-config') // '{"timeout":5000,...}' (string)

// camelCase mapping: data-foo-bar -> .data('fooBar')
$('[data-foo-bar]').data('fooBar')
</script>

speicher & aufräumen

.remove() nutzen, um elemente zu löschen — es räumt zugehörige daten und events automatisch auf. .detach() entfernt aus dem DOM, erhält aber daten/events (für wieder-einfügen). .empty() entfernt kinder UND räumt deren daten/events auf. NIEMALS .html('') zum leeren der kinder nutzen — es räumt deren daten/events nicht auf und verursacht speicherlecks. plugins sollten eine destroy methode exponieren, die events entbindet und daten entfernt. jquerys automatisches aufräumen ist ein Hauptgrund, .remove() statt roher DOM entfernung zu nutzen.

jquery
// .remove() cleans up data and events
$('.box').remove()  // safe — data and events gone

// .detach() preserves data and events for re-insertion
const $box = $('.box').detach()
$('#elsewhere').append($box)  // events still fire

// .empty() removes children AND their data/events
$('.container').empty()  // children's data/events cleaned

// .html('') does NOT clean up children's data/events (leak!)
// use .empty() instead

// manual cleanup before removal
$('.box').off().removeData().remove()

// custom cleanup in a plugin
$.fn.myPlugin = function () {
  this.on('click.myplugin', handler)
  this.data('myplugin', { /* state */ })

  // expose destroy for manual cleanup
  // ... or use .on('remove') event (non-standard)
17

eigene animationen

.animate() grundlagen

.animate() tweened numerische CSS eigenschaften über eine dauer. relative werte ('+=50', '-=20') für schrittweise änderungen. eigenschaftsnamen in camelCase (marginLeft, nicht margin-left). die sonderwerte 'toggle', 'show', 'hide' wirken wie ihre methoden-pendants. zahlen defaulten auf pixel. farben brauchen das jquery color plugin — core jquery animiert nur zahlen. der callback feuert einmal nach ende der animation (je element, bei sammlungen also ggf. mehrfach).

jquery
// animate numeric CSS properties
$('.box').animate({
  width: '500px',
  height: 200,         // number = px
  opacity: 0.5,
  marginLeft: '+=50',  // relative
  fontSize: '20px'     // camelCase for hyphenated props
}, 1000)  // duration in ms

// with callback
$('.box').animate({ left: 300 }, 1000, function () {
  console.log('done')
})

// 'slow' = 600, 'fast' = 200
$('.box').animate({ height: 'toggle' }, 'slow')

// special values: 'toggle', 'show', 'hide'
$('.box').animate({ width: 'toggle' })

easing & optionen

easing steuert die geschwindigkeitskurve: 'swing' (default, langsamer start/ende, schnelle mitte) und 'linear' (gleichmäßig). jquery UI oder das easing plugin ergänzen 30+ weitere (easeInOutCubic, easeOutBounce). die options-form gibt feine kontrolle: step wird je animationsframe aufgerufen (praktisch zum synchronisieren anderer elemente), queue:false läuft parallel (default true reiht sequenziell), specialEasing setzt easing je eigenschaft. step erhält (now, fx), wobei fx fx.prop (eigenschaftsname) und fx.start/fx.end hält.

jquery
// easing: 'swing' (default, ease-out) or 'linear'
$('.box').animate({ left: 300 }, 1000, 'linear')

// options object form
$('.box').animate({ left: 300 }, {
  duration: 1000,
  easing: 'swing',
  complete: function () { console.log('done') },
  step: function (now, fx) {
    console.log(fx.prop, now)  // called each frame
  },
  queue: true,         // default true (sequential)
  specialEasing: {
    width: 'linear',   // per-property easing
    height: 'swing'
  }
})

// jQuery UI adds more easings: easeInOutCubic, etc.
// or include jquery.easing plugin

animations queue

jedes element hat eine 'fx' queue — animationen am selben element laufen per default sequenziell. queue:false für parallelität. .delay(ms) fügt eine pause ein. .queue(fn) fügt eine eigene funktion in die queue ein — next() (oder dequeue()) aufrufen zum weiterlaufen. so lassen sich animationen mit beliebigem code (AJAX, callbacks) in einer sequenz mischen. .clearQueue() leert die queue ohne die laufende animation zu berühren. .dequeue() springt zum nächsten eingereihten item.

jquery
// animations queue per element (default)
$('.box')
  .animate({ width: 500 }, 500)  // runs first
  .animate({ height: 300 }, 500) // runs after
  .animate({ opacity: 0.5 }, 500) // runs after that

// total: 1500ms (sequential)

// run in parallel: queue: false
$('.box').animate({ width: 500 }, { duration: 500, queue: false })
$('.box').animate({ height: 300 }, { duration: 500, queue: false })
// both run simultaneously

// .delay(): pause in the queue
$('.box')
  .animate({ width: 500 }, 500)
  .delay(300)              // wait 300ms
  .animate({ height: 300 }, 500)

// .queue(): insert custom function into the queue
$('.box').animate({ width: 500 }, 500).queue(function (next) {
  console.log('between animations')
  next()  // must call to continue
})

farb-animationen

core jquery kann farben nicht animieren (sie sind nicht-numerisch). das jquery color plugin (klein, eigenständig) oder jquery UI ergänzen farb-animationen — backgroundColor, color, borderColor usw. jquery UI ermöglicht zudem klassen-basierte animationen: .addClass('foo', 500) transitioniert über 500ms zu den stilen der neuen klasse. für moderne seiten CSS transitions bevorzugen (transition: background 0.3s) — hardware-beschleunigt und ohne JS. jquery farb-animationen nur für legacy support.

jquery
<!-- jQuery core does NOT animate colors -->
<!-- include jQuery Color plugin or jQuery UI -->
<script src="https://code.jquery.com/color/jquery.color-2.2.0.min.js"></script>

<script>
// now color animations work
$('.box').animate({
  backgroundColor: '#ff0000',
  color: '#ffffff',
  borderColor: '#000000'
}, 1000)

// jQuery UI also enables:
// - class animations: .toggleClass('active', 500)
// - more easing functions
// - color transitions on hover
$('.box').hover(function () {
  $(this).animate({ backgroundColor: '#eee' }, 300)
}, function () {
  $(this).animate({ backgroundColor: '#fff' }, 300)
})
</script>

stoppen & leeren

.stop() hält die laufende animation an. mit (clearQueue=true) leert es zusätzlich die queue. mit (jumpToEnd=true) springt die laufende animation an ihr ende. .finish() springt alle eingereihten animationen sofort an ihre endzustände. der :animated selektor matcht elemente mitten in der animation. hover-getriebene animationen immer mit .stop(true) paaren, um aufbau bei schnellem hinein-/herausbewegen zu verhindern — sonst reihen sich animationen auf und spielen lange nach dem verlassen weiter, mit ruckeligem verhalten.

jquery
// .stop([clearQueue], [jumpToEnd])
$('.box').stop()              // stop current, stay at current state
$('.box').stop(true)          // also clear the queue
$('.box').stop(true, true)    // clear queue AND jump current to end
$('.box').stop(false, true)   // jump current to end, keep queue

// .finish(): jump ALL queued animations to end state
$('.box').finish()

// prevent hover animation buildup
$('.box').hover(function () {
  $(this).stop(true).animate({ width: 300 }, 200)
}, function () {
  $(this).stop(true).animate({ width: 100 }, 200)
})

// check if currently animating
if (!$(':animated').length) { /* nothing animating */ }
if ($('.box').is(':animated')) { /* still animating */ }
18

event delegation

warum delegation?

event delegation bindet einen handler an ein parent; klicks auf kinder bubbeln hoch und triggern ihn. vorteile: (1) ein handler statt N (speicher), (2) funktioniert automatisch für dynamisch ergänzte elemente, (3) schnelleres setup (eine bindung statt N). das zweite argument an .on() ('li') ist der selektor-filter — 'this' im handler ist das passende kind, nicht das parent. delegation für jede liste, tabelle oder jeden container nutzen, wo kinder dasselbe verhalten teilen. der einzige preis: geringer overhead je event (selektor-check), vernachlässigbar.

jquery
// ANTI-PATTERN: bind to each <li> directly
$('li').on('click', function () {
  $(this).toggleClass('done')
})
// - 1 handler PER <li> (100 items = 100 handlers)
// - NEW <li> added later DON'T get the handler
// - high memory, slow setup

// PATTERN: delegate to parent
$('ul').on('click', 'li', function (e) {
  $(this).toggleClass('done')
})
// - 1 handler total
// - works for future <li>
// - low memory, fast setup
// - 'this' is the <li> (not the <ul>)

delegation in der praxis

dieses todo-listen muster zeigt die stärke von delegation: zwei delegierte handler an #tasks behandeln delete buttons und das togglen von items für alle aktuellen und zukünftigen items. ein neues <li> ergänzen erfordert keine neue bindung. e.stopPropagation() am delete button verhindert, dass auch der li klick feuert (der beim löschen .done togglen würde). .closest('li') findet das umschließende <li> vom geklickten button. dieses muster ist die grundlage von jquery SPAs vor den frameworks — und bleibt nützlich für widget-artige UI.

jquery
<!-- dynamic list -->
<ul id="tasks">
  <li>Task 1 <button class="delete">×</button></li>
</ul>

<script>
// ONE delegated handler handles all current AND future items
$('#tasks').on('click', '.delete', function (e) {
  e.stopPropagation()
  $(this).closest('li').remove()
})

$('#tasks').on('click', 'li', function () {
  $(this).toggleClass('done')
})

// adding new items works without re-binding
$('.add').on('click', function () {
  $('#tasks').append('<li>New task <button class="delete">×</button></li>')
})
</script>

delegiert vs. direkt gebunden

direkte bindung hängt den handler an die passenden elemente; delegierte bindung hängt an ein parent und filtert per selektor. der kernunterschied im handler: bei direkt ist e.currentTarget === this === das element. bei delegiert ist e.currentTarget das parent (wo der handler hängt), this das passende kind (der selektor-treffer), und e.target das tatsächlich geklickte element (evtl. ein nachfahre des kindes). e.delegateTarget für den zugriff aufs parent in delegierten handlern.

jquery
// DIRECT: bind directly to element
// - element must exist at bind time
// - handler attached to element itself
// - e.target === e.currentTarget === this
$('.btn').on('click', function (e) {
  console.log(e.currentTarget === this)  // true
})

// DELEGATED: bind to parent, filter by selector
// - works for future children
// - handler attached to parent
// - e.currentTarget = parent (the bound element)
// - this = child (matched selector)
// - e.target = actual clicked element (may be deeper child)
$('ul').on('click', 'li', function (e) {
  console.log(e.currentTarget)  // the <ul>
  console.log(this)              // the <li>
  console.log(e.target)          // clicked element (maybe <span> in li)
})

delegierte handler entbinden

namespacing (click.task) ist der sauberste weg, konkrete handler zu entbinden, ohne andere zu berühren. .off('click', 'li') entfernt delegierte handler, die zu diesem selektor passen. .off('click') entfernt alle click handler (direkte und delegierte). .off() entfernt alles — vorsichtig. um einen konkreten handler zu entfernen die original-funktionsreferenz übergeben. plugins sollten events immer namespacen (click.myplugin), damit nutzer sauber entbinden können, ohne die internen kennenzulernen.

jquery
// delegate with namespace
$('ul').on('click.task', 'li', handler)

// remove just this delegated handler (by namespace)
$('ul').off('click.task')

// remove all delegated click handlers
$('ul').off('click')

// remove all delegated handlers with a specific selector
$('ul').off('click', 'li')

// remove ALL handlers (including delegated)
$('ul').off()

// remove with reference to the original handler
function handler() { /* ... */ }
$('ul').on('click', 'li', handler)
$('ul').off('click', 'li', handler)  // exact match

delegation fallstricke

delegation an den nächsten stabilen vorfahren scopen — nicht alles an document/body delegieren (jedes event bubbelt hoch und wird gegen den selektor geprüft, das ist langsam). zu breite selektoren ('div') vermeiden. vorsichtig mit stopPropagation in kindern: es verhindert, dass delegierte handler an vorfahren feuern. stoppt ein kind die propagation, läuft der delegierte handler des parents nie. die abwägung: delegation ist flexibel, kostet aber geringen overhead je event (selektor-matching) — meist vernachlässigbar, auf riesigen seiten relevant.

jquery
// PITFALL 1: delegated handler on a parent that's too high
$(document).on('click', '.btn', handler)
// works, but EVERY click bubbles to document and is checked
// (slow on large pages — scope to nearest stable parent)

// BETTER: scope to the nearest container that won't be replaced
$('#sidebar').on('click', '.btn', handler)

// PITFALL 2: selector that matches too broadly
$('body').on('click', 'div', handler)  // fires on every div click

// PITFALL 3: stopping propagation in a child breaks delegation
$('.btn').on('click', function (e) {
  e.stopPropagation()  // parent's delegated handler won't fire!
})

// PITFALL 4: delegated handlers don't fire if a parent
// stops propagation before reaching the delegate target
19

best practices

performance tipps

kern-performance-tipps: (1) auswahlen cachen; (2) abfragen an einen container scopen mit .find(); (3) #id selektoren bevorzugen (nutzt intern getElementById); (4) * vermeiden; (5) events delegieren; (6) DOM updates über fragmente bündeln — jedes append triggert reflow, also ein fragment bauen und einmal anhängen; (7) vor schwerer manipulation detachen (operationen an detached elementen triggern kein reflow). bei listen mit 1000+ items ist string verkettung + .html() am schnellsten, aber fragmente sind sauberer.

jquery
// 1. cache selections
const $items = $('.items')  // query once

// 2. scope queries to a container
$('.item', $container)      // search within container
$container.find('.item')    // equivalent, slightly faster

// 3. use ID selectors when possible (fastest)
$('#header')                // getElementById

// 4. avoid universal selector
$('*').doSomething()        // SLOW

// 5. delegate events instead of binding many
$('ul').on('click', 'li', fn)  // 1 handler

// 6. batch DOM updates (use document fragment)
const $frag = $(document.createDocumentFragment())
for (let i = 0; i < 1000; i++) {
  $frag.append('<li>Item ' + i + '</li>')
}
$('ul').append($frag)  // one reflow, not 1000

// 7. detach before heavy manipulation
const $list = $('ul').detach()
// ... modify $list ...
$('#container').append($list)

DOM einfügen performance

DOM einfügen ist der größte performance flaschenhals. jedes .append() triggert reflow (der browser berechnet das layout neu). für bulk inserts: (1) einen HTML string bauen und mit .html() setzen (am schnellsten bei einfachem inhalt); (2) ein document fragment nutzen und einmal anhängen (sauberer bei komplexen elementen); (3) den container detachen, verändern, wieder anhängen (vermeidet reflow am live DOM während der bearbeitung). bei 1000+ items ist der string ansatz deutlich schneller als je-item .append().

jquery
// SLOW: appending in a loop (reflow per iteration)
for (let i = 0; i < 1000; i++) {
  $('ul').append('<li>Item ' + i + '</li>')
}

// FASTER: build string, append once
let html = ''
for (let i = 0; i < 1000; i++) {
  html += '<li>Item ' + i + '</li>'
}
$('ul').html(html)

// FASTEST: detached node + fragment
const $list = $('ul').detach()
const $frag = $(document.createDocumentFragment())
for (let i = 0; i < 1000; i++) {
  $frag.append($('<li>').text('Item ' + i))
}
$list.append($frag).appendTo('#container')

// even faster: array.join
const html = new Array(1000).fill(0).map((_, i) =>
  '<li>Item ' + i + '</li>'
).join('')
$('ul').html(html)

moderne jquery muster

moderne jquery (3.x) muster: .on()/.off() nutzen (legacy methoden wie .bind/.live/.delegate sind entfernt oder deprecated). das promise interface (.done/.fail) statt success/error callbacks. code in IIFEs oder ES module scopen — globals nicht verschmutzen. $(document).ready weglassen, wenn das skript am ende von body steht. CSS transitions/animationen statt .animate() bevorzugen (hardware-beschleunigt, geschmeidiger). 'use strict' nutzen. bei neuen projekten prüfen, ob ein framework (vue/react) besser passt als jquery.

jquery
// use .on() / .off() (not bind/unbind, live, delegate)
$('.btn').on('click', fn)

// use promises (.done/.fail) instead of success/error
$.get('/api').done(fn).fail(errFn)

// use IIFE or modules to scope code
(function ($) {
  'use strict'
  // private code
  $('.btn').on('click', fn)
}(jQuery))

// or ES modules
import $ from 'jquery'
$('.btn').on('click', fn)

// don't pollute global scope
// don't use $(document).ready if script is at end of body

// prefer CSS for animations (hardware-accelerated)
// .css({ transition: 'all 0.3s', transform: 'translateX(100px)' })

barrierefreiheit

barrierefreiheit essentials: ARIA rollen und zustände ergänzen (role='dialog', aria-modal, aria-expanded, aria-labelledby). eigene widgets tastaturzugänglich machen — enter/leertaste für buttons, pfeiltasten für menüs, esc zum schließen von modals behandeln. fokus verwalten: bei geöffnetem modal den fokus hineinbewegen, beim schließen zum auslöser zurück. semantische elemente (<button>, <a>, <nav>) statt divs mit onclick nutzen. sichtbarkeit: verbergen lieber über CSS klassen (die screenreader evtl. ignorieren) als display:none (das sie immer ignorieren).

jquery
// add ARIA attributes for screen readers
$('.modal').attr({
  role: 'dialog',
  'aria-modal': true,
  'aria-labelledby': 'modal-title'
})

// toggle aria-expanded for collapsibles
$('.accordion .header').on('click', function () {
  const $h = $(this)
  const expanded = $h.attr('aria-expanded') !== 'true'
  $h.attr('aria-expanded', expanded)
  $h.next('.content').slideToggle()
})

// keyboard navigation
$('.menu-item').on('keydown', function (e) {
  if (e.which === 13 || e.which === 32) {  // Enter or Space
    $(this).trigger('click')
  }
})

// focus management for modals
$('.modal').on('shown', function () {
  $(this).find('input:first').focus()
})

// use button elements for actions (not <div onclick>)
$('<button>').text('Save').on('click', save).appendTo('body')

sicherheit: XSS & HTML injection

untrustete strings niemals via .html() injizieren — sie führen eingebettete <script> tags und event handler aus (XSS). .text() für plain text nutzen (escapet automatisch). muss HTML rein, vorher bereinigen (manuelles escapen oder eine bibliothek wie DOMPurify). das sicherste muster: elemente mit $() bauen und .text() für dynamischen inhalt nutzen — $('<li>').text(userInput) escapet automatisch. besonders vorsichtig mit .append('<div>' + data + '</div>') mustern — XSS vektoren, wenn data nutzerkontrolliert ist.

jquery
// DANGEROUS: injecting untrusted HTML
const userInput = '<script>alert("xss")</script>'
$('.box').html(userInput)        // EXECUTES the script!

// SAFE: escape with .text()
$('.box').text(userInput)        // displays as text, no execution

// SAFE: sanitize before injecting
function escapeHtml(str) {
  return str
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#39;')
}
$('.box').html(escapeHtml(userInput))

// SAFE: build elements with .text() for content
const $li = $('<li>').text(userInput)  // text is auto-escaped
$('ul').append($li)

// AVOID .html() with user input. Use .text() or DOMPurify.
// $('div').html('<p>' + data + '</p>')  // BAD if data is user input
20

häufige muster

modal dialog

ein modal muster: overlay + modal erzeugen, an den body anhängen (entkommt parent stacking contexts), einblenden. klick auf das overlay (nicht das modal) schließt — mit e.target === this erkennen. die esc-taste schließt. beim schließen immer aufräumen (DOM entfernen, handler entbinden). für produktion eine bibliothek erwägen (magnific popup, bootstrap modal), die barrierefreiheit (fokus-einfang, ARIA, fokus zurück zum auslöser), animationen und iframe/ajax modals behandelt. das muster oben ist die minimale handgeschriebene version.

jquery
// simple modal pattern
function openModal(html) {
  const $overlay = $('<div class="modal-overlay"></div>')
  const $modal = $('<div class="modal"></div>').html(html)
  $overlay.append($modal).appendTo('body').hide().fadeIn(200)

  $overlay.on('click', function (e) {
    if (e.target === this) closeModal()  // click outside to close
  })

  $(document).on('keydown.modal', function (e) {
    if (e.which === 27) closeModal()  // Esc to close
  })
}

function closeModal() {
  $('.modal-overlay').fadeOut(200, function () { $(this).remove() })
  $(document).off('keydown.modal')
}

// usage
$('.open').on('click', function () {
  openModal('<p>Hello from modal!</p>')
})

tabs

das klassische tab muster: ein klick auf einen tab link aktiviert diesen tab. der href des links (#tab1) mappt auf die id des inhalts. die active klasse an link und inhalt steuert die sichtbarkeit (CSS: .tab-content:not(.active) { display: none }). der handler nutzt event delegation (behandelt dynamisch ergänzte tabs). preventDefault verhindert die hash-änderung der URL (oder preventDefault weglassen, um hash-basiertes deep-linking zu tabs zu ermöglichen). für barrierefreiheit role='tab', aria-selected und pfeiltasten-navigation ergänzen.

jquery
<!-- HTML -->
<div class="tabs">
  <ul class="tab-nav">
    <li><a href="#tab1" class="active">Tab 1</a></li>
    <li><a href="#tab2">Tab 2</a></li>
    <li><a href="#tab3">Tab 3</a></li>
  </ul>
  <div id="tab1" class="tab-content active">Content 1</div>
  <div id="tab2" class="tab-content">Content 2</div>
  <div id="tab3" class="tab-content">Content 3</div>
</div>

<script>
$('.tab-nav').on('click', 'a', function (e) {
  e.preventDefault()
  const $a = $(this)
  $a.addClass('active').parent().siblings().find('a').removeClass('active')
  $($a.attr('href')).addClass('active').siblings().removeClass('active')
})
</script>

accordion

accordion muster: ein klick auf eine header togglest ihren inhalt. die single-open variante schließt andere, wenn eines öffnet (den .not($h)-block für multi-open entfernen). aria-expanded nutzen, um den zustand für screenreader zu exponieren — CSS kann danach stylen (.acc-header[aria-expanded="true"] { ... }). slideToggle animiert den inhalt. <button> für headers (per default tastaturzugänglich). bei vielen items event delegation am parent nutzen, statt jeden header einzeln zu binden.

jquery
<!-- HTML -->
<div class="accordion">
  <div class="acc-item">
    <button class="acc-header" aria-expanded="false">Section 1</button>
    <div class="acc-content">Content 1</div>
  </div>
  <!-- more items -->
</div>

<script>
$('.accordion').on('click', '.acc-header', function () {
  const $h = $(this)
  const $c = $h.next('.acc-content')

  // close others (single-open accordion)
  $h.closest('.accordion')
    .find('.acc-header').not($h)
      .attr('aria-expanded', false)
      .next('.acc-content').slideUp()

  // toggle this one
  const isOpen = $h.attr('aria-expanded') === 'true'
  $h.attr('aria-expanded', !isOpen)
  $c.slideToggle()
})
</script>

infinite scroll

infinite scroll: erkennen, wenn der nutzer nahe am unteren rand scrollt, weitere items holen, anhängen. gegen gleichzeitige loads absichern (loading flag). liefert der server keine weiteren items, den scroll handler entbinden (keine versuche mehr). anhängen über ein fragment für performance. den scroll handler drosseln (er feuern oft je sekunde) — mit debounce/_.throttle oder dem loading flag (wie hier), um zu überspringen, solange eine anfrage läuft. moderne alternative: IntersectionObserver an einem sentinel element unten.

jquery
let loading = false
let page = 1

function loadMore() {
  if (loading) return
  loading = true
  $('.loader').show()

  $.get('/api/items', { page: page })
    .done(function (items) {
      if (items.length === 0) {
        // no more items — unbind the scroll handler
        $(window).off('scroll.inf')
        return
      }
      const $frag = $(document.createDocumentFragment())
      items.forEach(item => {
        $frag.append($('<li>').text(item.name))
      })
      $('ul.items').append($frag)
      page++
    })
    .always(function () {
      loading = false
      $('.loader').hide()
    })
}

// trigger when near bottom
$(window).on('scroll.inf', function () {
  if ($(window).scrollTop() + $(window).height() > $(document).height() - 200) {
    loadMore()
  }
})

live suche (debounced)

live suche: während der nutzer tippt den server abfragen und ergebnisse zeigen. debounce ist pflicht — ohne feuert jeder tastendruck eine anfrage (schnelles tippen = Dutzende anfragen). der debounce wartet N ms nach dem letzten tastendruck. 300ms sind ein guter default. die leere abfrage immer behandeln (ergebnisse leeren). in produktion laufende anfragen abbrechen, wenn eine neue startet (.abort() am vorigen jqXHR), um aus-der-reihe-geratene antworten zu vermeiden. moderne alternative: AbortController mit fetch.

jquery
// debounce: wait until user pauses typing
function debounce(fn, wait) {
  let timer
  return function () {
    clearTimeout(timer)
    const args = arguments
    const ctx = this
    timer = setTimeout(() => fn.apply(ctx, args), wait)
  }
}

// live search
const $input = $('#search')
const $results = $('#results')

$input.on('input', debounce(function () {
  const q = $(this).val()
  if (!q) { $results.empty(); return }

  $.get('/api/search', { q: q })
    .done(function (items) {
      $results.empty()
      items.forEach(item => {
        $results.append($('<li>').text(item.name))
      })
    })
}, 300))  // wait 300ms after last keystroke

// without debounce, a search fires on every keystroke (too many requests)

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.