Benutzerdefinierte Varianten per Plugin hinzufügen
Erstellen Sie mit addVariant benutzerdefinierte Statusvarianten für Selektoren wie .is-active oder Datenattribute und verwenden Sie sie als Klassenpräfixe im Markup.
Benutzerdefinierte Varianten per Plugin hinzufügen ist eine kostenlose Tailwind CSS Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Tailwind CSS Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Tailwind CSS Academy-Kurs umfasst insgesamt 4 Lektionen.
Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.
What Are Tailwind Variants?
Tailwind variants are the prefixes like hover:, focus:, dark:, and sm: that conditionally apply a utility class. Each variant wraps the generated CSS in a selector or media query. The addVariant plugin helper lets you register your own variant prefixes, enabling you to write things like aria-selected:bg-blue-100, data-active:opacity-100, or is-loading:cursor-wait in your HTML.
The addVariant Helper
addVariant takes two arguments: the variant name (the prefix before the colon) and a selector template string. The selector uses & as a placeholder for the generated class selector. When a user writes hocus:bg-gray-100, Tailwind replaces & with the generated class selector for bg-gray-100 and wraps it in your selector pattern.
const plugin = require('tailwindcss/plugin');
plugin(function({ addVariant }) {
// 'hocus' = hover OR focus (useful for touch/keyboard parity)
addVariant('hocus', ['&:hover', '&:focus']);
// Usage in markup:
// <button class='hocus:bg-blue-100 hocus:text-blue-700'>
// This button highlights on both hover and focus
// </button>
})Data Attribute Variants
One of the most practical uses of custom variants is targeting data attributes. Many UI frameworks (like Alpine.js, Headless UI, and Stimulus) communicate state through data-* attributes. Custom variants let you apply Tailwind classes based on these attributes, keeping all styling in the HTML class list rather than mixing CSS with attribute selectors in a stylesheet.
plugin(function({ addVariant }) {
// Target elements with data-active='true'
addVariant('data-active', '&[data-active='true']');
// Target elements with data-state='open'
addVariant('open', '&[data-state='open']');
// Target disabled attribute (not just :disabled pseudo-class)
addVariant('ui-disabled', '&[aria-disabled='true']');
})
// Usage:
// <div data-state='open' class='open:bg-blue-50 open:border-blue-200'>
// <button aria-disabled='true' class='ui-disabled:opacity-50 ui-disabled:cursor-not-allowed'>Parent State Variants
Tailwind has built-in group and peer patterns, but sometimes you need to target elements based on a parent with a specific class or attribute. Custom variants using the :where() or direct ancestor syntax let you express these relationships. The addVariant selector can reference parent elements by using .parent-class & patterns.
plugin(function({ addVariant }) {
// Apply when an ancestor has .is-dragging class
addVariant('dragging', '.is-dragging &');
// Apply when the form has [data-submitting] attribute
addVariant('submitting', '[data-submitting] &');
// Apply when the theme container is in .dark mode
addVariant('dark-mode', '.dark &');
})
// Usage:
// <form data-submitting>
// <input class='submitting:opacity-50 submitting:cursor-wait' />
// <button class='submitting:bg-gray-400 submitting:pointer-events-none'>
// Submit
// </button>
// </form>nth-Child and nth-of-Type Variants
CSS :nth-child() and :nth-of-type() pseudo-selectors enable styling based on position in a list. Tailwind includes odd: and even: variants, but not all :nth-child expressions. Add custom variants for patterns you use repeatedly, like first-three: for the first three list items or last-two: for the last two.
plugin(function({ addVariant }) {
// First 3 items
addVariant('first-3', '&:nth-child(-n+3)');
// Every 3rd item
addVariant('third', '&:nth-child(3n)');
// Only child
addVariant('only', '&:only-child');
// Not the first child
addVariant('not-first', '&:not(:first-child)');
// Not the last child
addVariant('not-last', '&:not(:last-child)');
})
// Usage:
// <ul>
// <li class='first-3:font-bold not-last:border-b'>Item 1</li>
// <li class='first-3:font-bold not-last:border-b'>Item 2</li>
// <li class='first-3:font-bold not-last:border-b'>Item 3</li>
// </ul>Combination Variants
The addVariant second argument accepts an array of selectors. When an array is provided, each selector becomes a separate rule, so any selector in the array triggers the variant. This is useful for combination variants that should apply across multiple related selectors — like styling an element when it is either selected or expanded.
plugin(function({ addVariant }) {
// 'selected' applies on aria-selected OR aria-current
addVariant('selected', [
'&[aria-selected='true']',
'&[aria-current='true']',
'&[aria-current='page']'
]);
// 'expanded' applies on open disclosure or expanded accordion
addVariant('expanded', [
'&[aria-expanded='true']',
'&[data-state='open']'
]);
})
// Usage:
// <a class='selected:bg-blue-50 selected:text-blue-700 expanded:rotate-180'>Pseudo-Element Variants
You can add variants that target pseudo-elements like ::before, ::after, ::placeholder, and ::selection. The selector template uses &:: for pseudo-elements. Combined with Tailwind's content utilities, pseudo-element variants enable CSS-only decorative elements without extra HTML markup.
plugin(function({ addVariant }) {
// ::after pseudo-element variant
addVariant('after', '&::after');
// ::before pseudo-element variant
addVariant('before', '&::before');
// ::selection (text selection styling)
addVariant('selection', '&::selection');
})
// Usage (combine with content utility for decorative elements):
// <div class="
// relative
// after:content-[''] after:absolute after:inset-0
// after:bg-gradient-to-t after:from-black/50 after:to-transparent
// after:rounded-xl after:pointer-events-none
// ">Media Query Variants
Custom variants can also wrap utilities in media queries beyond Tailwind's default breakpoints. Use this for features like prefers-reduced-motion, prefers-contrast, or custom DPI queries. Pass the media query string as the second argument to addVariant with the @media syntax.
plugin(function({ addVariant }) {
// Prefers reduced motion variant
addVariant('motion-reduce', '@media (prefers-reduced-motion: reduce)');
// High contrast mode
addVariant('contrast-high', '@media (prefers-contrast: high)');
// Print media
addVariant('print', '@media print');
// Pointer: coarse (touch devices)
addVariant('touch', '@media (pointer: coarse)');
})
// Usage:
// <div class='motion-reduce:transition-none motion-reduce:animate-none'>
// <button class='touch:py-4 touch:text-lg'>Larger on touch</button>ARIA Attribute Variants for Accessibility
ARIA attributes are the primary way assistive technologies communicate state. Building custom variants for common ARIA states lets you write accessibility-driven styles directly in HTML. Tailwind v3.2+ added some built-in ARIA variants (aria-checked:, aria-selected:), but you can extend this with any ARIA attribute your UI components use.
plugin(function({ addVariant }) {
// Custom ARIA variants for component states
addVariant('aria-expanded-true', '&[aria-expanded='true']');
addVariant('aria-pressed', '&[aria-pressed='true']');
addVariant('aria-busy', '&[aria-busy='true']');
addVariant('aria-invalid', '&[aria-invalid='true']');
addVariant('aria-required', '&[aria-required='true']');
})
// Usage:
// <button aria-pressed='true'
// class='aria-pressed:bg-blue-600 aria-pressed:text-white
// aria-busy:opacity-60 aria-busy:cursor-wait'>
// Toggle
// </button>Combining addVariant With addUtilities
The most powerful plugins combine addVariant and addUtilities (or addComponents) in a single plugin. For example, a plugin might define a selected: variant AND a set of .menu-item component classes that work together. Packaging related utilities and variants in a single plugin keeps the feature cohesive and easy to enable or disable as a unit.
// A complete 'list-nav' plugin
plugin(function({ addVariant, addComponents }) {
// Variant: item is the currently active page
addVariant('nav-active', '&[data-nav-active='true']');
// Component: base nav item style
addComponents({
'.nav-item': {
display: 'flex',
alignItems: 'center',
gap: '0.5rem',
padding: '0.5rem 0.75rem',
borderRadius: '0.5rem',
fontSize: '0.875rem',
fontWeight: '500',
color: '#4b5563',
cursor: 'pointer',
transition: 'background-color 150ms, color 150ms',
'&:hover': { backgroundColor: '#f3f4f6' }
}
});
})
// Usage:
// <a class='nav-item nav-active:bg-blue-50 nav-active:text-blue-700'>Testing Custom Variants
Verify custom variants work by writing HTML that uses them, running the Tailwind CLI, and inspecting the output CSS. The generated selector should match your addVariant template. Also test that the variant composes correctly with responsive prefixes — md:data-active:bg-blue-100 — and with other state variants like hover:data-active:bg-blue-200. Some variant combinations may produce unexpected selectors; testing confirms the generated CSS is what you expect.
<!-- test.html -->
<div data-active='true'
class='data-active:bg-blue-50 data-active:border-blue-200
hover:data-active:bg-blue-100
md:data-active:bg-blue-200'>
Content
</div>
<button aria-pressed='true'
class='aria-pressed:bg-blue-600 aria-pressed:text-white'>
Toggle
</button>
<!-- Expected generated CSS: -->
/* .data-active\:bg-blue-50[data-active='true'] { background-color: #eff6ff } */
/* @media (min-width: 768px) { .md\:data-active\:bg-blue-200[data-active='true'] { ... } } */Quick Check
Test your understanding of Tailwind CSS Mastery concepts from this lesson.
Lesson Recap
In this lesson you learned: addVariant creates custom class prefixes that wrap utilities in selector patterns or media queries, data attribute variants let you style based on framework state without writing CSS, and variants can be combined with arrays for multi-selector coverage. Next up we learn how to package and publish Tailwind plugins for reuse across projects.
Lerne HTML mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 30
- Lektionen
- 120
Häufig gestellte Fragen
Ist die Lektion „Benutzerdefinierte Varianten per Plugin hinzufügen“ kostenlos?
Ja — der vollständige Text von „Benutzerdefinierte Varianten per Plugin hinzufügen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Tailwind CSS Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Tailwind CSS Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Benutzerdefinierte Varianten per Plugin hinzufügen“?
Erstellen Sie mit addVariant benutzerdefinierte Statusvarianten für Selektoren wie .is-active oder Datenattribute und verwenden Sie sie als Klassenpräfixe im Markup. Du übst Tailwind CSS Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Tailwind CSS Academy zu starten?
Keine Vorkenntnisse erforderlich. Tailwind CSS Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Benutzerdefinierte Varianten per Plugin hinzufügen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Tailwind CSS Academy-Lektion Code schreiben und ausführen?
Ja. Jede Tailwind CSS Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Die Tailwind-Plugin-API
- Benutzerdefinierte Utilities per Plugin hinzufügen
- Benutzerdefinierte Varianten per Plugin hinzufügen
- Plugins veröffentlichen und wiederverwenden