CSS :where(): selettori a specificità zero e stili flessibili

Scopri come funziona la pseudo-classe CSS :where(), come mantiene la specificità a zero e come usarla per creare stili globali e componenti facilmente personalizzabili. 
Cos'è il selettore CSS :where()
:where() è una pseudo-classe funzionale introdotta per
semplificare la scrittura dei selettori CSS e, soprattutto, per
controllarne la specificità.
Il suo funzionamento è simile a quello di :is(): accetta
una lista di selettori e corrisponde agli elementi che soddisfano almeno
uno di essi. La differenza fondamentale riguarda la specificità.
Mentre :is() assume la specificità del selettore più
specifico tra quelli passati come argomento, :where()
mantiene sempre una specificità pari a zero, indipendentemente
dai selettori contenuti al suo interno.
Questo significa che puoi utilizzarlo per selezionare elementi attraverso selettori complessi senza rendere più difficile sovrascrivere le regole CSS in un secondo momento.
Sintassi di :where()
La sintassi è semplice: all'interno delle parentesi puoi inserire uno o più selettori, separati da una virgola.
:where(selettore1, selettore2, selettore3) {
/* dichiarazioni CSS */
}
Se un elemento corrisponde ad almeno uno dei selettori indicati, le dichiarazioni contenute nel blocco vengono applicate.
La lista di selettori è permissiva: un selettore non valido o non
supportato all'interno di :where() non invalida
necessariamente l'intera lista. I selettori validi possono continuare
a essere utilizzati.
La specificità di :where() è sempre zero
Per comprendere il vantaggio principale di :where(),
è utile ricordare come funziona la specificità CSS.
La specificità viene normalmente calcolata considerando tre categorie di selettori:
- ID, che contribuiscono alla prima colonna;
- classi, attributi e pseudo-classi, che contribuiscono alla seconda;
- elementi e pseudo-elementi, che contribuiscono alla terza.
Il valore viene rappresentato convenzionalmente come
ID - CLASS - ELEMENT. Per esempio, #header
ha specificità 1-0-0, .menu ha
specificità 0-1-0 e nav ha specificità
0-0-1.
Con :where(), invece, né la pseudo-classe né i selettori
inseriti tra le parentesi contribuiscono al calcolo della specificità.
Il risultato è sempre 0-0-0.
:where(#header .menu li.active a) {
color: blue;
}
Il selettore è in grado di individuare un link che si trova all'interno
di un elemento con ID header, di un elemento con classe
menu, di un li con classe
active, ma la sua specificità rimane
zero.
Il comportamento rende questa pseudo-classe particolarmente interessante per gli stili di base e per le regole che devono poter essere facilmente ridefinite da altri stylesheet.
Un confronto tra :where() e :is()
Le pseudo-classi :where() e :is() hanno
una sintassi e un comportamento di selezione simili, ma differiscono
nel calcolo della specificità.
:is(#main, .content, article) h2 {
color: darkblue;
}
:where(#main, .content, article) h2 {
color: darkgreen;
}
Nel primo caso, :is() assume la specificità del selettore
più specifico tra i suoi argomenti. Poiché la lista contiene un ID,
la specificità del primo selettore è 1-0-1.
Nel secondo caso, :where() non contribuisce alla
specificità. La specificità complessiva è determinata esclusivamente
da h2, quindi 0-0-1.
Se vuoi raggruppare selettori e mantenere le regole facilmente
sovrascrivibili, :where() è generalmente la scelta
più adatta. Se invece vuoi raggruppare selettori mantenendo
la specificità del più specifico tra quelli indicati, puoi usare
:is().
Utilizzare :where() per gli stili globali
Uno degli utilizzi più interessanti di :where() riguarda
la definizione degli stili globali. Quando realizzi un reset o uno
stylesheet di base, potresti voler applicare le stesse regole a
elementi che si trovano in contesti differenti.
Ad esempio, puoi definire un set di regole per titoli, paragrafi, liste e altri elementi contenuti in aree testuali:
:where(h1, h2, h3, h4, h5, h6) {
font-family: system-ui, sans-serif;
line-height: 1.2;
}
:where(p, ul, ol, blockquote) {
margin-block: 1rem;
}
Queste dichiarazioni costituiscono una base di partenza, ma possono
essere facilmente modificate da regole più specifiche, senza dover
ricorrere a selettori complessi o a !important.
È un approccio utile per evitare che gli stili globali diventino troppo invasivi e condizionino la personalizzazione delle singole pagine o componenti.
Gestire la specificità all'interno di un componente
:where() può essere utilizzato anche quando sviluppi
componenti che devono essere personalizzati da chi li integra.
Immagina di avere un componente card che può contenere titoli,
paragrafi, link e liste.
.card :where(h2, h3) {
margin-block-start: 0;
}
.card :where(p, ul, ol) {
margin-block-end: 1rem;
}
.card :where(a) {
color: inherit;
text-decoration-thickness: 0.08em;
}
In questo modo puoi applicare regole specifiche al contesto della
card, mantenendo però basso il peso dei selettori. La classe
.card contribuisce alla specificità, mentre
:where() non aggiunge alcun peso.
La possibilità di intervenire facilmente sulle regole predefinite diventa particolarmente utile quando i componenti vengono riutilizzati in applicazioni differenti, quando si sviluppa un design system o quando si lavora su un progetto con stylesheet condivisi tra più team.
Combinare :where() con selettori strutturali
La pseudo-classe può essere combinata con combinatori CSS e selettori strutturali per creare regole articolate senza aumentarne inutilmente la specificità.
Considera, per esempio, il caso in cui vuoi applicare uno stile a determinati elementi all'interno di un contenitore, ma solo quando questi sono discendenti diretti:
.content > :where(h1, h2, h3, p, ul, ol) {
max-width: 65ch;
}
Il combinatore > seleziona esclusivamente i figli diretti
di .content, mentre :where() permette di
raggruppare gli elementi di interesse.
La specificità di questo selettore è 0-1-0, dovuta
esclusivamente alla classe .content. Gli elementi
elencati all'interno di :where() non incidono sul
calcolo.
Quando conviene utilizzare :where()
:where() non è necessariamente la soluzione migliore
per ogni selettore. Il suo valore emerge soprattutto quando vuoi
separare la logica di selezione degli elementi dal peso che una
regola esercita nel cascade.
Può essere particolarmente utile nei seguenti contesti:
- definizione di reset CSS e stili globali;
- creazione di design system e librerie di componenti;
- sviluppo di widget o componenti riutilizzabili;
- riduzione dei conflitti tra stylesheet;
- semplificazione della manutenzione di selettori complessi;
- gestione di stili che devono essere facilmente personalizzabili.
In generale, mantenere bassa la specificità aiuta a evitare una progressiva escalation di selettori sempre più complessi. Questo rende il CSS più leggibile e riduce la necessità di ricorrere a override forzati.
Compatibilità con i browser
La pseudo-classe :where() è supportata dai browser
moderni. Può essere utilizzata nei principali browser desktop e
mobile, inclusi Chrome, Edge, Firefox e Safari.
Se il progetto deve supportare versioni molto datate dei browser, è comunque consigliabile verificare la compatibilità con il target previsto attraverso strumenti come MDN e Can I Use.
In progetti destinati a browser moderni, non è normalmente necessario
prevedere workaround specifici per :where().
Link utili
- MDN - :where() : documentazione, sintassi ed esempi.
- MDN - CSS Specificity : approfondimento sul calcolo della specificità dei selettori.
- MDN - :is() : confronto con un'altra pseudo-classe funzionale per raggruppare selettori.
- Can I Use - :where() : verifica della compatibilità tra browser e versioni.
Conclusioni
La pseudo-classe CSS :where() è uno strumento semplice
ma efficace per scrivere selettori più flessibili. Permette di
raggruppare elementi in base a criteri anche complessi senza
aumentare la specificità delle regole che li stilizzano.
Il vantaggio principale è la possibilità di realizzare stili globali, componenti riutilizzabili e stylesheet più facilmente personalizzabili, riducendo i conflitti e la necessità di override.
Quando la manutenibilità del CSS è un requisito del progetto, mantenere la specificità sotto controllo è una scelta progettuale importante. :where() permette di farlo in modo esplicito, senza rinunciare alla precisione dei selettori.
