Seletores
Seletores de atributo e pseudo-classes
O CSS3 introduziu seletores de atributo e pseudo-classes poderosos. ^= casa o prefixo, $= casa o sufixo, *= casa uma substring. nth-child permite listras zebra sem JavaScript.
/* attribute selectors */
input[type="text"] { border: 1px solid blue; }
a[href^="https"] { color: green; }
a[href$=".pdf"] { color: red; }
a[href*="example"] { font-weight: bold; }
/* pseudo-classes */
a:visited { color: purple; }
li:first-child { font-weight: bold; }
li:nth-child(odd) { background: #f0f0f0; }
input:focus { outline: 2px solid blue; }Pseudo-classes estruturais
Pseudo-classes estruturais selecionam elementos pela posição no DOM. :first-child / :last-child miram as pontas. nth-child(an+b) suporta fórmulas: 2n é par, 2n+1 é ímpar, 3n é a cada três. :nth-of-type conta apenas irmãos do mesmo tipo de elemento. :empty casa elementos sem filhos.
/* positional pseudo-classes */
li:first-child { color: green; }
li:last-child { color: red; }
li:only-child { font-weight: bold; }
/* nth variants */
li:nth-child(3) { color: blue; }
li:nth-child(2n+1) { background: #eee; } /* odd */
li:nth-last-child(2) { color: orange; }
/* type-based */
p:first-of-type { font-size: 1.2em; }
p:nth-of-type(even) { color: gray; }
div:empty { display: none; }:is, :where e :has
:is() e :where() agrupam seletores para economizar código. A diferença: :is() assume a maior especificidade dos seus argumentos, enquanto :where() sempre tem especificidade zero — ideal para estilos base fáceis de sobrescrever. :has() é o aguardado seletor pai/relacional, permitindo estilizar um elemento com base nos seus descendentes.
/* :is() - matches any selector in the list */
:is(h1, h2, h3) { color: navy; }
:is(.btn, .link):hover { opacity: 0.8; }
/* :where() - same as :is but zero specificity */
:where(article, section) p { line-height: 1.6; }
/* :has() - parent selector (selects element that has a match) */
div:has(> img) { padding: 0; }
card:has(.badge) { border-color: gold; }
form:has(input:invalid) button { opacity: 0.5; }Negação e pseudo-classes de formulário
:not() nega um seletor e agora aceita uma lista. Pseudo-classes de formulário (:required, :valid, :invalid, :checked, :placeholder-shown, :in-range) permitem estilizar com base no estado do input sem JavaScript — ótimo para feedback de validação inline e estilização personalizada de checkbox/radio.
/* :not() excludes matching elements */
input:not([type="checkbox"]) { display: block; }
li:not(:last-child) { border-bottom: 1px solid #ddd; }
/* form state pseudo-classes */
input:required { border-color: red; }
input:optional { border-color: #ccc; }
input:valid { border-color: green; }
input:invalid { border-color: red; }
input:in-range { color: black; }
input:out-of-range { color: red; }
input:placeholder-shown { background: #fafafa; }
input:checked + label { font-weight: bold; }Especificidade e cascata
A especificidade decide qual regra se aplica quando seletores conflitam. Conte IDs, classes e elementos como (a,b,c). !important sobrescreve a cascata mas quebra a manutenção — evite. Em empate de especificidade, a regra posterior na ordem do código vence. O DevTools mostra a cascata calculada.
/* specificity ranking: inline > ID > class/attr/pseudo > type/element */
#nav .item { color: red; } /* 1,1,0 */
.menu .item { color: blue; } /* 0,2,0 */
li.item { color: green; } /* 0,1,1 */
/* !important overrides normal declarations */
.btn { color: white !important; }
/* source order wins on equal specificity */
.late { color: purple; } /* wins over .early */Box model
box-sizing
box-sizing: border-box inclui padding e borda dentro da width/height declarada, tornando o dimensionamento previsível. content-box (padrão) os adiciona por cima. Aplicar border-box globalmente é o reset CSS mais importante — elimina as maiores dores de cabeça de cálculo de layout.
/* default: width = content only */
.box-content { box-sizing: content-box; width: 200px; padding: 20px; } /* total 240px */
/* padding & border inside width */
.box-border { box-sizing: border-box; width: 200px; padding: 20px; border: 2px solid; } /* total 200px */
/* universal reset - apply everywhere */
*, *::before, *::after {
box-sizing: border-box;
}Margin e padding
Padding fica dentro da borda (herda o fundo); margin fica fora (transparente). Margens verticais entre elementos block adjacentes colapsam para o maior valor — margens horizontais nunca colapsam. margin: 0 auto centraliza um elemento block com largura definida. Margens negativas podem puxar conteúdo, mas use com parcimônia.
.box {
/* top right bottom left (clockwise) */
margin: 10px 20px 15px 25px;
/* 2 values: vertical horizontal */
padding: 10px 20px;
/* single value: all sides */
margin: 0 auto; /* horizontal centering for fixed-width block */
}
/* margin collapse (vertical only) */
.a { margin-bottom: 30px; }
.b { margin-top: 20px; }
/* gap between .a and .b = 30px, not 50px (collapsed to larger) */
/* negative margins pull elements together */
.pull-left { margin-left: -10px; }box-shadow
Sintaxe do box-shadow: offset-x offset-y blur-radius spread-radius cor. Offsets positivos empurram a sombra para a direita/baixo. inset cria uma sombra interna. Múltiplas sombras se empilham, com a primeira por cima. Use rgba para sombras translúcidas e naturais. Sombras duras (blur zero) criam uma estética plana e marcante.
/* offset-x offset-y blur spread color */
.card { box-shadow: 0 4px 6px rgba(0,0,0,0.1); }
/* inset shadow (inside the box) */
.inset { box-shadow: inset 0 2px 4px rgba(0,0,0,0.2); }
/* multiple shadows (first = top layer) */
.layered { box-shadow: 0 1px 2px #000, 0 8px 24px rgba(0,0,0,0.15); }
/* no blur, hard shadow (neo-brutalism) */
.hard { box-shadow: 6px 6px 0 #000; }
/* glow effect */
.glow { box-shadow: 0 0 20px rgba(0,150,255,0.6); }Tipos de display
display: none remove o elemento do layout (sem espaço reservado). Elementos block ocupam a largura total e empilham verticalmente; elementos inline fluem com o texto e ignoram width/height. inline-block combina fluxo inline com dimensionamento de bloco. flow-root limpa floats sem hacks de clearfix. contents faz a caixa desaparecer mantendo os filhos no layout.
/* block: full width, new line */
div, p { display: block; }
/* inline: flows with text, ignores width/height */
span, a { display: inline; }
/* inline-block: flows inline but accepts width/height */
.tag { display: inline-block; width: 100px; }
/* none: removed from layout entirely */
.hidden { display: none; }
/* modern display values */
.flow { display: flow-root; } /* new block formatting context */
.contents { display: contents; } /* element's box disappears, children participate */Overflow
overflow controla como o conteúdo que excede a caixa é tratado. visible (padrão) deixa vazar; hidden corta; auto adiciona barras de rolagem quando necessário; scroll sempre as mostra. clip (mais novo) é como hidden, mas impede qualquer rolagem, até via JS. Use overflow-y/x para controlar os eixos de forma independente. Definir overflow como algo diferente de visible cria um novo contexto de formatação.
.scrollable {
overflow: auto; /* scrollbars when needed */
overflow-y: scroll; /* always show vertical scrollbar */
overflow-x: hidden; /* hide horizontal overflow */
}
/* visible (default) - content spills out */
.spill { overflow: visible; }
/* clip - like hidden but no programmatic scroll */
.clipped { overflow: clip; }
/* clip to a shape */
.custom-clip {
overflow: clip;
overflow-clip-margin: 20px;
}
/* longhand for both axes */
.both { overflow-x: hidden; overflow-y: auto; }Flexbox
Container flex
display: flex torna um elemento um container flex. justify-content alinha os itens ao longo do eixo principal (horizontal em row); align-items alinha no eixo transversal. flex-wrap permite que os itens quebrem para novas linhas. gap substitui o hack de espaçamento baseado em margin. Flexbox brilha em layouts unidimensionais (linhas ou colunas).
.container {
display: flex;
flex-direction: row; /* row | row-reverse | column | column-reverse */
justify-content: center; /* main axis: flex-start | center | space-between | space-around | space-evenly */
align-items: center; /* cross axis: stretch | flex-start | center | baseline */
flex-wrap: wrap; /* nowrap | wrap | wrap-reverse */
gap: 16px; /* spacing between items */
align-content: space-between; /* multi-line spacing */
}Flex items
flex-grow controla quanto um item se expande para preencher espaço extra (1 = parcela igual). flex-shrink controla o encolhimento. flex-basis é o tamanho inicial. O shorthand flex: 1 significa crescer igualmente a partir de base zero — perfeito para colunas iguais. align-self sobrescreve o align-items do container para um único item. order reordena visualmente sem mudar a ordem do DOM.
.item {
flex-grow: 1; /* grow to fill extra space (0 = don't grow) */
flex-shrink: 1; /* shrink when space is tight (0 = don't shrink) */
flex-basis: 200px; /* initial size before growing/shrinking */
/* shorthand: flex: grow shrink basis */
flex: 1 1 200px; /* flexible from 200px */
flex: 1; /* = 1 1 0% - equal distribution */
flex: 0 0 250px; /* fixed width, no grow/shrink */
align-self: flex-end; /* override align-items for this item */
order: 2; /* visual reordering (default 0) */
}Padrões de alinhamento flex
Flexbox torna a centralização trivial: justify-content: center + align-items: center. Um rodapé fixo usa um body flex em coluna com min-height: 100vh e o conteúdo principal com flex: 1. Para barras de navegação, space-between empurra o primeiro e o último item para bordas opostas. Margens automáticas (margin-left: auto) são uma alternativa flexível ao justify-content para empurrar itens.
/* perfect centering */
.center {
display: flex;
justify-content: center;
align-items: center;
min-height: 100vh;
}
/* sticky footer: body is flex column */
body { display: flex; flex-direction: column; min-height: 100vh; }
main { flex: 1; } /* grows to fill, pushing footer down */
/* navbar: space between */
.nav { display: flex; justify-content: space-between; }
/* auto margins absorb space */
.push-right { margin-left: auto; }Flex wrap e grid responsivo
flex-wrap: wrap deixa os itens fluírem para novas linhas quando falta espaço. flex: 1 1 280px cria cards que começam com 280px e crescem para preencher a linha. Isso faz um grid de cards responsivo sem media queries. Atenção: os itens da última linha se esticam para preencher, o que pode parecer desigual — para grids de cards consistentes, o CSS Grid costuma ser uma escolha melhor.
.cards {
display: flex;
flex-wrap: wrap;
gap: 20px;
}
.card {
/* start at 280px, grow & shrink fluidly */
flex: 1 1 280px;
/* prevent stretching beyond readable width */
max-width: 100%;
}
/* OR fixed-width cards that wrap */
.card-fixed {
flex: 0 0 300px;
}
/* last row items stretch to fill - to avoid, use grid instead */
/* gap wraps with items automatically */Flex direction e eixos
flex-direction determina o eixo principal. Em row (padrão), justify-content controla o alinhamento horizontal; em column, controla o vertical — os eixos trocam. Sempre pergunte 'qual é o eixo principal?' ao alinhar. row-reverse e column-reverse invertem a ordem dos itens, o que também afeta como justify-content distribui o espaço.
/* row: main axis = horizontal */
.row { display: flex; flex-direction: row; justify-content: center; }
/* column: main axis = vertical (axes swap!) */
.col { display: flex; flex-direction: column; align-items: center; }
/* reverse order */
.reverse { display: flex; flex-direction: row-reverse; }
/* centering in column: justify-content centers vertically */
.col-center {
display: flex;
flex-direction: column;
justify-content: center; /* vertical center */
align-items: center; /* horizontal center */
}Grid Layout
Container grid
display: grid cria um layout bidimensional. grid-template-columns define as colunas; a unidade fr distribui o espaço livre proporcionalmente. repeat(auto-fit, minmax(200px, 1fr)) é a receita mágica de grids responsivos — as colunas se criam e redimensionam sozinhas, sem media queries. gap adiciona espaço entre as trilhas de forma limpa.
.grid {
display: grid;
/* fixed columns */
grid-template-columns: 200px 1fr 200px;
/* responsive auto columns */
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
grid-template-rows: auto 1fr auto;
gap: 20px; /* row + column gap */
row-gap: 20px; /* gap between rows */
column-gap: 16px; /* gap between columns */
}Grid template areas
grid-template-areas permite desenhar o layout visualmente com regiões nomeadas — extremamente legível. Cada string entre aspas é uma linha; os nomes posicionam itens, e um ponto marca uma célula vazia. Um item com grid-area: name preenche aquela região. É a forma mais clara de construir layouts de página, como app shells.
.layout {
display: grid;
grid-template-columns: 200px 1fr;
grid-template-rows: auto 1fr auto;
grid-template-areas:
"header header"
"sidebar main"
"footer footer";
min-height: 100vh;
}
.header { grid-area: header; }
.sidebar { grid-area: sidebar; }
.main { grid-area: main; }
.footer { grid-area: footer; }
/* empty cell with a dot */
grid-template-areas: "header header" "sidebar .";Posicionamento de itens no grid
Itens do grid podem ser posicionados explicitamente por números de linha. grid-column: 1 / 3 abrange da linha 1 à linha 3 (cobrindo 2 colunas). A palavra-chave span dimensiona por contagem de trilhas. As linhas também podem ser nomeadas em grid-template-columns para legibilidade. Sem posicionamento explícito, os itens fluem automaticamente para as células disponíveis.
.item {
/* place by line numbers: row-start / col-start / row-end / col-end */
grid-column: 1 / 3; /* span columns 1 to 3 */
grid-row: 1 / 2;
/* span keyword */
grid-column: span 2; /* span 2 columns */
grid-row: 2 / span 3;
/* shorthand: grid-area: row-start / col-start / row-end / col-end */
grid-area: 1 / 1 / 3 / 4;
/* name a line and reference it */
grid-column-start: content-start;
}Alinhamento no grid
O alinhamento do grid funciona em dois níveis. justify-content/align-content posicionam o grid inteiro dentro do container quando sobra espaço. justify-items/align-items alinham os itens dentro das suas células (stretch por padrão). justify-self/align-self sobrescrevem o alinhamento por item. 'justify' = eixo inline/principal, 'align' = eixo block/transversal.
.grid {
display: grid;
grid-template-columns: repeat(3, 100px);
/* align tracks within container */
justify-content: center; /* center the grid horizontally */
align-content: center; /* center vertically (needs fixed height) */
/* align items within their cells */
justify-items: stretch; /* fill cell width (default) */
align-items: center; /* center within cell height */
}
.item {
justify-self: start; /* override justify-items for one item */
align-self: end;
}auto-fit vs auto-fill
Ambos criam quantas trilhas couberem, mas se comportam diferente com poucos itens. auto-fit colapsa as trilhas não usadas e estica os itens existentes para preencher a linha. auto-fill mantém as trilhas vazias, então os itens ficam no tamanho mínimo. Use auto-fit quando quiser que os itens cresçam e preencham o espaço; use auto-fill quando quiser um tamanho de item fixo e consistente.
/* auto-fit: empty tracks collapse, items stretch to fill */
.autofit {
grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
}
/* auto-fill: empty tracks remain, items keep their size */
.autofill {
grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
}
/* with few items:
auto-fit -> items stretch to fill the row
auto-fill -> items stay small, leaving empty columns */Posicionamento
Valores de position
static é o padrão. relative desloca um elemento da sua posição normal no fluxo (o espaço é preservado). absolute o remove do fluxo e posiciona relativo ao ancestral posicionado mais próximo (ou à viewport). fixed é relativo à viewport do navegador. sticky alterna entre relative e fixed conforme a posição de rolagem — ideal para cabeçalhos fixos.
/* static - default, flows normally */
.static { position: static; }
/* relative - offset from its normal position */
.relative { position: relative; top: 10px; left: 20px; }
/* absolute - positioned relative to nearest positioned ancestor */
.absolute { position: absolute; top: 0; right: 0; }
/* fixed - positioned relative to viewport (stays on scroll) */
.fixed { position: fixed; bottom: 0; left: 0; }
/* sticky - relative until scroll threshold, then fixed */
.sticky { position: sticky; top: 0; }Centralização absoluta
Há várias formas de centralizar absolutamente. O truque translate(-50%, -50%) funciona em elementos de qualquer tamanho. A técnica inset: 0 + margin: auto exige dimensões explícitas. A abordagem moderna é display: grid com place-items: center (shorthand de align-items + justify-items) — sem cálculos de posicionamento e a função mais simples.
/* classic: position absolute + transform */
.center {
position: absolute;
top: 50%; left: 50%;
transform: translate(-50%, -50%);
}
/* inset: 0 + margin: auto (needs width/height) */
.center-auto {
position: absolute;
inset: 0; /* top/right/bottom/left: 0 */
margin: auto;
width: 300px;
height: 200px;
}
/* modern: no positioning needed */
.center-grid { display: grid; place-items: center; }Posicionamento sticky
position: sticky mantém um elemento no fluxo normal até atingir um limiar (por exemplo, top: 0), então gruda como fixed. Perfeito para cabeçalhos fixos ou sidebars de sumário. Pegadinha: qualquer ancestral com overflow: hidden/auto/scroll (na direção da rolagem) vira o containing block e quebra o comportamento esperado. Sempre defina um fundo e z-index nos elementos sticky.
.header {
position: sticky;
top: 0; /* sticks when header hits top of viewport */
z-index: 100;
background: white;
}
/* sticky sidebar that scrolls with content until threshold */
.sidebar {
position: sticky;
top: 60px; /* offset below the fixed header */
max-height: calc(100vh - 60px);
overflow-y: auto;
}
/* NOTE: a parent with overflow: hidden breaks sticky */z-index e stacking contexts
z-index só funciona em elementos posicionados (não static). Um stacking context é criado por position + z-index, mas também por opacity < 1, transform, filter, will-change e isolation: isolate. Dentro de um stacking context, os z-index dos filhos ficam isolados — um filho nunca pode renderizar acima de um irmão de um ancestral. Entender isso evita guerras de escalada de z-index.
.modal { position: fixed; z-index: 1000; }
.overlay { position: fixed; z-index: 999; }
.card { position: relative; z-index: 1; }
/* creating a stacking context (isolates z-index) */
.context {
position: relative;
z-index: 0; /* children's z-index only matters within this */
}
/* other properties that create stacking contexts:
opacity < 1, transform, filter, will-change, isolation: isolate */
.isolated { isolation: isolate; }Shorthand inset
inset é o shorthand lógico de top, right, bottom e left — como margin/padding, aceita 1, 2 ou 4 valores. inset: 0 estica um elemento absolutamente posicionado para preencher seu containing block. É mais limpo que declarar quatro propriedades separadas e combina bem com margin: auto para centralizar.
/* inset sets top right bottom left (like margin) */
.popup {
position: absolute;
inset: 0; /* all sides = 0 (stretches to fill parent) */
}
/* two values: vertical horizontal */
.pill {
position: absolute;
inset: 10px 20px; /* top/bottom 10px, left/right 20px */
}
/* four values: top right bottom left */
.box {
position: absolute;
inset: 10px 20px 30px 40px;
}
/* longhand equivalents */
.inset-longhand {
position: absolute;
top: 0; right: 0; bottom: 0; left: 0;
}Estilização de texto
Propriedades de fonte
font-family deve sempre terminar com uma família genérica (serif, sans-serif, monospace) como último recurso. font-weight varia de 100-900; comuns: 400 normal, 700 bold. line-height é melhor sem unidade (1.5) para escalar com o font-size. O shorthand font exige size e family; a ordem é style weight size/line-height family.
body {
font-family: "Helvetica Neue", Arial, sans-serif; /* fallback chain */
font-size: 16px;
font-weight: 400; /* 100-900; 400=normal, 700=bold */
font-style: italic; /* normal | italic | oblique */
line-height: 1.5; /* unitless = multiplier of font-size */
letter-spacing: 0.5px;
word-spacing: 2px;
font-variant: small-caps;
}
/* shorthand: style weight size/line-height family (order matters) */
p { font: italic 700 16px/1.5 "Georgia", serif; }Formatação de texto
text-align: justify pode criar rios de espaço em branco; pareie com hyphens: auto para blocos mais limpos. text-decoration agora aceita line, style e color num único shorthand. text-transform: capitalize capitaliza cada palavra. white-space: nowrap impede a quebra de linha. text-shadow recebe offset-x offset-y blur cor.
.text {
text-align: justify; /* left | right | center | justify */
text-decoration: underline wavy red; /* line style color */
text-decoration: line-through;
text-transform: uppercase; /* lowercase | capitalize */
text-indent: 2em; /* first-line indent */
white-space: nowrap; /* prevent wrapping */
word-break: break-word; /* break long words */
hyphens: auto; /* auto-hyphenate (needs lang attr) */
text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
}Overflow de texto e reticências
Truncamento de linha única precisa de três propriedades: white-space: nowrap, overflow: hidden, text-overflow: ellipsis. Para truncamento multilinha, use -webkit-line-clamp com display: -webkit-box (ainda precisa do prefixo -webkit- mas funciona nos navegadores modernos). Um max-width ou width é necessário para o truncamento disparar.
.truncate {
/* three properties required for ellipsis */
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis; /* clip | ellipsis */
max-width: 200px;
}
/* multi-line clamp (line-clamp) */
.clamp {
display: -webkit-box;
-webkit-line-clamp: 3; /* limit to 3 lines */
-webkit-box-orient: vertical;
overflow: hidden;
}
/* custom fade effect */
.fade {
-webkit-mask-image: linear-gradient(to bottom, black 70%, transparent);
}text-shadow e efeitos
text-shadow recebe offset-x offset-y blur-radius cor. Múltiplas sombras se empilham, com a primeira por cima — útil para brilhos neon ou contornos de texto (uma sombra em 4 direções imita um contorno). Diferente de -webkit-text-stroke, text-shadow é suportado universalmente. Sombras duras (sem blur) criam uma estética retrô, tipo adesivo.
/* x-offset y-offset blur color */
.shadow { text-shadow: 2px 2px 4px rgba(0,0,0,0.3); }
/* multiple shadows (first = top) */
.neon { text-shadow: 0 0 10px #fff, 0 0 20px #fff, 0 0 30px #0ff; }
/* 3D letterpress effect */
.letterpress { text-shadow: 0 1px 0 rgba(255,255,255,0.5); }
/* outline text (no blur, light color) */
.outline { text-shadow: -1px -1px 0 #000, 1px -1px 0 #000, -1px 1px 0 #000, 1px 1px 0 #000; }
/* hard shadow retro effect */
.retro { text-shadow: 4px 4px 0 #ff6b6b; }Writing modes e direção
writing-mode controla a direção do texto: horizontal-tb (padrão), vertical-rl (por exemplo, chinês/japonês tradicionais) ou vertical-lr. direction: rtl trata línguas da direita para a esquerda como o árabe. Propriedades lógicas (margin-inline-start, padding-block, inset-inline-end) se adaptam automaticamente ao writing mode e à direção — essenciais para layouts verdadeiramente internacionais e agnósticos de direção.
/* horizontal (default) */
.horizontal { writing-mode: horizontal-tb; }
/* vertical, top to bottom */
.vertical-rl { writing-mode: vertical-rl; }
.vertical-lr { writing-mode: vertical-lr; }
/* text direction */
.rtl { direction: rtl; unicode-bidi: bidi-override; }
/* logical properties adapt to writing mode */
.box {
margin-inline-start: 10px; /* logical left in LTR */
padding-block: 20px; /* logical top/bottom */
inset-inline-end: 0; /* logical right in LTR */
}Fundos e gradientes
Shorthand background
O shorthand background aceita todas as propriedades de fundo. Ao usar position e size juntos, separe-os com uma barra (center/cover). Múltiplos fundos se empilham separados por vírgula, o primeiro declarado = o de cima. Uma cor sólida deve sempre vir por último como fallback. Use cover para preencher a caixa e contain para caber a imagem inteira.
.box {
/* longhand */
background-color: #fff;
background-image: url("bg.png");
background-repeat: no-repeat;
background-position: center;
background-size: cover;
background-attachment: fixed;
/* shorthand (color image position/size repeat attachment) */
background: #fff url("bg.png") center/cover no-repeat fixed;
}
/* multiple backgrounds (first = top layer) */
.multi {
background: url("top.png") top left/contain no-repeat,
url("bottom.png") bottom right/cover no-repeat #eee;
}Gradientes lineares
linear-gradient(direction, color-stops) cria uma transição suave. A direção pode ser uma palavra-chave (to right) ou um ângulo (45deg). Os stops podem incluir posições em porcentagens — colocar dois stops na mesma posição cria uma borda dura (ótimo para listras). Gradientes são imagens, então vão em background-image, e podem ser usados onde quer que imagens sejam aceitas.
/* direction or angle, then color stops */
.gradient { background: linear-gradient(to right, red, blue); }
.gradient-45 { background: linear-gradient(45deg, red, blue); }
/* multiple color stops */
.rainbow { background: linear-gradient(to right, red, orange, yellow, green, blue); }
/* color stops with positions */
.hard-stop { background: linear-gradient(to right, red 0%, red 50%, blue 50%, blue 100%); }
/* transparent stops for fade effects */
.fade { background: linear-gradient(to bottom, rgba(0,0,0,0.5), transparent); }Gradientes radiais e cônicos
radial-gradient irradia de um ponto central — útil para holofotes e botões. Você pode posicionar o centro (at top left) e controlar forma/tamanho (circle, closest-side). conic-gradient gira as cores em torno de um ponto — perfeito para gráficos de pizza e rodas de cores. Stops duros em gradientes cônicos criam fatias de pizza limpas.
/* radial: radiates from a center point */
.radial { background: radial-gradient(circle, red, blue); }
.radial-c { background: radial-gradient(circle at top left, #fff, #000); }
.radial-size { background: radial-gradient(closest-side, red, blue); }
/* conic: rotates around a center point */
.pie { background: conic-gradient(red 0% 30%, blue 30% 70%, green 70% 100%); }
/* conic with angle start */
.spin { background: conic-gradient(from 45deg, red, yellow, green, red); }background-clip e origin
background-clip controla até onde o fundo se estende: border-box (padrão, sob a borda), padding-box (dentro da borda) ou content-box (dentro do padding). O truque de manchete: background-clip: text com color: transparent preenche o texto com um gradiente ou imagem. Sempre inclua a versão com prefixo -webkit- para o Safari. background-origin define a área de posicionamento.
/* clip: where the background paints */
.border-box { background-clip: border-box; } /* default - under border */
.padding-box { background-clip: padding-box; } /* inside border */
.content-box { background-clip: content-box; } /* inside padding */
/* text clip: gradient-filled text */
.gradient-text {
background: linear-gradient(to right, red, blue);
-webkit-background-clip: text;
background-clip: text;
color: transparent;
-webkit-text-fill-color: transparent;
}
/* origin: where positioning starts */
.origin { background-origin: content-box; }Attachment de fundo e parallax
background-attachment: fixed cria um efeito parallax — o fundo fica fixo enquanto o conteúdo rola sobre ele. scroll (padrão) se move com o elemento; local rola com o conteúdo do elemento (útil para caixas roláveis). Fixed attachment é irregular e mal suportado no mobile; para parallax em produção, use transform: translate3d baseado na posição de rolagem.
/* fixed: background stays put during scroll (parallax) */
.parallax {
background-image: url("hero.jpg");
background-attachment: fixed;
background-size: cover;
height: 100vh;
}
/* scroll: scrolls with element (default) */
.scroll { background-attachment: scroll; }
/* local: scrolls with element's content */
.local {
background-attachment: local; /* scrolls with inner content */
}
/* NOTE: background-attachment: fixed has poor mobile support
prefer transform-based parallax for mobile */Bordas e cantos arredondados
border-radius
border-radius arredonda cantos, aceitando 1-4 valores (sentido horário a partir do canto superior esquerdo). Uma barra separa os raios horizontal/vertical para cantos elípticos. border-radius: 50% num quadrado cria um círculo perfeito; num retângulo, uma elipse. Propriedades longhand (border-top-left-radius) controlam cantos individuais. Cantos arredondados cortam fundos, bordas e (com overflow: hidden) o conteúdo filho.
.box { border-radius: 10px; } /* all corners */
.box-2 { border-radius: 10px 20px; } /* top-left/bottom-right top-right/bottom-left */
.box-4 { border-radius: 10px 20px 30px 40px; } /* TL TR BR BL (clockwise) */
/* per-corner longhand */
.card {
border-top-left-radius: 10px;
border-top-right-radius: 20px;
border-bottom-right-radius: 30px;
border-bottom-left-radius: 40px;
}
/* elliptical corners (horizontal / vertical) */
.ellipse { border-radius: 50px / 25px; }
/* perfect circle (square element) */
.circle { border-radius: 50%; }border-image
border-image fatia uma imagem em 9 regiões e aplica os cantos/arestas a uma borda. border-image-slice divide a imagem de origem; repeat controla como as arestas se repetem. Um truque moderno comum: usar border-image com um linear-gradient e slice 1 para criar bordas com gradiente. Nota: border-image substitui border-style, então defina border-width antes.
.frame {
border: 20px solid transparent;
border-image-source: url("frame.png");
border-image-slice: 30; /* slice image into 9 regions */
border-image-width: 20px;
border-image-outset: 0;
border-image-repeat: stretch; /* stretch | repeat | round | space */
}
/* shorthand */
.frame-shorthand {
border: 20px solid transparent;
border-image: url("frame.png") 30 stretch;
}
/* gradient border (using border-image) */
.grad-border {
border: 4px solid;
border-image: linear-gradient(to right, red, blue) 1;
}Múltiplas bordas
CSS não consegue empilhar várias propriedades border, mas há alternativas. box-shadow com offset zero e spread cria bordas externas nítidas (funciona com border-radius). outline desenha uma segunda borda por fora, mas ignora border-radius. Um pseudo-elemento dá controle total, inclusive do raio. Cada técnica tem tradeoffs — escolha conforme precisar de cantos arredondados.
/* technique 1: box-shadow (no rounded issue) */
.multi-shadow {
box-shadow: 0 0 0 5px red, 0 0 0 10px blue;
}
/* technique 2: outline (outside border, no radius) */
.outline-border {
border: 5px solid red;
outline: 5px solid blue;
outline-offset: 0;
}
/* technique 3: pseudo-element (full control) */
.pseudo-border {
position: relative;
border: 5px solid red;
}
.pseudo-border::after {
content: "";
position: absolute;
inset: -10px;
border: 5px solid blue;
border-radius: inherit;
}Bordas com gradiente
Bordas com gradiente são complicadas porque border-image não suporta border-radius. A solução robusta: empilhar dois fundos — uma cor sólida cortada em padding-box e um gradiente cortado em border-box, com uma borda transparente. Isso respeita o border-radius e funciona nos lugares. A função mais simples com border-image funciona quando você não precisa de cantos arredondados.
/* method 1: border-image (works but no border-radius) */
.grad-1 {
border: 4px solid;
border-image: linear-gradient(to right, red, blue) 1;
}
/* method 2: background-clip trick (works with radius) */
.grad-2 {
border: 4px solid transparent;
border-radius: 12px;
background:
linear-gradient(white, white) padding-box,
linear-gradient(to right, red, blue) border-box;
}
/* method 3: mask + pseudo (advanced, supports radius + animation) */Outline e estilos de foco
outline desenha fora da borda e não afeta o layout, tornando-o ideal para indicadores de foco. outline-offset adiciona um espaço. Regra crítica de acessibilidade: nunca defina outline: none sem uma alternativa visível. :focus-visible mostra o contorno apenas para navegação por teclado (não cliques de mouse) — a abordagem moderna e amigável para estilização de foco.
/* outline: doesn't affect layout, draws outside border */
.focusable:focus {
outline: 2px solid blue;
outline-offset: 2px; /* gap between element and outline */
}
/* never use outline: none without a replacement */
button:focus { outline: none; box-shadow: 0 0 0 3px rgba(0,150,255,0.5); }
/* :focus-visible: only shows outline for keyboard users */
button:focus-visible { outline: 2px solid blue; outline-offset: 2px; }
button:focus:not(:focus-visible) { outline: none; }
/* outline shorthand */
.box { outline: 2px dashed red; }Transforms
Transforms 2D
Transforms 2D — translate, rotate, scale, skew — movem e distorcem elementos sem afetar o layout (irmãos não refluem). Transforms combinados aplicam da direita para a esquerda, então a ordem importa: rotate antes de translate move ao longo do eixo rotacionado. Como transforms não disparam reflow, são ideais para animações e são acelerados por GPU.
.box { transform: translate(50px, 20px); } /* move right 50, down 20 */
.box-x { transform: translateX(50px); }
.box-scale { transform: scale(1.5); } /* grow 1.5x */
.box-scale-2 { transform: scale(1, 2); } /* x 1, y 2 */
.box-rotate { transform: rotate(45deg); } /* clockwise */
.box-skew { transform: skew(20deg, 10deg); } /* skew x, y */
/* combine transforms (order matters!) */
.combo { transform: translate(20px, 0) rotate(45deg) scale(1.2); }
/* transform does NOT affect layout (no reflow) */transform-origin
transform-origin define o ponto de pivô dos transforms — o padrão é o centro do elemento. Aceita palavras-chave (top left), pixels ou porcentagens. Mudar a origem altera drasticamente o comportamento de rotação e escala: um card que vira pela borda superior precisa de transform-origin: top. Para transforms 3D, um terceiro valor do eixo z pode ser especificado.
.box { transform: rotate(45deg); }
/* default origin: center center (50% 50%) */
.center { transform-origin: center center; }
/* rotate around top-left corner */
.tl { transform-origin: top left; transform: rotate(45deg); }
/* custom point (x y) */
.custom { transform-origin: 20px 50px; transform: rotate(45deg); }
/* 3-value form (x y z) */
.three-d { transform-origin: 0 0 100px; }
/* percentage-based */
.pct { transform-origin: 100% 0; } /* top-right corner */Transforms 3D
Transforms 3D adicionam rotateX, rotateY, rotateZ, translateZ e scaleZ. perspective(n) deve ser aplicada como primeira função de transform (ou no pai) para habilitar profundidade — valores menores exageram o efeito 3D. translate3d e scale3d são acelerados por GPU e têm melhor desempenho em animações que suas contrapartes 2D.
.card { transform: perspective(1000px) rotateY(45deg); }
/* rotateX/Y/Z - rotate around 3D axes */
.flip { transform: rotateX(180deg); } /* flip horizontally */
.turn { transform: rotateY(180deg); } /* flip like a page */
.spin { transform: rotateZ(90deg); } /* same as rotate() */
/* translate3d (GPU-accelerated) */
.move { transform: translate3d(50px, 20px, 100px); }
/* scale3d */
.grow { transform: scale3d(1.5, 1.5, 1.5); }
/* combined 3D */
.combo-3d { transform: perspective(800px) rotateX(15deg) rotateY(-20deg) translateZ(-50px); }Perspective e espaço 3D
perspective define a distância do observador — menor = 3D mais dramático. Coloque no pai para que os filhos compartilhem o mesmo ponto de fuga. transform-style: preserve-3d permite que elementos aninhados vivam num espaço 3D compartilhado (essencial para construir cubos). backface-visibility: hidden oculta o verso de um elemento — chave para efeitos de card que gira.
/* perspective on parent: applies to all children uniformly */
.scene { perspective: 1000px; }
.cube { transform: rotateY(45deg); }
/* perspective() in transform: only affects that element */
.solo { transform: perspective(1000px) rotateY(45deg); }
/* perspective-origin: vanishing point */
.scene { perspective: 1000px; perspective-origin: top left; }
/* transform-style: preserve-3d lets children share 3D space */
.cube {
transform-style: preserve-3d;
transform: rotateY(30deg);
}
.cube .face { position: absolute; transform: translateZ(50px); }
/* backface-visibility: hide back of flipped element */
.card { backface-visibility: hidden; }Animando transforms (desempenho)
Sempre anime transform e opacity — são acelerados por GPU e não disparam layout (reflow) nem paint. Animar top/left/width/margin força o navegador a recalcular o layout a cada frame, causando jank. will-change: transform dá uma dica ao navegador para preparar uma camada de compositor com antecedência, mas o uso excessivo desperdiça memória. Aplique logo antes de uma animação e remova depois.
/* GOOD: animate transform & opacity (GPU-accelerated) */
.smooth {
transition: transform 0.3s ease;
}
.smooth:hover { transform: translateY(-5px); }
/* BAD: animating top/left triggers reflow */
.janky { transition: top 0.3s; }
.janky:hover { top: -5px; }
/* will-change: hint the browser to optimize */
.prepared {
will-change: transform; /* prepare for upcoming transform changes */
}
/* force GPU layer (use sparingly) */
.gpu { transform: translateZ(0); }Transições
Shorthand transition
transition: propriedade duração timing-function delay. O padrão é all 0s ease 0s — então só escrever transition: 0.3s anima todas as propriedades alteradas. Por desempenho e controle, liste propriedades específicas. Múltiplas transições são separadas por vírgula. A transition vai no estado padrão do elemento (não no :hover), para que a animação reversa também aconteça.
.btn {
background: blue;
/* shorthand: property duration timing-function delay */
transition: background 0.3s ease 0s;
/* common usage */
transition: all 0.3s ease;
/* multiple properties (comma-separated) */
transition: background 0.3s, transform 0.2s ease-out;
/* list the same duration on many properties */
transition: 0.3s;
}
.btn:hover {
background: darkblue;
transform: scale(1.05);
}Funções de timing
Funções de timing controlam a aceleração. ease (padrão) é suave. ease-out parece a mais responsiva para UI (início rápido, fim lento). linear parece antinatural para a maioria dos movimentos. cubic-bezier(x1,y1,x2,y2) permite criar curvas personalizadas — valores fora de 0-1 no eixo y criam overshoot/bounce. steps(n) cria saltos discretos, úteis para animações de sprite-sheet.
.ease { transition: all 0.3s ease; } /* default, smooth start/end */
.linear { transition: all 0.3s linear; } /* constant speed */
.ease-in { transition: all 0.3s ease-in; } /* slow start */
.ease-out { transition: all 0.3s ease-out; } /* slow end (feels responsive) */
.ease-in-out { transition: all 0.3s ease-in-out; }/* slow both ends */
/* cubic-bezier: custom curve (P1x P1y P2x P2y) */
.custom { transition: all 0.3s cubic-bezier(0.68, -0.55, 0.27, 1.55); } /* overshoot */
/* steps: jump in increments */
.steps { transition: all 0.3s steps(4, end); }Transições múltiplas e escalonadas
Propriedades diferentes podem ter durações e delays diferentes — útil para efeitos coreografados em que uma propriedade termina antes de outra começar. transition-delay cria entradas escalonadas para listas; combine com nth-child para atrasar cada item progressivamente. Delays também funcionam para saídas, mas cuidado: se o usuário tirar o hover no meio do delay, a entrada pode se assentar de repente.
.card {
/* different durations per property */
transition: transform 0.2s ease-out, box-shadow 0.4s ease;
/* delay creates staggered effect */
transition: background 0.3s, color 0.3s 0.1s; /* color starts after 0.1s */
}
.card:hover {
transform: translateY(-4px);
box-shadow: 0 10px 30px rgba(0,0,0,0.2);
background: #f5f5f5;
}
/* stagger multiple elements via transition-delay */
.item:nth-child(1) { transition-delay: 0s; }
.item:nth-child(2) { transition-delay: 0.1s; }
.item:nth-child(3) { transition-delay: 0.2s; }Propriedades transicionáveis
Algumas propriedades transicionam suavemente; outras causam jank. As estrelas aceleradas por GPU são transform, opacity e filter. Cores e box-shadow são aceitáveis (disparam paint, não layout). Evite transicionar width, height, margin, top, left — forçam recálculo de layout a cada frame. Para animar uma mudança de tamanho, use transform: scale().
/* WELL-SUPPORTED & performant */
.good {
transition: transform 0.3s, opacity 0.3s, filter 0.3s;
}
/* OK but may trigger paint */
.okay {
transition: background-color 0.3s, color 0.3s, border-color 0.3s;
transition: box-shadow 0.3s;
}
/* AVOID: triggers layout (reflow) - janky */
.bad {
transition: width 0.3s, height 0.3s, margin 0.3s, top 0.3s, left 0.3s;
}
/* if you must animate size, use transform: scale() instead */
.smooth-resize { transition: transform 0.3s; }Gatilhos de transição
Transições disparam em qualquer mudança de propriedade: estados de pseudo-classe (:hover, :focus, :checked), mudanças de classe (adicionadas/removidas por JS) e mudanças de media query. Elas interpolam entre os valores antigo e novo suavemente. Transições só rodam a caminho do novo estado — ambas as direções (entrada/saída) animam. Para movimento mais complexo, em loop ou em múltiplos passos, use animações @keyframes.
/* hover trigger */
.btn { transition: all 0.3s; }
.btn:hover { transform: scale(1.1); }
/* focus trigger (accessibility-friendly) */
.input { transition: border-color 0.2s; }
.input:focus { border-color: blue; }
/* class change via JavaScript */
.modal { transition: opacity 0.3s; opacity: 0; }
.modal.open { opacity: 1; }
/* media query trigger */
.box { transition: width 0.3s; width: 100%; }
@media (min-width: 768px) { .box { width: 50%; } }
/* CSS state triggers (:checked) */
.toggle:checked + .menu { transition: max-height 0.3s; max-height: 500px; }Animações
@keyframes
@keyframes define a sequência de uma animação. Os stops podem ser porcentagens (0%, 50%, 100%) ou from/to (equivalentes a 0%/100%). Propriedades não listadas num stop interpolam entre os stops definidos. Só propriedades animáveis (transform, opacity, cores) funcionam — display, position etc. não. Defina @keyframes uma vez e reutilize em muitos elementos.
@keyframes bounce {
0% { transform: translateY(0); }
50% { transform: translateY(-30px); }
100% { transform: translateY(0); }
}
/* from/to shorthand (2-stop) */
@keyframes fadeIn {
from { opacity: 0; }
to { opacity: 1; }
}
/* multiple properties at each stop */
@keyframes pulse {
0% { opacity: 1; transform: scale(1); }
50% { opacity: 0.5; transform: scale(1.1); }
100% { opacity: 1; transform: scale(1); }
}Shorthand animation
O shorthand animation comprime 8 propriedades nesta ordem: name duration timing-function delay iteration-count direction fill-mode play-state. No mínimo você precisa de name e duration. Nota: ambiguidade de valor de tempo sem unidade — o primeiro tempo é duration, o segundo é delay. Para legibilidade em produção, prefira longhand ou shorthand parcial.
.bouncing {
/* longhand */
animation-name: bounce;
animation-duration: 1s;
animation-timing-function: ease-in-out;
animation-delay: 0s;
animation-iteration-count: infinite;
animation-direction: alternate;
animation-fill-mode: both;
animation-play-state: running;
/* shorthand: name duration timing delay count direction fill-mode play-state */
animation: bounce 1s ease-in-out 0s infinite alternate both running;
/* minimal: name + duration */
animation: bounce 1s;
}Iteração e direção
animation-iteration-count controla a repetição — infinite faz loop para sempre, valores fracionários reproduzem ciclos parciais. animation-direction: alternate reproduz a animação para frente e depois para trás na próxima iteração, criando um bounce contínuo. reverse reproduz para trás, e alternate-reverse começa para trás. Alternate é essencial para movimentos de ping-pong como pulsos ou efeitos de respiração.
/* iteration-count: how many times to play */
.once { animation-iteration-count: 1; } /* default */
.thrice { animation-iteration-count: 3; }
.forever { animation-iteration-count: infinite; }
.fractional { animation-iteration-count: 0.5; } /* half a play */
/* direction */
.normal { animation-direction: normal; } /* 0% -> 100% */
.reverse { animation-direction: reverse; } /* 100% -> 0% */
.alternate { animation-direction: alternate; } /* forward, then backward */
.alternate-rev { animation-direction: alternate-reverse; }Animation fill mode
animation-fill-mode controla os estilos antes e depois da animação rodar. none (padrão) volta aos estilos normais do elemento. forwards mantém o estado do keyframe final após terminar — essencial para animações de entrada, para que os elementos não voltem de repente. backwards aplica o primeiro keyframe durante o delay. both cobre os dois casos. Use forwards ou both para entradas de uso único.
@keyframes slideIn {
from { transform: translateX(-100%); }
to { transform: translateX(0); }
}
/* none (default): reverts to original styles before/after */
.none { animation: slideIn 1s; }
/* forwards: holds the final (to) state after finishing */
.forwards { animation: slideIn 1s forwards; }
/* backwards: applies the (from) state during delay */
.backwards { animation: slideIn 1s 0.5s backwards; }
/* both: applies from during delay AND holds to after */
.both { animation: slideIn 1s 0.5s both; }Play state e pausa
animation-play-state: paused congela uma animação no frame atual; running a retoma. Essa é a forma mais limpa de pausar no hover ou via classe alternada por JS — a animação lembra sua posição em vez de reiniciar. Por desempenho, pause animações em elementos que saem da tela usando IntersectionObserver. Combine com media queries de reduced-motion por acessibilidade.
.anim { animation: spin 2s linear infinite; }
/* pause on hover */
.anim:hover { animation-play-state: paused; }
/* pause via class (JS toggle) */
.anim.paused { animation-play-state: paused; }
/* useful for performance: pause off-screen animations */
.offscreen { animation-play-state: paused; }
/* resume */
.resumed { animation-play-state: running; }Media queries
Sintaxe básica
Media queries aplicam estilos condicionalmente. (min-width: 768px) é mobile-first — aplica em telas de 768px para cima. Combine com and (ambos devem casar), vírgulas (OU) e not (negação). A abordagem mobile-first (min-width) é a preferida: escreva estilos base para telas pequenas, depois aprimore para as maiores. Isso mantém o CSS de telas pequenas enxuto.
/* apply styles when viewport is at least 768px wide */
@media (min-width: 768px) {
.grid { grid-template-columns: repeat(2, 1fr); }
}
/* combine conditions with and */
@media (min-width: 768px) and (max-width: 1024px) {
.box { padding: 20px; }
}
/* list of queries (OR) */
@media (max-width: 600px), (min-width: 1200px) {
.text { font-size: 14px; }
}
/* negate with not */
@media not print {
.screen-only { display: block; }
}Breakpoints de min/max width
Breakpoints devem se basear no conteúdo, não em dispositivos específicos, mas faixas comuns funcionam bem: 640px (tablet), 1024px (desktop), 1280px (grande). Mobile-first significa usar min-width e escrever os estilos mobile como base. A sintaxe de faixa mais nova (width >= 768px) é mais legível e suportada nos navegadores modernos, substituindo combinações verbosas de min/max.
/* common breakpoints (mobile-first) */
/* base styles (mobile) */
.container { padding: 16px; }
@media (min-width: 640px) { /* small tablets */
.container { padding: 24px; }
}
@media (min-width: 1024px) { /* desktops */
.container { padding: 32px; max-width: 1200px; margin: 0 auto; }
}
@media (min-width: 1280px) { /* large screens */
.container { max-width: 1400px; }
}
/* range syntax (newer, cleaner) */
@media (width >= 768px) and (width <= 1024px) {
.box { padding: 20px; }
}Orientação e aspect ratio
Além da largura, media queries podem mirar orientação (portrait/landscape), aspect-ratio, capacidade de hover e tipo de ponteiro. @media (hover: hover) garante que estilos de hover só apliquem em dispositivos com ponteiro real (evitando hover pegajoso no touch). (pointer: coarse) mira dispositivos de toque — perfeito para ampliar alvos de toque. Esses recursos habilitam interfaces realmente adequadas ao dispositivo.
/* portrait vs landscape */
@media (orientation: portrait) {
.grid { grid-template-columns: 1fr; }
}
@media (orientation: landscape) {
.grid { grid-template-columns: 1fr 1fr; }
}
/* aspect ratio */
@media (min-aspect-ratio: 16/9) {
.video { width: 100%; height: auto; }
}
/* hover capability: devices that support hover */
@media (hover: hover) {
.btn:hover { background: darkblue; }
}
/* pointer: fine (mouse) vs coarse (touch) */
@media (pointer: coarse) {
.btn { padding: 16px 32px; } /* bigger tap targets */
}Estilos de impressão
Media queries de impressão estilizam como as páginas aparecem quando impressas. Oculte navegação, anúncios e elementos interativos; expanda o conteúdo para largura total; force preto no branco para economizar tinta. break-inside: avoid impede que elementos se dividam entre páginas, e break-before: page força quebras de página. O truque ::after em links revela as URLs na impressão — valioso para artigos imprimíveis.
@media print {
/* hide non-essential UI */
.nav, .sidebar, .ads, .comments { display: none; }
/* expand main content */
.main { width: 100%; margin: 0; }
/* force black text on white */
body { color: black; background: white; }
/* avoid breaking inside elements */
h1, h2, img, table { break-inside: avoid; }
/* page breaks before sections */
h1 { break-before: page; }
/* show URLs after links */
a[href]::after { content: " (" attr(href) ")"; }
}prefers-reduced-motion e color-scheme
prefers-reduced-motion é um recurso crítico de acessibilidade — usuários com distúrbios vestibulares precisam de movimento minimizado. Sempre forneça um fallback de movimento reduzido que desabilite ou encurte animações. prefers-color-scheme permite se adaptar automaticamente ao tema do SO do usuário. Para modo escuro, considere também contraste, imagens e sombras que funcionem em fundos escuros.
/* respect users who prefer less motion */
@media (prefers-reduced-motion: reduce) {
*, *::before, *::after {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
scroll-behavior: auto !important;
}
}
/* light/dark mode */
@media (prefers-color-scheme: dark) {
body { background: #1a1a1a; color: #eee; }
.card { background: #2a2a2a; }
}
@media (prefers-color-scheme: light) {
body { background: white; color: #333; }
}Design responsivo
Tipografia fluida com clamp()
clamp(min, preferido, max) cria valores que escalam fluidamente entre limites — perfeito para tipografia e espaçamento que se adaptam sem media queries. O valor preferido costuma ser uma expressão baseada em vw. Isso elimina muitos breakpoints. Pareie com rem por acessibilidade (usuários ainda podem escalar o font-size raiz). Tipografia fluida melhora a percepção de desempenho e a legibilidade entre dispositivos.
/* clamp(min, preferred, max) - fluid between bounds */
h1 {
/* scales from 1.5rem to 3rem as viewport grows */
font-size: clamp(1.5rem, 5vw, 3rem);
}
p {
/* readable body text on any screen */
font-size: clamp(1rem, 2.5vw, 1.25rem);
}
/* fluid spacing */
.section {
padding: clamp(1rem, 4vw, 3rem);
}
/* fluid container width */
.container {
width: clamp(280px, 90vw, 1200px);
margin: 0 auto;
}Abordagem mobile-first
Mobile-first significa escrever os estilos de telas pequenas como base, depois usar media queries min-width para aprimorar para telas maiores. Isso produz CSS mais enxuto (o mobile baixa só o que precisa) e força uma mentalidade de priorização de conteúdo. Desktop-first (max-width) força dispositivos móveis a baixar e sobrescrever estilos de desktop — mais lento e mais difícil de manter.
/* base = mobile styles (no media query) */
.card {
width: 100%;
padding: 12px;
font-size: 14px;
}
/* progressively enhance for larger screens */
@media (min-width: 640px) {
.card { width: 50%; padding: 16px; }
}
@media (min-width: 1024px) {
.card { width: 33.33%; padding: 24px; font-size: 16px; }
}
/* AVOID desktop-first (forces mobile to override) */
/* @media (max-width: 640px) { ... } */Container queries
Container queries mudam o jogo: permitem que componentes respondam ao tamanho do pai, não da viewport. Um card pode adaptar seu layout tanto numa sidebar estreita quanto numa área principal larga — responsividade verdadeira no nível do componente. container-type: inline-size consulta a largura (o mais performático). Nomeie containers para mirá-los especificamente, ou use queries sem nome para o ancestral mais próximo.
/* make an element a query container */
.sidebar {
container-type: inline-size;
container-name: sidebar;
}
/* styles based on the container's size, not the viewport */
@container sidebar (min-width: 400px) {
.card {
grid-template-columns: 1fr 1fr;
}
}
/* inline-size = width only (most common, performant) */
/* size = both dimensions (more expensive) */
/* unnamed container query (uses nearest ancestor) */
.card-wrap { container-type: inline-size; }
@container (min-width: 500px) {
.card { flex-direction: row; }
}Unidades de viewport
vh/vw são porcentagens da viewport. O problema: 100vh no mobile muda conforme a barra de endereço aparece/some, causando jank. As unidades mais novas svh/lvh/dvh resolvem isso — dvh atualiza dinamicamente, svh usa o menor valor estável. vmin/vmax são a menor/maior dimensão da viewport — ótimo para elementos quadrados que escalam. Sempre pareie tamanhos de fonte em vw com um piso em rem/px via calc ou clamp.
.hero {
height: 100vh; /* full viewport height */
/* small viewport units: account for mobile browser chrome */
height: 100svh; /* smallest possible viewport (stable) */
height: 100lvh; /* largest possible viewport */
height: 100dvh; /* dynamic - updates as chrome shows/hides */
}
.full-width { width: 100vw; }
.responsive-font { font-size: 5vw; }
/* vmin/vmax: smaller/larger of width or height */
.square { width: 50vmin; height: 50vmin; }
.banner { height: 30vmax; }
/* combining with calc for safety */
.hero-text { font-size: calc(16px + 2vw); }aspect-ratio
aspect-ratio mantém uma proporção largura:altura automaticamente — acabaram os hacks de padding-top para vídeo responsivo. A altura do elemento deriva da largura (ou vice-versa). Combinado com object-fit: cover em imagens, evita deslocamento de layout conforme as imagens carregam. É a forma mais limpa de reservar espaço para mídia e evitar cumulative layout shift (CLS) — um Core Web Vital.
/* maintain a 16:9 ratio regardless of width */
.video {
aspect-ratio: 16 / 9;
width: 100%;
}
/* square avatar */
.avatar {
aspect-ratio: 1;
width: 80px;
border-radius: 50%;
}
/* golden ratio card */
.card {
aspect-ratio: 1.618;
}
/* combined with object-fit for responsive images */
.thumb {
aspect-ratio: 4 / 3;
width: 100%;
object-fit: cover;
}Custom properties (variáveis)
Definindo e usando variáveis
Custom properties CSS (variáveis) são declaradas com --name e usadas com var(--name). Defina-as em :root para acesso global, ou escopo-as a qualquer elemento. Diferente de variáveis de pré-processador, elas são vivas: mudar uma variável atualiza os usos em tempo real, e elas fazem cascata e herdam. var() aceita um fallback como segundo argumento, usado quando a variável é indefinida.
:root {
--primary: #3490dc;
--spacing: 16px;
--max-width: 1200px;
}
.button {
background: var(--primary);
padding: var(--spacing);
/* with fallback value (used if --primary undefined) */
color: var(--text-color, #333);
}
/* override in a specific scope */
.dark-theme {
--primary: #5a9fee;
}Temas e modo escuro
Custom properties tornam a tematização trivial: defina variáveis semânticas (--bg, --text, --primary), depois sobrescreva-as num seletor [data-theme]. Alternar o atributo data-theme no <html> troca o tema inteiro instantaneamente — sem folhas de estilo duplicadas. Combine com prefers-color-scheme para modo escuro automático que respeita a escolha manual do usuário. Essa é a forma moderna e performática de tematizar.
:root {
--bg: #ffffff;
--text: #1a1a1a;
--primary: #3490dc;
}
[data-theme="dark"] {
--bg: #1a1a1a;
--text: #ffffff;
--primary: #5a9fee;
}
body {
background: var(--bg);
color: var(--text);
}
/* auto dark mode via media query */
@media (prefers-color-scheme: dark) {
:root:not([data-theme="light"]) {
--bg: #1a1a1a;
--text: #ffffff;
}
}Cascata e herança
Custom properties fazem cascata e herdam como CSS normal. Uma variável definida em .card está disponível para .card e os descendentes — mas não para irmãos. Cada elemento lê o valor computado da variável no seu próprio escopo. @property (mais novo) permite declarar variáveis tipadas com uma syntax, valor inicial e flag de herança — habilitando transições e animações suaves de custom properties.
:root { --color: blue; } /* global */
.card { --color: green; } /* scoped to .card */
.card .inner { color: var(--color); } /* green - inherits from .card */
/* variables inherit like other properties */
.parent { --size: 20px; }
.child { font-size: var(--size); } /* 20px via inheritance */
/* but: each element reads its own computed value */
.a { --x: 10px; }
.b { /* --x is NOT defined here, even if .a is sibling */ }
/* @property: typed variables with initial value */
@property --angle {
syntax: "<angle>";
inherits: false;
initial-value: 0deg;
}Interação com JavaScript
Variáveis CSS são totalmente acessíveis do JavaScript. Leia com getComputedStyle(el).getPropertyValue('--name') (retorna uma string, frequentemente com espaço inicial — faça trim). Defina com el.style.setProperty('--name', value). Isso faz das custom properties uma ponte poderosa de JS para CSS: atualize uma variável em JS e o CSS reage instantaneamente — perfeito para efeitos dirigidos por rolagem, temas e layouts dinâmicos.
/* read a variable */
const styles = getComputedStyle(document.documentElement);
const primary = styles.getPropertyValue("--primary"); /* "#3490dc" */
/* set a variable globally */
document.documentElement.style.setProperty("--primary", "#ff0000");
/* set on a specific element */
el.style.setProperty("--spacing", "24px");
/* inline style with variable */
<div style="--rotate: 45deg"></div>
/* useful pattern: expose JS values to CSS */
.root { --scroll: 0; }
.box { transform: rotate(calc(var(--scroll) * 1deg)); }Fallbacks e encadeamento
var() suporta um fallback como segundo argumento, usado apenas quando a variável é indefinida (não quando é inválida — valores inválidos fazem a propriedade inteira voltar ao seu default). Fallbacks podem se encadear: var(--a, var(--b, #default)). Isso é útil para progressive enhancement e integração de componentes de terceiros. Use @supports (--x: 0) para detectar suporte, embora os navegadores modernos suportem custom properties.
.box {
/* single fallback */
color: var(--undefined, #333);
/* chained: try --primary, fall back to --blue, then #00f */
color: var(--primary, var(--blue, #0000ff));
/* fallback in calc() */
width: calc(100% - var(--sidebar, 250px));
/* invalid values fall back to inherited/default */
/* var() itself doesn't fail — the property does */
}
/* feature detection for custom property support */
@supports (--custom: property) {
:root { --modern: true; }
}Filtros
Funções de filtro
filter aplica efeitos visuais a um elemento. brightness/contrast/saturate recebem multiplicadores (1 = normal) ou porcentagens. hue-rotate desloca os matizes por um ângulo. Múltiplos filtros se encadeiam da esquerda para a direita. Uso comum: imagens em tons de cinza no hover, efeitos de foto vintage ou escurecimento de fundos. Filtros afetam o elemento, seu fundo, bordas e filhos.
.blur { filter: blur(4px); } /* gaussian blur in px */
.bright { filter: brightness(1.5); } /* 1 = normal, >1 brighter */
.contrast { filter: contrast(200%); } /* 100% = normal */
.gray { filter: grayscale(100%); } /* 0-100% */
.sepia { filter: sepia(80%); }
.hue { filter: hue-rotate(90deg); } /* rotate hue */
.invert { filter: invert(100%); } /* invert colors */
.saturate { filter: saturate(2); } /* 1 = normal */
.opacity { filter: opacity(50%); }
/* combine multiple filters (left-to-right) */
.vintage { filter: sepia(60%) contrast(110%) brightness(90%) saturate(1.2); }drop-shadow
drop-shadow é o equivalente em filtro do box-shadow — mas segue a forma real de alpha do elemento, não sua caixa. Isso significa que sombras abraçam recortes de PNG/SVG e formas irregulares. Use para sombras de ícones, logos brilhantes ou qualquer elemento não retangular. Múltiplos drop-shadows podem ser empilhados. Nota: pode ser mais caro que box-shadow, então use com discernimento.
/* drop-shadow follows the alpha shape (unlike box-shadow) */
.cutout {
filter: drop-shadow(4px 4px 8px rgba(0,0,0,0.4));
}
/* shadows on PNG with transparency - hugs the shape */
.logo {
filter: drop-shadow(0 4px 6px rgba(0,0,0,0.3));
}
/* glow effect on text or SVG */
.icon {
filter: drop-shadow(0 0 8px rgba(0, 150, 255, 0.8));
}
/* multiple drop-shadows layer */
.deep {
filter: drop-shadow(0 1px 1px rgba(0,0,0,0.5))
drop-shadow(0 2px 4px rgba(0,0,0,0.3));
}backdrop-filter
backdrop-filter aplica um filtro a tudo atrás de um elemento — a assinatura do glassmorphism. Um fundo semitransparente mais backdrop-filter: blur() cria o visual de vidro fosco. Sempre inclua o prefixo -webkit- para o Safari. O elemento precisa de alguma transparência no fundo para o efeito aparecer. Combine com saturate() para resultados vibrantes, e adicione uma borda sutil para simular reflexo de borda.
/* frosted glass effect */
.glass {
background: rgba(255, 255, 255, 0.2);
backdrop-filter: blur(10px);
-webkit-backdrop-filter: blur(10px); /* Safari */
border: 1px solid rgba(255, 255, 255, 0.3);
}
/* saturate + blur for vivid glass */
.vivid-glass {
backdrop-filter: blur(16px) saturate(180%);
}
/* dark glass for dark mode */
.dark-glass {
background: rgba(0, 0, 0, 0.3);
backdrop-filter: blur(12px);
}Combinando filtros
Múltiplos filtros se aplicam da esquerda para a direita, então a ordem afeta o resultado (grayscale antes de hue-rotate não tem nada para rotacionar, por exemplo). Filtros são animáveis e acelerados por GPU — ótimos para efeitos de hover. Pareie filter com mix-blend-mode para misturar um elemento com seu fundo. Para controle dinâmico, guarde a cadeia de filtros numa custom property e atualize via JS.
/* order matters: each filter feeds the next */
.artsy {
filter: grayscale(100%) contrast(150%) brightness(110%);
}
/* animate filters smoothly */
img { transition: filter 0.3s; }
img:hover { filter: grayscale(0%) saturate(1.4); }
/* use CSS variables for dynamic filters */
.dynamic { filter: var(--photo-filter, none); }
/* layer with other effects */
.complex {
filter: blur(1px) brightness(1.1);
mix-blend-mode: multiply;
opacity: 0.9;
}Desempenho de filtros
Filtros são acelerados por GPU, mas não são grátis. Blurs grandes em elementos de tela cheia causam repaints pesados e jank, especialmente no mobile. Mantenha os raios de blur pequenos, limite a área filtrada e aplique will-change: filter antes de disparar animações. backdrop-filter é particularmente caro — use em pequenos elementos de UI, não em seções inteiras. contain: paint isola a área de repaint para melhor desempenho.
/* AVOID: large blur on full-screen elements */
.janky { filter: blur(20px); } /* causes repaints */
/* BETTER: pre-blurred image, or limit blur area */
.smooth {
filter: blur(2px); /* small radius is cheaper */
}
/* backdrop-filter is expensive - use sparingly */
/* contain: paint can limit repaint area */
.contained {
contain: paint;
backdrop-filter: blur(10px);
}
/* will-change prepares the GPU layer */
.prepared {
will-change: filter;
filter: blur(4px);
}Pseudo-elementos
::before e ::after
::before e ::after inserem conteúdo gerado antes/depois do conteúdo real de um elemento. A propriedade content é obrigatória (mesmo que string vazia para elementos decorativos). O conteúdo pode ser texto, Unicode escapado ou valores de atributos via attr(). Esses pseudo-elementos são inline por padrão — defina display: block para decoração em forma de caixa. Perfeitos para ícones, linhas decorativas, aspas e limpar floats.
.quote::before { content: "\201C"; } /* opening quote */
.quote::after { content: "\201D"; } /* closing quote */
/* icon via Unicode */
.warning::before { content: "\26A0"; margin-right: 6px; }
/* decorative element with content: "" */
.card::after {
content: "";
display: block;
width: 50px; height: 2px;
background: currentColor;
margin-top: 12px;
}
/* content can use attributes */
a[href^="http"]::after {
content: " (" attr(href) ")";
font-size: 0.8em;
}::first-letter e ::first-line
::first-letter estiliza o primeiro caractere — perfeito para capitulares em artigos. ::first-line estiliza a primeira linha formatada, que se ajusta dinamicamente conforme a viewport muda de largura. Ambos só funcionam em elementos block-level. Note que ::first-letter só se aplica quando o primeiro caractere não é precedido por outro conteúdo (como imagens). São essenciais de tipografia para layouts editoriais.
article p::first-letter {
font-size: 3em;
font-weight: bold;
float: left;
line-height: 0.8;
margin-right: 8px;
/* drop cap effect */
}
article p::first-line {
text-transform: uppercase;
letter-spacing: 1px;
font-weight: bold;
}
/* only works on block-level elements */
/* affects the first formatted line (reflows with width) */::selection
::selection estiliza a parte do texto que o usuário seleciona. Só um punhado de propriedades se aplica: color, background-color, text-shadow e text-decoration. Use para dar a cor de seleção a identidade do seu site. Aplique globalmente com ::selection ou escopo a elementos específicos. Firefox antigo precisava de ::-moz-selection, mas o Firefox moderno suporta o padrão ::selection.
/* style highlighted/selected text */
::selection {
background: #b3d4fc;
color: black;
text-shadow: none;
}
/* scoped to specific elements */
p::selection { background: yellow; }
.highlight::selection { background: gold; color: #333; }
/* note: only a few properties work:
color, background-color, text-shadow,
text-decoration (and its longhands) */
/* firefox historically used ::-moz-selection */::placeholder e ::marker
::placeholder estiliza o texto de placeholder em inputs de formulário — defina opacity: 1 porque o Firefox usa um placeholder translúcido por padrão. ::marker estiliza bullets ou números de list-item, e suporta um conjunto limitado de propriedades (color, content, font, direction). Você pode substituir bullets por conteúdo personalizado (Unicode, counters). Esses pseudo-elementos colocam a estilização de formulários e listas totalmente sob controle do designer.
/* style input placeholder text */
input::placeholder {
color: #999;
font-style: italic;
opacity: 1; /* Firefox applies opacity < 1 by default */
}
/* style list item markers (bullets/numbers) */
ul li::marker {
color: red;
font-size: 1.2em;
content: "\25CF"; /* custom bullet */
}
ol li::marker {
content: counter(list-item) ". ";
color: blue;
font-weight: bold;
}
/* ::marker supports: color, content, font properties,
direction, unicode-bidi, text-transform, white-space */Conteúdo gerado e counters
Conteúdo gerado via ::before/::after pode incluir valores counter(), valores de atributos (attr()) ou literais de string — habilitando numeração, ícones e tooltips só com CSS, sem DOM extra. counters() produz numeração aninhada como '1.2.3'. Tooltips construídos com attr(data-tooltip) e uma transição de hover são uma alternativa leve a bibliotecas JS. Lembre: conteúdo gerado não está no DOM e não é lido por alguns leitores de tela — não coloque conteúdo crítico lá.
/* counter in generated content */
h2::before {
content: "Section " counter(section) ": ";
color: gray;
}
/* attr() reads HTML attributes */
a::after {
content: attr(data-icon);
}
/* counters() for nested numbering */
ol { counter-reset: item; }
li { display: block; }
li::before {
content: counters(item, ".") " ";
counter-increment: item;
}
/* CSS-only tooltip */
.tooltip::after {
content: attr(data-tooltip);
position: absolute;
background: black; color: white;
padding: 4px 8px;
opacity: 0; transition: opacity 0.2s;
}
.tooltip:hover::after { opacity: 1; }Counters
counter-reset e counter-increment
Counters CSS permitem numerar elementos sem JavaScript. counter-reset inicializa um counter (padrão 0, mas você pode começar em outro valor). counter-increment o aumenta (padrão 1, mas qualquer inteiro funciona — até negativo). Exiba o valor com counter() dentro de content. Counters têm escopo no elemento onde foram resetados e seus descendentes, habilitando numeração aninhada.
body { counter-reset: section; } /* initialize to 0 */
h2 {
counter-increment: section; /* +1 each h2 */
}
h2::before {
content: "Section " counter(section) ": ";
}
/* custom increment value */
ol { counter-reset: item; }
li { counter-increment: item 1; } /* +1 (default) */
li.big { counter-increment: item 2; } /* +2 */
/* reset to a custom starting value */
.start-5 { counter-reset: item 4; } /* next increment = 5 */Função counter()
counter(name) exibe o valor atual de um counter, e counter(name, style) aplica um estilo de lista: decimal (padrão), lower/upper-alpha, lower/upper-roman, disc, square e mais. Você pode rodar múltiplos counters em paralelo e combiná-los em content — perfeito para figuras numeradas por capítulo (Figura 3-2). Os valores dos counters são calculados em tempo de renderização, então se atualizam automaticamente quando o DOM muda.
body { counter-reset: section; }
h2 { counter-increment: section; }
h2::before {
content: "Chapter " counter(section) ". ";
color: navy;
}
/* counter style (decimal, lower-alpha, upper-roman, etc.) */
h2::before {
content: counter(section, upper-roman) ". ";
}
/* multiple counters */
body { counter-reset: section figure; }
h2 { counter-increment: section; }
figcaption { counter-increment: figure; }
figcaption::before {
content: "Figure " counter(section) "-" counter(figure) ": ";
}Counters aninhados com counters()
counters(name, separador) é a função de counters aninhados: concatena o valor do counter em cada escopo ancestral, separado pela string dada. Isso produz numerações como '1.2.3' automaticamente — o mesmo nome de counter é resetado em cada <ol> aninhado. Sem counters() (plural), listas aninhadas compartilhariam a mesma numeração. O separador pode ser qualquer string, como '.' ou '-'.
ol { counter-reset: item; list-style: none; }
li::before {
counter-increment: item;
/* counters() concatenates ancestor counters with separator */
content: counters(item, ".") " ";
}
/* produces: 1 / 1.1 / 1.2 / 2 / 2.1 / 2.1.1 ... */
<ol>
<li>Item
<ol>
<li>Sub-item</li>
<li>Sub-item</li>
</ol>
</li>
<li>Item</li>
</ol>
/* custom separator */
li::before { content: counters(item, "-") ": "; }Estilização de counters
Counters suportam muitos estilos embutidos: decimal, upper-roman, lower-alpha, lower-greek, cjk-decimal e mais. @counter-style permite definir estilos personalizados com um conjunto de símbolos, um system (cyclic, additive, extends) e opções como pad (zeros à esquerda), prefix/suffix e range. Ótimo para listas temáticas, bullets de emoji ou numeração localizada sem JavaScript.
/* built-in styles */
.decimal { content: counter(c, decimal); }
.roman { content: counter(c, upper-roman); } /* I, II, III */
.alpha { content: counter(c, lower-alpha); } /* a, b, c */
.greek { content: counter(c, lower-greek); } /* alpha, beta, gamma */
.cjk { content: counter(c, cjk-decimal); } /* CJK numerals */
/* @counter-style: define a custom style */
@counter-style thumbs {
system: cyclic;
symbols: "\1F44D"; /* thumbs up emoji */
suffix: " ";
}
.like-list { list-style-type: thumbs; }
/* leading zeros via pad */
@counter-style padded {
system: extends decimal;
pad: 3 "0"; /* 001, 002, ... */
}Padrões práticos de counters
Counters brilham em indicadores de passos numerados, sumários e numerações. Estilize o ::before com um badge circular, cor e número para criar listas de passos numeradas sem numeração manual. Edite o DOM e os números se atualizam sozinhos. Ressalva: valores de counter não podem ser lidos facilmente pelo JavaScript — são só para exibição. Para lógica baseada em contagens, use JS ou CSS :nth-child.
/* numbered steps */
.steps { counter-reset: step; }
.steps li { counter-increment: step; }
.steps li::before {
content: counter(step);
display: inline-block;
width: 28px; height: 28px;
border-radius: 50%;
background: var(--primary);
color: white;
text-align: center;
line-height: 28px;
margin-right: 10px;
}
/* "you've completed N sections" via counters (limited -
counters can't be read by JS easily, use them for display) */Layout multicoluna
column-count e column-width
Layout multicoluna flui o conteúdo em colunas estilo jornal. column-count fixa o número; column-width deixa o navegador criar quantas colunas de 250px couberem (responsivo sem media queries). O shorthand columns recebe count e/ou width. Multicoluna é ideal para texto de leitura longa, mas cuidado: conteúdo curto pode causar alturas de coluna desiguais.
.article {
/* fixed number of columns */
column-count: 3;
/* OR width-based (browser decides count) */
column-width: 250px;
/* shorthand (count width) */
columns: 3 250px;
columns: 3; /* 3 columns */
columns: 250px; /* 250px columns, auto count */
}
/* responsive: width lets columns collapse on small screens */
.fluid { column-width: 200px; } /* 1 column on mobile, more on desktop */column-gap e column-rule
column-gap define o espaço entre colunas (também usado por flexbox e grid hoje). column-rule desenha uma linha divisória vertical no espaço — é o equivalente de border para colunas, com o mesmo shorthand. A regra não ocupa largura extra; fica centrada no espaço. Use uma cor sutil para delimitar colunas sem ser intrusivo.
.article {
column-count: 3;
column-gap: 30px; /* space between columns */
/* divider line (like border) */
column-rule: 1px solid #ddd; /* shorthand */
column-rule-width: 1px;
column-rule-style: solid;
column-rule-color: #ddd;
}
/* rule sits in the gap, doesn't add width */column-span
column-span: all faz um elemento romper por todas as colunas — perfeito para uma manchete estilo revista que atravessa a largura total com colunas fluindo acima e abaixo. column-span: none (padrão) mantém o conteúdo fluindo pelas colunas. Saiba que isso pode causar reflow significativo e já teve suporte inconsistente; teste bem. É mais confiável para títulos entre blocos de colunas.
.article {
column-count: 3;
}
/* heading spans all columns (like a magazine) */
.article h2 {
column-span: all;
/* resets above the heading, columns resume below */
}
/* default: content flows through columns */
.normal { column-span: none; }
/* note: column-span: all can cause reflow and is
not supported in older Firefox */break-inside e quebras de coluna
Conteúdo multicoluna pode dividir elementos de forma estranha entre colunas. break-inside: avoid mantém um elemento (como um card ou figura) intacto numa única coluna. break-before/break-after: column forçam quebras de coluna. As propriedades antigas page-break-* funcionam como aliases. Um hack comum era display: inline-block com width: 100%, mas break-inside: avoid é a abordagem moderna e correta.
/* prevent an element from splitting across columns */
.card {
break-inside: avoid; /* modern */
-webkit-column-break-inside: avoid; /* old webkit */
page-break-inside: avoid; /* old */
display: inline-block; /* hack for older browsers */
width: 100%;
}
/* control where columns break */
h2 { break-after: column; } /* force new column after */
h3 { break-before: column; } /* force new column before */
p { break-inside: avoid; } /* keep paragraph together */column-fill e balanceamento
column-fill controla como o conteúdo se distribui pelas colunas. balance (padrão) iguala as alturas para que as colunas terminem aproximadamente alinhadas — visualmente arrumado. auto preenche a primeira coluna por completo antes de passar à seguinte, exigindo altura fixa; isso corresponde ao comportamento de impressão. Colunas balanceadas são melhores para uso geral; auto é melhor quando o conteúdo deve fluir estritamente de cima a baixo.
.article {
column-count: 3;
/* balance: equalize column heights (default in most browsers) */
column-fill: balance;
/* auto: fill first column fully, then next (needs height) */
column-fill: auto;
height: 500px; /* required for auto */
}
/* balanced columns look neat but can split awkwardly;
auto is more like print, fills top-to-bottom */Interface do usuário
Outline e acessibilidade
Indicadores de foco visíveis são um requisito de acessibilidade. :focus-visible mostra o contorno apenas para usuários de teclado (não de mouse), a melhor prática para estilização de foco. Nunca defina outline: none sem substituição (como um anel de box-shadow). outline-offset adiciona espaço entre o elemento e o contorno. Navegadores modernos suportam contornos arredondados via border-radius afetando a forma do contorno.
/* visible focus ring for keyboard users */
button:focus-visible {
outline: 2px solid #0066cc;
outline-offset: 2px;
}
/* never outline: none without a replacement */
/* custom focus ring via box-shadow */
button:focus {
outline: none;
box-shadow: 0 0 0 3px rgba(0, 102, 204, 0.5);
}
/* outline shorthand */
.outlined { outline: 2px dashed red; outline-offset: 4px; }
/* thick rounded outline (modern browsers) */
button:focus-visible {
outline: 3px solid blue;
outline-offset: 2px;
border-radius: 4px;
}resize
resize controla se o usuário pode redimensionar um elemento arrastando. textarea é redimensionável por padrão; resize: none desabilita. vertical/horizontal/both restringem a direção. Para o resize funcionar, o elemento precisa de overflow diferente de visible (defina overflow: auto ou hidden). Útil para textareas, editores de código ou qualquer painel ajustável pelo usuário.
textarea {
/* allow vertical resize only (default for textarea) */
resize: vertical;
/* allow both axes */
resize: both;
/* horizontal only */
resize: horizontal;
/* disable resizing */
.locked { resize: none; }
/* default: inline/block elements can't be resized;
textarea default is both in most browsers */
}
/* note: resize only works on overflow != visible */caret-color e user-select
caret-color define a cor do cursor piscante em elementos editáveis — um toque pequeno, mas bacana, para formulários com identidade. user-select controla se o texto pode ser selecionado: none desabilita (para controles de UI), all seleciona o elemento inteiro ao clicar (bom para blocos de código ou e-mails) e contain mantém a seleção dentro de um elemento. Evite user-select: none no body — prejudica a acessibilidade.
/* color of the text cursor in inputs */
input, textarea {
caret-color: #0066cc; /* default: current color */
}
/* custom thick caret (limited support) */
input { caret-color: red; }
/* control text selection by the user */
.no-select { user-select: none; } /* disable selection */
.select-all { user-select: all; } /* select whole element on click */
.select-text { user-select: text; } /* normal text selection */
.select-contain { user-select: contain; } /* selection stays within */
/* email addresses, code blocks often user-select: all */appearance e estilização de formulários
appearance: none remove a estilização nativa do SO dos controles de formulário, permitindo estilizá-los totalmente com CSS — essencial para design de formulários consistente entre navegadores. Depois de remover a seta nativa do select, adicione um background-image personalizado. Checkboxes personalizados usam appearance: none mais :checked para o estado. Sempre prefixe com -webkit-/-moz- para suporte completo. Teste bem entre navegadores — alguns controles (date, color) continuam difíceis de reestilizar totalmente.
/* remove native widget styling */
input, select, button {
-webkit-appearance: none;
-moz-appearance: none;
appearance: none;
}
/* custom select arrow (after removing native) */
select {
background-image: url("arrow.svg");
background-repeat: no-repeat;
background-position: right 10px center;
padding-right: 30px;
}
/* style checkbox/radio with appearance: none */
input[type="checkbox"] {
appearance: none;
width: 20px; height: 20px;
border: 2px solid #999;
border-radius: 4px;
}
input[type="checkbox"]:checked {
background: var(--primary);
border-color: var(--primary);
}scroll-behavior e scrollbar
scroll-behavior: smooth no <html> faz os cliques em links de âncora animarem até o alvo em vez de saltar — pareie com prefers-reduced-motion para desabilitar para usuários sensíveis. Scrollbars personalizadas: as propriedades padrão scrollbar-width/scrollbar-color funcionam no Firefox e no Chrome moderno; os pseudo-elementos ::-webkit-scrollbar dão controle mais fino em WebKit/Blink. Scrollbars personalizadas sutis refinam a UX de áreas roláveis.
/* smooth scrolling for anchor links */
html { scroll-behavior: smooth; }
/* respect reduced motion */
@media (prefers-reduced-motion: reduce) {
html { scroll-behavior: auto; }
}
/* custom scrollbar (WebKit) */
.scroll-area::-webkit-scrollbar { width: 8px; }
.scroll-area::-webkit-scrollbar-track { background: #f1f1f1; }
.scroll-area::-webkit-scrollbar-thumb { background: #888; border-radius: 4px; }
.scroll-area::-webkit-scrollbar-thumb:hover { background: #555; }
/* standard scrollbar-color (Firefox + spec) */
.scroll-area {
scrollbar-width: thin;
scrollbar-color: #888 #f1f1f1;
}Recursos avançados e modernos
Scroll Snap
Scroll Snap cria rolagem tipo carrossel ou de página inteira sem JavaScript. scroll-snap-type: x/y + mandatory/proximity controla o eixo e a rigidez. Filhos com scroll-snap-align se ancoram em start/center/end. mandatory força a ancoragem (bom para seções de página inteira); proximity só ancora quando perto (mais suave, para galerias de imagens). Combine com scroll-margin para deslocar pontos de ancoragem sob cabeçalhos sticky.
.gallery {
scroll-snap-type: x mandatory; /* snap horizontally, must snap */
overflow-x: auto;
display: flex;
}
.gallery > img {
scroll-snap-align: center; /* start | center | end */
scroll-snap-stop: always; /* can't skip snaps */
flex: 0 0 80%;
}
/* vertical full-page snap */
.pages {
scroll-snap-type: y mandatory;
height: 100vh;
overflow-y: scroll;
}
.page { scroll-snap-align: start; height: 100vh; }
/* proximity: only snaps when close (gentler) */
.soft { scroll-snap-type: y proximity; }object-fit e object-position
object-fit controla como um <img> ou <video> preenche sua caixa — o equivalente de mídia do background-size. cover preenche a caixa e corta o excesso; contain cabe toda a mídia com possível espaço vazio; fill estica (distorce). object-position define o ponto focal — útil quando cover corta partes importantes de uma imagem. Elimina a necessidade de hacks de background-image para mídia responsiva.
/* cover: fill box, crop overflow (like background-size: cover) */
.avatar img {
width: 100px; height: 100px;
object-fit: cover; /* cover | contain | fill | none | scale-down */
object-position: center; /* position the focal point */
border-radius: 50%;
}
/* contain: whole image visible, may letterbox */
.preview img {
width: 300px; height: 200px;
object-fit: contain;
background: #eee;
}
/* object-position shifts the visible area */
.banner img {
width: 100%; height: 300px;
object-fit: cover;
object-position: top; /* show top of image */
}will-change
will-change dá uma dica ao navegador de que uma propriedade mudará em breve, deixando-o pré-alocar camadas de GPU e otimizar. Aplique logo antes de uma animação e remova depois — uso permanente em muitos elementos desperdiça memória e pode prejudicar o desempenho. Liste apenas propriedades que realmente animarão (transform, opacity, filter). O uso excessivo dispara o efeito oposto ao pretendido, então use com parcimônia e intenção.
/* hint that an element will animate transform */
.card { will-change: transform; }
/* remove when not needed (frees GPU memory) */
.card.idle { will-change: auto; }
/* multiple properties */
.complex { will-change: transform, opacity; }
/* AVOID: permanent will-change on many elements */
/* .all { will-change: transform, opacity, top, left; } */ /* bad */
/* apply just before animation, remove after */
.prepare { will-change: transform; }
/* JS: el.classList.add('prepare');
setTimeout(() => el.classList.remove('prepare'), 1000); */contain
contain informa ao navegador que um elemento é independente do resto da página, habilitando grandes otimizações de desempenho — mudanças dentro de um elemento contido não disparam recálculo fora dele. layout, paint, style e size são os tipos de isolamento. strict (os quatro, incluindo size) é o mais forte. Aplique contain a widgets repetidos, itens de lista ou anúncios para limitar o custo de reflow/repaint. size exige dimensões explícitas.
/* isolate an element's layout/paint/style from the rest */
.widget {
contain: layout paint style; /* or: strict, content */
/* size: the element's size is independent of its children */
contain: size; /* needs explicit dimensions */
}
/* layout: changes inside don't affect outside layout */
/* paint: children don't render outside the box (clipped) */
/* style: counters and quotes are scoped */
/* size: element ignores children for sizing */
/* full isolation */
.isolated { contain: strict; } /* = size layout paint style */
.content-isolated { contain: content; } /* = layout paint style */
/* useful for performance on complex widgets, lists, ads */aspect-ratio e gap universal
aspect-ratio mantém uma proporção largura:altura em qualquer elemento, evitando deslocamento de layout conforme a mídia carrega. gap (e seus longhand row-gap/column-gap) é a ferramenta moderna de espaçamento, funcionando em flexbox, grid e multicoluna — eliminando os hacks .item + margin + :last-child. Ambos são suportados universalmente em navegadores modernos e, juntos, resolvem duas das maiores dores de cabeça do CSS: manter proporções de mídia e espaçar itens de forma limpa.
/* aspect-ratio works on any element */
.video-wrap {
aspect-ratio: 16 / 9;
background: black;
}
/* gap works in flex, grid, and multi-column */
.flex { display: flex; gap: 16px; }
.grid { display: grid; gap: 16px; }
.cols { column-count: 3; column-gap: 16px; }
/* row-gap / column-gap longhands */
.layout {
display: grid;
row-gap: 24px;
column-gap: 16px;
}
/* gap replaced margin-based spacing hacks */
/* (no more .item:last-child { margin-right: 0 }) */Snippets de CSS3 relacionados
Copy-paste ready code for common tasks.
Flexbox Layout
Align and distribute items along one axis with flexbox.
Grid Layout
Build two-dimensional layouts with grid-template-areas.
Animations
Define keyframes and apply reusable animations.
Transitions
Smoothly interpolate properties on state change.
2D & 3D Transforms
Translate, rotate, and scale elements with GPU-friendly transforms.
Media Queries
Apply responsive, print, and preference-based styles.
Custom Properties
Define and reuse CSS variables with live updates.
Pseudo-Classes
Select elements by state and structural position.
Was this helpful?