Elementos semânticos
Estrutura do documento
O HTML5 introduziu elementos semânticos que descrevem seu significado tanto para o navegador quanto para o desenvolvedor. header, nav, main, article, aside, footer definem a estrutura do documento. DOCTYPE html dispara o modo padrões, lang melhora a acessibilidade e o SEO, e charset UTF-8 é obrigatório para a codificação correta.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Page Title</title>
</head>
<body>
<header>Header content</header>
<nav>Navigation</nav>
<main>
<article>Article content</article>
<aside>Sidebar</aside>
</main>
<footer>Footer</footer>
</body>
</html>Header e footer
header representa conteúdo introdutório (logos, títulos, formulários de busca) e pode aparecer várias vezes. footer guarda conteúdo de encerramento, como copyright, links ou informações de contato. Ambos podem ser usados dentro de elementos de seção como article ou section, não apenas no nível da página.
<header>
<h1>Site Title</h1>
<p>Tagline</p>
</header>
<footer>
<nav>
<a href="/about">About</a>
<a href="/contact">Contact</a>
</nav>
<small>© 2024 Example</small>
</footer>Elemento de navegação
nav é reservado para blocos principais de navegação. Nem toda lista de links precisa de nav — apenas grupos significativos para a navegação do site. Use aria-label para distinguir múltiplos elementos nav (por exemplo, principal vs breadcrumb). aria-current indica a página atual.
<nav aria-label="Main navigation">
<ul>
<li><a href="/" aria-current="page">Home</a></li>
<li><a href="/blog">Blog</a></li>
<li><a href="/about">About</a></li>
</ul>
</nav>
<nav aria-label="Breadcrumb">
<ol>
<li><a href="/">Home</a></li>
<li><a href="/blog">Blog</a></li>
<li aria-current="page">Post</li>
</ol>
</nav>Main e article
main envolve o conteúdo dominante da página e deve aparecer apenas uma vez por página (mapeado para o landmark ARIA 'main'). article é uma composição autocontida — uma postagem de blog, notícia ou widget — reutilizável de forma independente. section agrupa conteúdo tematicamente relacionado, sempre com um título.
<body>
<header>Site header</header>
<main>
<article>
<h1>Blog Post Title</h1>
<p>Body content...</p>
<section>
<h2>Subsection</h2>
<p>More content</p>
</section>
</article>
</main>
</body>Section e aside
section agrupa conteúdo relacionado e deve sempre incluir um título. aside representa conteúdo tangencialmente relacionado ao principal — sidebars, citações destacadas ou anúncios. Ambos melhoram o esboço do documento. Use aria-labelledby para dar às sections um nome acessível.
<section aria-labelledby="features-heading">
<h2 id="features-heading">Features</h2>
<p>Feature description</p>
</section>
<aside aria-label="Related links">
<h2>Related</h2>
<ul>
<li><a href="/post-2">Next post</a></li>
</ul>
</aside>Figure e figcaption
figure agrupa conteúdo (imagens, listagens de código, citações) referenciado no fluxo principal, com figcaption fornecendo a legenda. figcaption deve ser o primeiro ou o último filho. figure não se limita a imagens — funciona para qualquer conteúdo autocontido, como trechos de código ou blockquotes.
<figure>
<img src="chart.png" alt="Sales chart showing growth">
<figcaption>Figure 1: Quarterly sales growth in 2024.</figcaption>
</figure>
<figure>
<blockquote>
<p>The best way to predict the future is to invent it.</p>
</blockquote>
<figcaption>— Alan Kay</figcaption>
</figure>Aprimoramentos de formulário
Novos tipos de input
O HTML5 adicionou tipos de input como email, url, tel, date, time, color, range, number, month, week e datetime-local. Os navegadores fornecem validação nativa e UI especializada (seletores de data, seletores de cor). type=email/url dispara validação automática de formato ao enviar o formulário.
<form>
<label>Email: <input type="email" required></label>
<label>URL: <input type="url"></label>
<label>Phone: <input type="tel"></label>
<label>Date: <input type="date"></label>
<label>Time: <input type="time"></label>
<label>Color: <input type="color"></label>
<label>Range: <input type="range" min="0" max="100"></label>
<label>Number: <input type="number" min="0" step="0.01"></label>
<button>Submit</button>
</form>Autocomplete com datalist
datalist fornece sugestões de autocomplete para um input via o atributo list. Diferente de select, os usuários podem digitar texto livre ou escolher uma sugestão. O value de cada option vira uma sugestão. datalist degrada graciosamente em navegadores sem suporte, virando um input de texto comum.
<label>
Choose a browser:
<input list="browsers" name="browser">
</label>
<datalist id="browsers">
<option value="Chrome">
<option value="Firefox">
<option value="Safari">
<option value="Edge">
</datalist>Elemento output
output representa o resultado de um cálculo ou ação do usuário. Tem uma propriedade value acessível via JS e um atributo for referenciando os inputs que contribuíram. É um elemento associado a formulário, então seu valor é enviado com o form. Ótimo para calculadoras ao vivo.
<form oninput="result.value = (+a.value + +b.value)">
<input type="number" name="a" value="0">
+
<input type="number" name="b" value="0">
=
<output name="result" for="a b">0</output>
</form>Progress e meter
progress mostra a conclusão de uma tarefa (value/max); omita value para um estado indeterminado. meter exibe uma medida escalar dentro de uma faixa conhecida, com limiares low/high/optimum que afetam sua cor. meter é somente leitura e não serve para indicar progresso.
<label>Uploading:
<progress value="70" max="100">70%</progress>
</label>
<label>Disk usage:
<meter value="0.6" min="0" max="1" low="0.4" high="0.8" optimum="0.2">
60%
</meter>
</label>
<!-- Indeterminate progress -->
<progress>Processing...</progress>Atributo form e fieldset
O atributo form associa um input, fieldset ou button a um formulário pelo id, mesmo quando o elemento não está aninhado dentro dele. fieldset agrupa controles relacionados e legend fornece uma legenda. O atributo disabled no fieldset desabilita os controles contidos de uma vez.
<form id="myForm" action="/submit" method="post"></form>
<!-- Input outside the form, but associated via form attribute -->
<label>
Name:
<input type="text" name="name" form="myForm" required>
</label>
<fieldset form="myForm" disabled>
<legend>Shipping Options</legend>
<label><input type="radio" name="ship" value="standard"> Standard</label>
<label><input type="radio" name="ship" value="express"> Express</label>
</fieldset>
<button type="submit" form="myForm">Submit</button>Placeholder e autofocus
placeholder mostra uma dica dentro do input e desaparece no foco — não substitui um label. autofocus foca o elemento ao carregar a página (use com parcimônia, um por página). autocomplete controla se o navegador lembra valores anteriores. title fornece um tooltip, mas não deve substituir labels acessíveis.
<form>
<label>
Search:
<input type="search" name="q"
placeholder="Type to search..."
autofocus
autocomplete="off">
</label>
<label>
Hint text:
<input type="text" name="hint" title="Helpful tooltip">
</label>
<button type="submit">Go</button>
</form>Validação de formulário
Atributo required
O atributo booleano required marca um campo como obrigatório; o navegador bloqueia o envio e mostra um balão de erro se estiver vazio. Funciona nos controles de texto, número, checkbox, radio, arquivo e select. Pareie com as pseudo-classes CSS :invalid e :valid para feedback visual.
<form>
<label>
Email (required):
<input type="email" name="email" required>
</label>
<label>
Optional phone:
<input type="tel" name="phone">
</label>
<button>Submit</button>
</form>Validação com pattern
pattern aceita uma expressão regular JavaScript (sem barras) que o valor deve casar. Ancorar com ^ e $ é recomendado. O atributo title dá aos usuários uma dica em caso de falha. Pattern é implicitamente ancorado para type=email/url, mas explícito para inputs de texto.
<form>
<label>
Product code:
<input type="text" name="code"
pattern="[A-Z]{3}-\d{4}"
title="Three letters, hyphen, four digits (e.g., ABC-1234)"
required>
</label>
<label>
Hex color:
<input type="text" name="color" pattern="^#[0-9A-Fa-f]{6}$">
</label>
<button>Submit</button>
</form>Min, max e step
min e max definem os limites inferior e superior para inputs numéricos e de data. step especifica o incremento; os valores devem ser min + n*step. step='any' permite qualquer decimal. O navegador rejeita valores fora da faixa ao enviar e ajusta os cliques no spinner.
<form>
<label>
Quantity:
<input type="number" name="qty" min="1" max="99" step="1" value="1">
</label>
<label>
Price:
<input type="number" name="price" min="0" step="0.01">
</label>
<label>
Date range:
<input type="date" name="start" min="2024-01-01" max="2024-12-31">
</label>
<button>Submit</button>
</form>Minlength e maxlength
minlength e maxlength restringem o número de caracteres para inputs de texto e textareas. minlength dispara a validação apenas se o campo tiver um valor (combine com required para campos obrigatórios). maxlength trava a entrada além do limite, impedindo digitação.
<form>
<label>
Username (3-20 chars):
<input type="text" name="user" minlength="3" maxlength="20" required>
</label>
<label>
Bio (max 280 chars):
<textarea name="bio" maxlength="280"></textarea>
</label>
<button>Submit</button>
</form>API de validação de restrições
A Constraint Validation API expõe validity.valid, valueMissing, typeMismatch, patternMismatch, tooShort, rangeOverflow e mais. setCustomValidity(msg) mostra uma mensagem personalizada (passe string vazia para limpar). checkValidity() retorna um booleano e dispara o evento invalid; reportValidity() também mostra a UI.
<form id="f">
<label>
Username:
<input name="u" required minlength="3">
</label>
<button>Submit</button>
</form>
<script>
const input = document.querySelector('#f input[name=u]');
input.addEventListener('input', () => {
if (input.validity.valueMissing) {
input.setCustomValidity('Please pick a username.');
} else if (input.validity.tooShort) {
input.setCustomValidity('At least 3 characters.');
} else {
input.setCustomValidity('');
}
});
</script>novalidate e formnovalidate
novalidate no formulário desabilita totalmente a validação do navegador, útil quando você valida via JS. formnovalidate num botão de submit pula a validação apenas para o envio daquele botão (por exemplo, um 'Salvar rascunho' que permite dados incompletos). Ambos ainda enviam o formulário.
<!-- Browser validation disabled for whole form -->
<form novalidate>
<label>Email: <input type="email" name="e" required></label>
<button>Save draft</button>
<!-- Skip validation only for this button -->
<button type="submit" formnovalidate>Cancel</button>
</form>Desenho em canvas
Elemento canvas e contexto 2D
canvas é uma superfície de desenho bitmap. getContext('2d') retorna o contexto de renderização 2D; 'webgl' retorna um contexto 3D. Os atributos width/height definem o tamanho do buffer de desenho (não o tamanho CSS). Para renderização nítida em telas retina, escale o buffer pelo devicePixelRatio. O conteúdo de fallback vai entre as tags.
<canvas id="cv" width="400" height="300">
Your browser does not support canvas.
</canvas>
<script>
const canvas = document.getElementById('cv');
const ctx = canvas.getContext('2d');
// High-DPI scaling
const dpr = window.devicePixelRatio || 1;
canvas.width = 400 * dpr;
canvas.height = 300 * dpr;
ctx.scale(dpr, dpr);
</script>Desenhando retângulos
fillRect(x, y, w, h) desenha um retângulo preenchido, strokeRect desenha só o contorno, e clearRect apaga pixels para transparente. fillStyle e strokeStyle aceitam cores, gradientes ou padrões. lineWidth afeta a espessura do traço, centrado na borda do caminho.
<script>
const ctx = canvas.getContext('2d');
// Filled rectangle
ctx.fillStyle = '#3498db';
ctx.fillRect(10, 10, 100, 50);
// Outlined rectangle
ctx.strokeStyle = '#e74c3c';
ctx.lineWidth = 3;
ctx.strokeRect(130, 10, 100, 50);
// Clear a rectangle (erase)
ctx.clearRect(50, 20, 40, 30);
</script>Caminhos e linhas
beginPath inicia um novo caminho. moveTo define a posição da caneta sem desenhar; lineTo adiciona um segmento de linha. closePath conecta o último ponto ao início. Chame fill() e/ou stroke() para renderizar. Arcos (arc), curvas (quadraticCurveTo, bezierCurveTo) e retângulos também podem ser adicionados a um caminho.
<script>
const ctx = canvas.getContext('2d');
ctx.beginPath();
ctx.moveTo(20, 20); // starting point
ctx.lineTo(180, 20); // top edge
ctx.lineTo(100, 140); // bottom corner
ctx.closePath(); // back to start
ctx.fillStyle = 'rgba(46,204,113,0.6)';
ctx.fill();
ctx.stroke();
</script>Desenhando texto
font usa o mesmo shorthand do CSS font. textAlign (start, end, left, right, center) e textBaseline (top, middle, alphabetic, bottom) controlam o alinhamento. fillText desenha texto sólido; strokeText desenha só o contorno. measureText('foo').width retorna a largura renderizada.
<script>
const ctx = canvas.getContext('2d');
ctx.font = '600 24px system-ui, sans-serif';
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
ctx.fillStyle = '#2c3e50';
ctx.fillText('Hello Canvas', 200, 150);
ctx.lineWidth = 1;
ctx.strokeStyle = '#bdc3c7';
ctx.strokeText('Outlined', 200, 200);
</script>Desenhando imagens
drawImage pode receber um elemento img, canvas ou video. Com 3 argumentos desenha no tamanho natural; com 5, escala para w/h; com 9, os primeiros quatro são o retângulo de origem (recorte) e os últimos quatro o retângulo de destino. Espere o onload antes de desenhar, ou a imagem pode não aparecer.
<script>
const img = new Image();
img.src = 'pic.jpg';
img.onload = () => {
ctx.drawImage(img, 0, 0); // full size
ctx.drawImage(img, 0, 0, 100, 75); // scaled
// Source crop -> destination
ctx.drawImage(img, 32, 32, 64, 64, 200, 0, 64, 64);
};
</script>Gradientes
createLinearGradient(x0, y0, x1, y1) e createRadialGradient(x0, y0, r0, x1, y1, r1) definem gradientes. addColorStop(offset, color) adiciona stops de cor com offset de 0 a 1. Sempre passe strings de cor padrão; formatos incompatíveis (misturar hex e rgba) podem quebrar a interpolação. Atribua o gradiente a fillStyle ou strokeStyle.
<script>
// Linear gradient
const lg = ctx.createLinearGradient(0, 0, 200, 0);
lg.addColorStop(0, '#1e90ff');
lg.addColorStop(1, '#ffffff');
ctx.fillStyle = lg;
ctx.fillRect(0, 0, 200, 80);
// Radial gradient
const rg = ctx.createRadialGradient(100, 180, 5, 100, 180, 80);
rg.addColorStop(0, 'rgba(255,200,0,1)');
rg.addColorStop(1, 'rgba(255,200,0,0)');
ctx.fillStyle = rg;
ctx.fillRect(0, 100, 200, 160);
</script>SVG inline
Básico do elemento SVG
SVG inline usa o elemento svg com width/height para o tamanho de exibição e viewBox para o sistema de coordenadas. xmlns é obrigatório quando o SVG é usado isolado, opcional inline. SVG é vetorial: escala nítido em qualquer tamanho, é pesquisável e estilizável com CSS como HTML normal.
<svg width="200" height="120" viewBox="0 0 200 120"
xmlns="http://www.w3.org/2000/svg">
<rect x="10" y="10" width="180" height="100"
fill="#3498db" rx="8" />
<text x="100" y="65" text-anchor="middle"
fill="white" font-size="18">SVG</text>
</svg>Formas básicas
Primitivas SVG incluem rect, circle, ellipse, line, polyline (aberta) e polygon (fechada). cx/cy são coordenadas do centro; r é o raio. Fill é a cor do interior, stroke é o contorno. stroke-width define a espessura do contorno. Os atributos também podem ser definidos via CSS.
<svg width="240" height="120" viewBox="0 0 240 120">
<rect x="10" y="10" width="80" height="80" fill="#e74c3c" />
<circle cx="150" cy="50" r="40" fill="#2ecc71" />
<ellipse cx="200" cy="60" rx="30" ry="18" fill="#f1c40f" />
<line x1="10" y1="110" x2="230" y2="110" stroke="#333" stroke-width="2" />
<polyline points="10,100 60,70 110,100 160,70"
fill="none" stroke="#9b59b6" stroke-width="3" />
</svg>Paths
path é o elemento SVG mais poderoso, desenhando via um atributo d de comandos. M = moveTo, L = lineTo, H/V = linhas horizontal/vertical, C = bezier cúbica, Q = bezier quadrática, A = arco, Z = fechar caminho. Letras minúsculas usam coordenadas relativas. A maioria dos SVGs exportados por editores usa paths.
<svg width="200" height="120" viewBox="0 0 200 120">
<!-- M=moveTo, L=lineTo, C=cubicBezier, Z=closePath -->
<path d="M 10 80
C 40 10, 90 10, 120 80
L 180 80 Z"
fill="none" stroke="#3498db" stroke-width="3" />
<!-- A=arc -->
<path d="M 10 100 A 90 90 0 0 1 190 100"
fill="none" stroke="#e74c3c" stroke-width="2" />
</svg>Texto em SVG
text renderiza texto escalável e selecionável. x/y posicionam a linha de base. text-anchor (start/middle/end) e dominant-baseline controlam o alinhamento. tspan permite estilização, posicionamento e quebras de linha por segmento. O texto SVG permanece nítido em qualquer zoom e é acessível, diferente do texto desenhado em canvas.
<svg width="300" height="100" viewBox="0 0 300 100">
<text x="20" y="40" font-family="system-ui" font-size="20"
fill="#2c3e50">Plain text</text>
<text x="20" y="75" font-size="20" fill="#e74c3c"
text-decoration="underline">Underlined</text>
<text x="180" y="50">
<tspan fill="#3498db">Blue</tspan>
<tspan fill="#27ae60">Green</tspan>
</text>
</svg>Gradientes e padrões
Gradientes ficam dentro de defs e são referenciados por id via fill='url(#id)'. linearGradient usa x1/y1/x2/y2 (objectBoundingBox por padrão, 0-1). radialGradient assume por padrão um círculo centrado. Elementos stop definem os stops de cor. defs também guarda patterns, clip paths e symbols reutilizáveis.
<svg width="220" height="120" viewBox="0 0 220 120">
<defs>
<linearGradient id="g1" x1="0" y1="0" x2="1" y2="0">
<stop offset="0%" stop-color="#1e90ff" />
<stop offset="100%" stop-color="#ffffff" />
</linearGradient>
<radialGradient id="g2">
<stop offset="0%" stop-color="#f1c40f" />
<stop offset="100%" stop-color="#e67e22" />
</radialGradient>
</defs>
<rect x="10" y="10" width="90" height="90" fill="url(#g1)" />
<circle cx="160" cy="55" r="45" fill="url(#g2)" />
</svg>SVG inline vs Canvas
SVG é independente de resolução, cada forma é um nó DOM que você pode estilizar e anexar eventos — ideal para ícones, gráficos com poucos elementos e gráficos acessíveis. Canvas é um bitmap único, mais rápido para milhares de objetos ou manipulação de pixels (jogos, processamento de imagem), mas não escalável nem acessível pelo DOM.
<!-- SVG: vector, DOM-accessible, scalable -->
<svg width="100" height="100" viewBox="0 0 100 100">
<circle id="c" cx="50" cy="50" r="40" fill="#3498db" />
</svg>
<button onclick="document.getElementById('c')
.setAttribute('r','20')">Shrink</button>
<!-- Canvas: bitmap, pixel-based, faster for many objects -->
<canvas id="cv" width="100" height="100"></canvas>Áudio e vídeo
Elemento video
video incorpora vídeo sem plugins. controls mostra a UI nativa; poster é a miniatura antes da reprodução. Múltiplos elementos source permitem que o navegador escolha o primeiro codec suportado. O texto de fallback entre as tags aparece em navegadores sem suporte. Sempre inclua width/height para evitar deslocamento de layout.
<video controls width="640" poster="cover.jpg">
<source src="movie.mp4" type="video/mp4">
<source src="movie.webm" type="video/webm">
Your browser does not support the video tag.
</video>Elemento audio
audio funciona como video, sem dimensões visuais. controls adiciona UI de play/pause/seek/volume. Sem controls, o elemento é invisível e deve ser controlado via JS. Forneça múltiplas fontes (mp3, ogg) para suporte entre navegadores. autoplay pode ser bloqueado pelos navegadores, a menos que esteja muted.
<audio controls>
<source src="song.mp3" type="audio/mpeg">
<source src="song.ogg" type="audio/ogg">
Your browser does not support audio.
</audio>
<!-- Simple single-source -->
<audio src="beep.mp3" autoplay></audio>Múltiplas fontes
Os navegadores escolhem a primeira fonte cujo type conseguem reproduzir. Incluir o parâmetro codecs ajuda a decidir sem baixar. Liste formatos modernos (webm/av1) primeiro, para payloads menores, com mp4 como fallback universal. Um link de download dentro das tags é um fallback gracioso.
<video controls>
<source src="clip.webm" type='video/webm; codecs="vp9, opus"'>
<source src="clip.mp4" type='video/mp4; codecs="hvc1"'>
<source src="clip.ogv" type="video/ogg">
<p>Download <a href="clip.mp4">clip.mp4</a></p>
</video>Elemento track (legendas)
track adiciona faixas de texto temporizado via arquivos WebVTT (.vtt). kind pode ser subtitles, captions, descriptions, chapters ou metadata. srclang declara o idioma, label aparece no menu, e default escolhe a faixa inicial. Legendas são essenciais para acessibilidade e melhoram o SEO.
<video controls>
<source src="talk.mp4" type="video/mp4">
<track kind="subtitles" src="talk.en.vtt"
srclang="en" label="English" default>
<track kind="captions" src="talk.en.cc.vtt"
srclang="en" label="English CC">
<track kind="chapters" src="talk.chapters.vtt"
srclang="en" label="Chapters">
</video>Atributos de mídia
autoplay inicia a reprodução automaticamente, mas é bloqueado a menos que muted também esteja definido. loop repete para sempre. playsinline impede tela cheia forçada no iOS (essencial para fundos inline). preload pode ser none, metadata (só duração/dimensões) ou auto (bufferizar o arquivo inteiro). Evite autoplay+preload=auto juntos para poupar banda.
<video src="bg.mp4"
autoplay muted loop
playsinline
preload="auto"
width="1280" height="720">
</video>
<video src="preview.mp4"
controls
preload="metadata"
poster="preview.jpg">
</video>API de mídia
A API HTMLMediaElement expõe play(), pause(), load(), currentTime, duration, volume, muted, playbackRate e readyState. Eventos incluem play, pause, timeupdate, ended, volumechange, loadedmetadata e waiting. Construa players personalizados ocultando controls e ligando botões a essas funções.
<video id="v" src="movie.mp4"></video>
<button onclick="v.play()">Play</button>
<button onclick="v.pause()">Pause</button>
<input type="range" min="0" max="100" oninput="v.volume = this.value/100">
<script>
const v = document.getElementById('v');
v.addEventListener('timeupdate', () => {
console.log(v.currentTime, '/', v.duration);
});
v.addEventListener('ended', () => alert('Done!'));
// Jump 10s forward
function skip() { v.currentTime += 10; }
</script>Geolocalização
getCurrentPosition
getCurrentPosition recebe callbacks de sucesso e de erro opcionais, mais um objeto de opções. O objeto position expõe coords.latitude, longitude, accuracy e — quando disponíveis — altitude, heading e speed. A geolocalização só funciona em HTTPS (ou localhost) e solicita permissão ao usuário.
<script>
if ('geolocation' in navigator) {
navigator.geolocation.getCurrentPosition(
(pos) => {
console.log('Latitude:', pos.coords.latitude);
console.log('Longitude:', pos.coords.longitude);
console.log('Accuracy:', pos.coords.accuracy, 'meters');
},
(err) => console.error(err.message),
{ enableHighAccuracy: true, timeout: 10000 }
);
}
</script>Opções de posição
enableHighAccuracy pede o resultado mais preciso (GPS), ao custo de tempo e bateria. timeout limita a espera; se excedido, error.code é TIMEOUT (3). maximumAge permite que o navegador retorne uma posição em cache se ela for mais recente que os milissegundos dados, evitando chamadas repetidas de GPS.
<script>
navigator.geolocation.getCurrentPosition(success, error, {
enableHighAccuracy: true, // use GPS, slower
timeout: 5000, // max wait in ms
maximumAge: 60000 // accept cached fix up to 60s old
});
function success(pos) { /* ... */ }
function error(err) { /* ... */ }
</script>watchPosition
watchPosition chama o callback de sucesso toda vez que a posição muda, retornando um ID. Passe esse ID a clearWatch para parar as atualizações. Essencial para apps de navegação. Atenção à bateria — use um intervalo de atualização razoável e pare de observar quando não for necessário.
<script>
const watchId = navigator.geolocation.watchPosition(
(pos) => updateMap(pos.coords),
(err) => console.warn(err.message),
{ enableHighAccuracy: true }
);
// Stop tracking
document.getElementById('stop').onclick = () => {
navigator.geolocation.clearWatch(watchId);
};
</script>Tratamento de erros
O callback de erro recebe um GeolocationPositionError com code e message. PERMISSION_DENIED (1) significa que o usuário recusou ou o navegador bloqueou. POSITION_UNAVAILABLE (2) significa que o dispositivo não conseguiu determinar a posição. TIMEOUT (3) significa que a requisição demorou mais que a opção timeout. Sempre trate os três casos graciosamente.
<script>
navigator.geolocation.getCurrentPosition(
(pos) => console.log(pos),
(err) => {
switch (err.code) {
case err.PERMISSION_DENIED: // 1
console.log('User denied permission'); break;
case err.POSITION_UNAVAILABLE: // 2
console.log('Position unavailable'); break;
case err.TIMEOUT: // 3
console.log('Timed out'); break;
}
console.log(err.message);
}
);
</script>API de Permissions
A Permissions API permite verificar o estado de uma permissão sem disparar um prompt. query({ name: 'geolocation' }) retorna um PermissionStatus cujo state é granted, denied ou prompt. Escute onchange para reagir quando o usuário conceder ou revogar a permissão em outro lugar. Suportado para geolocation, notifications, camera, microphone e outros.
<script>
navigator.permissions
.query({ name: 'geolocation' })
.then((result) => {
// result.state: 'granted' | 'denied' | 'prompt'
if (result.state === 'granted') {
startTracking();
} else if (result.state === 'prompt') {
showEnableButton();
} else {
showInstructions();
}
result.onchange = () => console.log(result.state);
});
</script>Web Storage
Básico do localStorage
localStorage armazena pares chave/valor em string, sem expiração; os dados persistem entre abas e sessões. Os valores são strings, então números e booleanos são convertidos automaticamente. O limite é ~5MB por origem. O armazenamento é síncrono e bloqueia a thread principal, então evite escritas grandes. Acessá-lo em modo privado pode lançar erro, então envolva em try/catch.
<script>
// Store a value (strings only)
localStorage.setItem('theme', 'dark');
// Read a value
const theme = localStorage.getItem('theme'); // 'dark'
// Remove one key
localStorage.removeItem('theme');
// Remove everything
localStorage.clear();
// Number of stored keys
console.log(localStorage.length);
</script>sessionStorage
sessionStorage tem a mesma API do localStorage, mas tem escopo numa única aba e é limpo quando a aba fecha. Útil para dados transitórios como um rascunho de formulário em várias etapas, um carrinho temporário ou tokens CSRF. Os dados não são compartilhados entre abas, mesmo na mesma origem.
<script>
// sessionStorage works like localStorage but per-tab
sessionStorage.setItem('cart', '3 items');
console.log(sessionStorage.getItem('cart'));
sessionStorage.removeItem('cart');
// Survives a page reload but not a tab close
// Also isolated per tab (not shared)
</script>Armazenando dados JSON
Como o Web Storage só armazena strings, use JSON.stringify e JSON.parse para objetos e arrays. Sempre envolva o parse em try/catch, porque dados corrompidos ou editados manualmente lançam erro. Para dados complexos, versione a chave (por exemplo, 'settings.v2') para que mudanças de schema não quebrem dados antigos.
<script>
const settings = { theme: 'dark', fontSize: 16, lang: 'en' };
// Serialize before saving
localStorage.setItem('settings', JSON.stringify(settings));
// Parse when reading
try {
const saved = JSON.parse(localStorage.getItem('settings'));
console.log(saved.theme); // 'dark'
} catch (e) {
console.warn('Corrupted data', e);
}
</script>Eventos de storage
O evento storage dispara em todas as outras abas da mesma origem quando localStorage ou sessionStorage muda — mas NÃO na aba que fez a mudança. É o canal de comunicação entre abas mais simples. O objeto do evento carrega key, oldValue, newValue, url e storageArea. Use-o para sincronizar logout, mudanças de tema ou atualizações ao vivo entre abas.
<script>
// Listen in OTHER tabs (same origin) for changes
window.addEventListener('storage', (e) => {
console.log('Key changed:', e.key);
console.log('Old value:', e.oldValue);
console.log('New value:', e.newValue);
console.log('URL:', e.url);
});
// The tab that calls setItem does NOT receive the event
localStorage.setItem('count', '42');
</script>Limpando o armazenamento
clear() remove todas as chaves da origem — use com parcimônia e confirme com o usuário. key(n) retorna o nome da chave no índice n, ou null se fora da faixa. A ordem de iteração é definida pela implementação, então não dependa dela. Para limpeza parcial, liste as chaves com um prefixo (por exemplo, 'cache:') e remova-as com removeItem num loop.
<script>
// Remove a single key
localStorage.removeItem('temp');
// Wipe all keys for this origin
localStorage.clear();
// Iterate keys
const keys = [];
for (let i = 0; i < localStorage.length; i++) {
keys.push(localStorage.key(i));
}
console.log(keys);
// Indexed access (order is not guaranteed)
localStorage.key(0);
</script>IndexedDB
Abrindo um banco de dados
indexedDB.open(name, version) abre ou cria um banco de dados. onupgradeneeded dispara quando a versão aumenta ou o DB é criado pela primeira vez — é o ÚNICO lugar onde você pode criar ou alterar object stores e índices. Aumente o número da versão sempre que mudar o schema. Stores precisam de um keyPath (a propriedade usada como chave) ou de uma chave auto-incremental.
<script>
const request = indexedDB.open('MyDB', 1);
request.onupgradeneeded = (e) => {
const db = e.target.result;
if (!db.objectStoreNames.contains('users')) {
const store = db.createObjectStore('users', { keyPath: 'id' });
store.createIndex('email', 'email', { unique: true });
}
};
request.onsuccess = (e) => {
const db = e.target.result;
console.log('DB ready:', db.name, db.version);
};
request.onerror = (e) => console.error(e.target.error);
</script>Object stores
Um object store é como uma tabela; cada registro tem uma chave e um valor (qualquer objeto clonável por structured clone). keyPath informa ao store qual propriedade guarda a chave. autoIncrement atribui chaves inteiras sequenciais. Índices permitem consultar por uma propriedade que não é chave; unique: true impõe ausência de duplicatas naquele campo.
<script>
request.onupgradeneeded = (e) => {
const db = e.target.result;
// With a key path
const users = db.createObjectStore('users', { keyPath: 'id' });
// Auto-incrementing integer key
const logs = db.createObjectStore('logs', { autoIncrement: true });
// Indexes for fast lookups
users.createIndex('name', 'name', { unique: false });
users.createIndex('email', 'email', { unique: true });
};
</script>Adicionando dados
Todas as operações acontecem dentro de uma transação criada com db.transaction(storeName, mode). O modo é 'readonly' (padrão) ou 'readwrite'. add() rejeita duplicatas; put() faz upsert. A transação faz commit automático quando todas as requisições completam; escute oncomplete. Mantenha as transações curtas — elas bloqueiam outras transações nos mesmos stores.
<script>
function addUser(db, user) {
const tx = db.transaction('users', 'readwrite');
const store = tx.objectStore('users');
store.add(user); // throws on duplicate key
// store.put(user); // inserts OR overwrites
tx.oncomplete = () => console.log('Saved');
tx.onerror = () => console.error(tx.error);
}
addUser(db, { id: 1, name: 'Ada', email: '[email protected]' });
</script>Lendo dados
get(key) lê um único registro pela chave primária; getAll() retorna os registros como array. Para buscar por um campo que não é chave, abra o índice com store.index(name) e chame get/getAll nele. Cada requisição tem onsuccess e onerror. Os resultados ficam em event.target.result ou request.result.
<script>
const tx = db.transaction('users', 'readonly');
const store = tx.objectStore('users');
// By primary key
const req = store.get(1);
req.onsuccess = () => console.log(req.result);
// By index
const byEmail = store.index('email');
byEmail.get('[email protected]').onsuccess = (e) => {
console.log(e.target.result);
};
// All records
store.getAll().onsuccess = (e) => {
console.log(e.target.result); // array
};
</script>Cursors e índices
openCursor() permite iterar os registros um por vez, ideal para datasets grandes que não cabem na memória. Chame cursor.continue() para avançar. cursor.update(value) modifica o registro atual; cursor.delete() o remove. IDBKeyRange (bound, only, lowerBound, upperBound) delimita consultas de índice — útil para buscas por prefixo ou faixa.
<script>
const tx = db.transaction('users', 'readwrite');
const store = tx.objectStore('users');
// Iterate and modify
const req = store.openCursor();
req.onsuccess = (e) => {
const cursor = e.target.result;
if (cursor) {
if (cursor.value.name === 'Ada') {
cursor.value.role = 'admin';
cursor.update(cursor.value);
}
cursor.continue();
}
};
// Range query on an index
const range = IDBKeyRange.bound('A', 'M');
store.index('name').openCursor(range).onsuccess = (e) => { /* ... */ };
</script>API de drag and drop
Tornando elementos arrastáveis
Defina draggable='true' em qualquer elemento para torná-lo arrastável. O evento dragstart dispara quando o arrasto começa; use dataTransfer.setData para empacotar dados para o alvo do drop. effectAllowed (copy, move, link, all, none) sugere a operação pretendida. dragend dispara quando o arrasto termina, independentemente de ter havido drop.
<div id="card" draggable="true">
Drag me!
</div>
<script>
const card = document.getElementById('card');
card.addEventListener('dragstart', (e) => {
e.dataTransfer.setData('text/plain', card.id);
e.dataTransfer.effectAllowed = 'move';
card.classList.add('dragging');
});
card.addEventListener('dragend', () => {
card.classList.remove('dragging');
});
</script>Eventos de drag
Para aceitar um drop, você DEVE chamar preventDefault() tanto em dragover quanto em drop — caso contrário o navegador não faz nada. dragenter/dragleave disparam quando o ponteiro entra/sai do alvo. dropEffect (copy, move, link, none) controla o cursor. O evento drag dispara continuamente na fonte durante o arrasto.
<script>
// Events on the SOURCE element:
// dragstart, drag, dragend
// Events on the TARGET element:
// dragenter, dragover, dragleave, drop
const drop = document.getElementById('drop');
drop.addEventListener('dragover', (e) => {
e.preventDefault(); // REQUIRED to allow drop
e.dataTransfer.dropEffect = 'move';
});
drop.addEventListener('drop', (e) => {
e.preventDefault();
const id = e.dataTransfer.getData('text/plain');
drop.appendChild(document.getElementById(id));
});
</script>DataTransfer
dataTransfer transporta dados entre a fonte do arrasto e o alvo do drop. setData(format, data) guarda uma string; getData(format) a lê. Formatos padrão incluem text/plain, text/uri-list, text/html e files. Você também pode registrar tipos MIME personalizados. Alguns navegadores restringem getData a eventos de drop por segurança.
<script>
card.addEventListener('dragstart', (e) => {
// Multiple data types
e.dataTransfer.setData('text/plain', 'Hello');
e.dataTransfer.setData('text/uri-list', 'https://example.com');
e.dataTransfer.setData('application/json', JSON.stringify({ a: 1 }));
// Read in the drop handler
// e.dataTransfer.getData('text/plain')
});
</script>Zona de drop
Um padrão comum: destacar a zona de drop em dragenter/dragover, limpar em dragleave/drop. dataTransfer.files fornece um FileList ao arrastar arquivos do sistema operacional, habilitando uploads por arrastar e soltar. Sempre preventDefault em dragover, ou o evento drop não dispara. Use contadores de dragenter/leave se tiver elementos aninhados.
<style>
.dropzone { border: 2px dashed #bbb; padding: 24px; }
.dropzone.over { background: #eaf6ff; border-color: #3498db; }
</style>
<div class="dropzone" id="dz">Drop files here</div>
<script>
const dz = document.getElementById('dz');
dz.addEventListener('dragenter', () => dz.classList.add('over'));
dz.addEventListener('dragover', (e) => e.preventDefault());
dz.addEventListener('dragleave', () => dz.classList.remove('over'));
dz.addEventListener('drop', (e) => {
e.preventDefault();
dz.classList.remove('over');
const files = e.dataTransfer.files; // FileList
for (const f of files) console.log(f.name, f.size);
});
</script>Imagem de drag
setDragImage(element, offsetX, offsetY) substitui o fantasma padrão de arrasto por um elemento personalizado. O elemento precisa estar no DOM e renderizado, então crie-o, anexe e remova depois do dragstart. Os offsets posicionam o cursor em relação ao canto superior esquerdo da imagem. Se não passar imagem, o navegador captura uma foto do elemento arrastado.
<script>
card.addEventListener('dragstart', (e) => {
const ghost = document.createElement('div');
ghost.textContent = 'Dragging card';
ghost.style.cssText = 'position:absolute;top:-999px;' +
'padding:8px;background:#3498db;color:#fff;';
document.body.appendChild(ghost);
e.dataTransfer.setDragImage(ghost, 20, 20);
setTimeout(() => document.body.removeChild(ghost), 0);
});
</script>Web Workers
Básico de workers
new Worker(url) cria uma thread de segundo plano que roda o arquivo de script. A comunicação é via postMessage e onmessage, com dados copiados (structured clone) entre threads. Workers não podem tocar no DOM, window ou document — mas podem usar fetch, IndexedDB e setTimeout. Use-os para computação pesada, para que a UI continue responsiva.
<!-- main.js -->
<script>
const worker = new Worker('worker.js');
worker.postMessage({ cmd: 'sum', nums: [1, 2, 3] });
worker.onmessage = (e) => {
console.log('Result:', e.data); // 6
};
worker.onerror = (e) => {
console.error(e.message, e.filename, e.lineno);
};
</script>Script do worker
Dentro de um worker, self (ou this) é o escopo global — postMessage e onmessage pendem dele. Não há window nem document. Workers podem usar fetch, importScripts(), setTimeout/setInterval e IndexedDB. importScripts('a.js','b.js') carrega outros scripts no worker de forma síncrona. Cada worker roda no seu próprio isolate.
// worker.js
self.onmessage = (e) => {
const { cmd, nums } = e.data;
if (cmd === 'sum') {
let total = 0;
for (const n of nums) total += n;
self.postMessage(total);
} else if (cmd === 'heavy') {
const result = doExpensiveWork();
self.postMessage(result);
}
};
function doExpensiveWork() {
// ... long-running computation
return 'done';
}Enviando mensagens
postMessage(data, transferables) envia dados, copiando-os via structured clone. Passe um array de ArrayBuffer, MessagePort ou ImageBitmap no segundo argumento para TRANSFERIR a propriedade em vez de copiar — muito mais rápido para buffers grandes, mas o original fica inutilizável na thread que envia.
<script>
const w = new Worker('worker.js');
// Plain object
w.postMessage({ type: 'start' });
// Transferable: zero-copy move of a buffer
const buffer = new ArrayBuffer(1024);
w.postMessage(buffer, [buffer]);
// buffer is now "neutered" in main thread
// Two-way communication
w.onmessage = (e) => console.log('Worker said:', e.data);
</script>Objetos transferíveis
Objetos transferíveis (ArrayBuffer, MessagePort, ImageBitmap, OffscreenCanvas) se movem entre threads sem cópia. transferControlToOffscreen entrega um canvas a um worker, que pode então renderizar nele de forma independente — ótimo para animações suaves enquanto a thread principal está ocupada. A thread principal perde o acesso ao objeto transferido.
<script>
// Send a canvas ImageBitmap to a worker for processing
const offscreen = canvas.transferControlToOffscreen();
const worker = new Worker('paint.js');
worker.postMessage({ canvas: offscreen }, [offscreen]);
// Now the worker draws directly to the canvas
// without round-trips to the main thread.
</script>
<!-- paint.js -->
self.onmessage = (e) => {
const ctx = e.data.canvas.getContext('2d');
ctx.fillStyle = '#3498db';
ctx.fillRect(0, 0, 100, 100);
};Shared workers
Um SharedWorker é um único worker compartilhado por múltiplas abas da mesma origem. Cada conexão recebe um MessagePort via o evento connect. Use-o para estado entre abas (contagens ao vivo, caches compartilhados) ou um único fan-out de WebSocket. SharedWorkers não são suportados no Safari do iOS e têm particularidades; teste antes de depender deles.
<!-- main.js -->
<script>
const sw = new SharedWorker('shared.js');
sw.port.onmessage = (e) => console.log('Broadcast:', e.data);
sw.port.start();
sw.port.postMessage({ from: 'tab-A' });
</script>
<!-- shared.js -->
const ports = new Set();
self.onconnect = (e) => {
const port = e.ports[0];
ports.add(port);
port.onmessage = (ev) => {
// Broadcast to every connected tab
for (const p of ports) p.postMessage(ev.data);
};
port.start();
};WebSockets
Abrindo uma conexão
new WebSocket(url) abre uma conexão persistente e bidirecional. Use wss:// (TLS) em produção — ws:// é texto puro e bloqueado em páginas HTTPS. O readyState passa por CONNECTING (0), OPEN (1), CLOSING (2) e CLOSED (3). Escute os eventos open, message, error e close.
<script>
const ws = new WebSocket('wss://echo.example.com/chat');
ws.addEventListener('open', () => {
console.log('Connected');
ws.send('Hello server!');
});
ws.addEventListener('message', (e) => {
console.log('Received:', e.data);
});
ws.addEventListener('close', (e) => {
console.log('Closed', e.code, e.reason);
});
</script>Enviando mensagens
send() aceita strings, Blobs, ArrayBuffers e ArrayBufferViews. Para dados estruturados, JSON.stringify primeiro e interprete no outro lado. As mensagens entram na fila se enviadas antes do open, mas por segurança verifique readyState === OPEN. O protocolo é full-duplex — qualquer lado pode enviar a qualquer momento.
<script>
// Strings
ws.send('plain text');
// JSON
ws.send(JSON.stringify({ type: 'chat', text: 'hi' }));
// Binary
const blob = new Blob([new Uint8Array([1,2,3])]);
ws.send(blob);
ws.send(new ArrayBuffer(8));
// Check state before sending
if (ws.readyState === WebSocket.OPEN) ws.send(data);
</script>Recebendo mensagens
Eventos message entregam e.data como string (texto), Blob (binário padrão) ou ArrayBuffer (defina ws.binaryType = 'arraybuffer'). Para protocolos de texto, JSON é a codificação mais comum. Para binário, escolha Blob para arquivos/imagens e ArrayBuffer para parse numérico. Defina um schema de mensagens para que ambos os lados concordem com a forma.
<script>
ws.addEventListener('message', (e) => {
// Text messages: e.data is a string
if (typeof e.data === 'string') {
const msg = JSON.parse(e.data);
console.log(msg.type, msg.text);
}
// Binary: e.data is a Blob or ArrayBuffer
else {
e.data.arrayBuffer().then((buf) => {
const view = new DataView(buf);
console.log(view.getInt32(0));
});
}
});
// Force binary type
ws.binaryType = 'arraybuffer';
</script>Erros e fechamento
Eventos error carregam poucos detalhes por segurança; verifique o evento close depois. close(code, reason) inicia um desligamento limpo; código 1000 é fechamento normal, 1006 significa que a conexão caiu sem frame de fechamento (problema de rede). Códigos 4000-4999 são reservados para uso da aplicação. wasClean é true apenas quando ambos os lados completam o handshake.
<script>
ws.addEventListener('error', (e) => {
console.error('Socket error', e);
});
ws.addEventListener('close', (e) => {
console.log('code:', e.code, 'reason:', e.reason, 'clean:', e.wasClean);
});
// Close gracefully (1000 = normal closure)
ws.close(1000, 'goodbye');
// Common codes:
// 1000 normal, 1001 going away, 1006 abnormal (no close frame)
// 4000-4999 app-defined
</script>Reconexão
Os navegadores não reconectam automaticamente, então implemente com backoff exponencial (delay = min(base * 2^retry, max)). Envie pings periódicos para que sockets mortos sejam detectados e fechados. Reconecte ao fechar, mas limite o intervalo de retentativa para não bombardear o servidor. Zere o contador de retentativas quando conectar com sucesso.
<script>
let ws;
let retry = 0;
function connect() {
ws = new WebSocket('wss://example.com/live');
ws.onopen = () => { retry = 0; console.log('open'); };
ws.onmessage = (e) => console.log(e.data);
ws.onclose = () => {
const delay = Math.min(1000 * 2 ** retry, 30000);
retry++;
setTimeout(connect, delay);
};
}
connect();
// Heartbeat to detect dead connections
setInterval(() => {
if (ws.readyState === WebSocket.OPEN) ws.send('ping');
}, 30000);
</script>History API
pushState
pushState(state, title, url) adiciona uma nova entrada ao histórico da sessão e atualiza a barra de endereço sem recarregar a página — o núcleo do roteamento no cliente. A URL deve ser da mesma origem ou pushState lança erro. O argumento title é atualmente ignorado pelos navegadores. O objeto de estado é serializável e recuperável via history.state.
<script>
// Add a new entry WITHOUT reloading
history.pushState(
{ page: 'about' }, // state object
'About', // title (ignored by most browsers)
'/about' // URL
);
console.log(history.length); // entries count
console.log(history.state); // { page: 'about' }
</script>replaceState
replaceState(state, title, url) funciona como pushState, mas substitui a entrada atual em vez de adicionar uma nova — então voltar/avançar salta sobre a original. Use para atualizar a URL ou o estado sem poluir o histórico, por exemplo, depois de aplicar um filtro pelo qual você não quer que o usuário 'volte'.
<script>
// Replace the CURRENT entry (no new history item)
history.replaceState(
{ page: 'home', tab: 'featured' },
'',
'/home?tab=featured'
);
// Useful for: cleaning up redirects, updating URL after
// AJAX filter changes, or normalizing the entry URL.
</script>Evento popstate
popstate dispara quando o usuário clica em voltar/avançar ou history.go/back/forward é chamado — não em pushState/replaceState. O event.state é o objeto de estado da entrada para a qual se está navegando. A maioria dos routers de SPA chama a função de renderização tanto no navigate() quanto no handler de popstate, para que todas as navegações atualizem a view.
<script>
window.addEventListener('popstate', (e) => {
console.log('Location:', location.pathname);
console.log('State:', e.state);
renderRoute(location.pathname);
});
function navigate(path) {
history.pushState({ path }, '', path);
renderRoute(path);
}
// NOTE: pushState/replaceState do NOT fire popstate.
// Only back/forward (and history.go) do.
</script>Funções de navegação
back(), forward() e go(delta) movem-se pelo histórico da sessão; go(0) recarrega. history.length é o número de entradas na sessão atual, limitado pelo navegador. Essas funções são assíncronos — popstate dispara quando a navegação completa. Chamar go além dos limites não faz nada.
<script>
history.back(); // go back one entry
history.forward(); // go forward one entry
history.go(-2); // go back two entries
history.go(2); // go forward two entries
history.go(0); // reload current page
if (history.length === 1) {
console.log('First page in this tab');
}
</script>Roteamento de SPA
Um router de SPA mínimo: intercepte cliques em links internos, pushState para atualizar a URL, e renderize a nova view. Trate popstate para que voltar/avançar funcione. Use data-link ou uma classe para marcar links internos, e ignore links externos ou com target=_blank. Frameworks reais adicionam rotas aninhadas, params, guards e restauração de rolagem.
<script>
document.body.addEventListener('click', (e) => {
const a = e.target.closest('a');
if (!a || !a.matches('[data-link]')) return;
if (a.origin !== location.origin) return;
e.preventDefault();
history.pushState({ path: a.pathname }, '', a.pathname);
render(a.pathname);
});
window.addEventListener('popstate', () => render(location.pathname));
function render(path) {
fetch(path, { headers: { 'X-Ajax': '1' } })
.then((r) => r.text())
.then((html) => {
document.querySelector('#app').innerHTML = html;
});
}
</script>Elementos semânticos inline
Elemento time
time representa uma data, hora ou duração específica. O valor legível por máquina vai no atributo datetime (YYYY-MM-DD, HH:MM, ou ISO 8601 completo com fuso); o texto legível por humanos é o conteúdo. Motores de busca e apps de calendário usam datetime para extrair eventos. Sem datetime, o próprio conteúdo deve ser uma string de data válida.
<p>
Published on
<time datetime="2024-07-04">July 4, 2024</time>.
</p>
<p>
Event starts at
<time datetime="2024-07-04T19:00-05:00">7 PM EST</time>.
</p>
<p>
Open
<time datetime="09:00">9:00 AM</time>-
<time datetime="17:00">5:00 PM</time> daily.
</p>Elemento mark
mark destaca texto como relevante para o contexto atual do usuário, como correspondências de termos de busca ou notas que o usuário adicionou. Diferente de strong ou em, não carrega ênfase semântica — apenas destaque visual. O estilo padrão é um fundo amarelo. Também é útil dentro de blockquotes para marcar texto ao qual quem cita quer chamar atenção.
<p>
The function <code>querySelector()</code> returns the
first match, while <mark>querySelectorAll()</mark>
returns a static NodeList.
</p>
<p>
Search results: <mark>HTML5</mark> is the latest
version of the Hypertext Markup Language.
</p>details e summary
details cria um widget de revelação que o usuário pode expandir ou colapsar — sem JS. summary é o rótulo sempre visível; clique nele para alternar. Adicione o atributo open para expandir por padrão. O evento toggle dispara ao abrir ou fechar. Ótimo para FAQs, configurações avançadas e revelação progressiva de conteúdo.
<details>
<summary>What is HTML5?</summary>
<p>HTML5 is the fifth major revision of the HTML standard,
introducing semantic elements, new form controls, and APIs
for graphics, media, and offline apps.</p>
</details>
<details open>
<summary>System requirements</summary>
<ul>
<li>Modern browser (Chrome, Firefox, Safari, Edge)</li>
<li>JavaScript enabled</li>
</ul>
</details>Elemento dialog
dialog representa uma caixa modal ou não modal. show() abre sem modalidade; showModal() abre como modal, com backdrop e o resto da página inerte. method='dialog' num formulário fecha o dialog e define returnValue como o valor do botão clicado. O evento close dispara após fechar. ::backdrop estiliza a sobreposição.
<button onclick="dlg.showModal()">Open dialog</button>
<dialog id="dlg">
<form method="dialog">
<p>Are you sure?</p>
<menu>
<button value="cancel">Cancel</button>
<button value="confirm">OK</button>
</menu>
</form>
</dialog>
<script>
const dlg = document.getElementById('dlg');
dlg.addEventListener('close', () => {
console.log('User chose:', dlg.returnValue);
});
</script>abbr, cite e q
abbr expande abreviações via title (tooltip no hover) e ajuda leitores de tela. cite marca o título de uma obra (livro, artigo, filme) — não o autor. q é uma citação inline (os navegadores adicionam aspas); blockquote é para nível de bloco. dfn marca a instância definidora de um termo; usos subsequentes podem linkar a ela com a.
<p>
<abbr title="World Health Organization">WHO</abbr>
was founded in 1948.
</p>
<p>
As <cite>MDN Web Docs</cite> notes,
<q>HTML is the standard markup language.</q>
</p>
<p>
Use <dfn>semantics</dfn> to describe the meaning of
content, then refer to it normally.
</p>Design responsivo
Meta viewport
A meta tag viewport diz aos navegadores móveis para usar a largura do dispositivo como viewport de layout e começar na escala 1. Sem ela, os celulares fingem ter 980px de largura. initial-scale=1 impede zoom ao carregar. viewport-fit=cover permite usar a área do notch com env(safe-area-inset-*). Evite user-scalable=no — quebra a acessibilidade.
<head>
<meta name="viewport"
content="width=device-width, initial-scale=1, viewport-fit=cover">
</head>
<!-- Without this tag, mobile browsers render the page at a
~980px "desktop" width and shrink it down, making text
unreadable. -->
<!-- viewport-fit=cover lets content extend into the notch
area on iPhone X+. -->Elemento picture
picture permite servir imagens diferentes conforme condições de mídia (direção de arte). O navegador escolhe a primeira source cuja media casa e ignora as demais. O img é obrigatório como fallback e fornece o texto alt. Use quando precisar recortar ou trocar a imagem inteira por breakpoint, não apenas redimensioná-la.
<picture>
<!-- Art direction: different image per viewport -->
<source media="(min-width: 800px)" srcset="wide.jpg">
<source media="(orientation: portrait)" srcset="tall.jpg">
<img src="default.jpg" alt="A responsive photo">
</picture>
<!-- Browser picks the first matching <source>,
falling back to the <img>. -->srcset e sizes
srcset lista candidatos de imagem com sua largura intrínseca (480w = 480px de largura). sizes informa ao navegador quão larga a imagem será exibida em cada breakpoint. O navegador então escolhe o melhor candidato com base na viewport e no device pixel ratio — sem JS. Use quando a mesma imagem só precisa de resoluções diferentes.
<img src="small.jpg"
srcset="small.jpg 480w,
medium.jpg 800w,
large.jpg 1200w"
sizes="(max-width: 600px) 100vw,
(max-width: 1200px) 50vw,
33vw"
alt="A responsive photo">Unidades de viewport
vw e vh são porcentagens da largura/altura da viewport. No mobile, 100vh pode incluir a barra de endereço, causando saltos — prefira dvh (dinâmico), svh (pequeno) ou lvh (grande). clamp(min, preferido, max) é a forma mais limpa de tipografia fluida que não fica pequena ou grande demais. vmin/vmax usam a dimensão menor/maior.
<style>
.hero { height: 100vh; } /* full viewport height */
.half { width: 50vw; } /* half the viewport width */
/* Responsive typography */
h1 {
font-size: clamp(1.5rem, 4vw + 1rem, 3rem);
}
/* Use dvh/svh/lvh to handle mobile browser UI bars */
.hero { height: 100dvh; }
</style>Picture com type
source com type permite servir formatos de imagem modernos com fallback JPEG/PNG. O navegador escolhe o primeiro type que suporta, ignorando os demais. AVIF e WebP oferecem arquivos 30-50% menores que JPEG na mesma qualidade. Combinado com loading='lazy' no img, é a forma mais eficiente de entregar imagens.
<picture>
<!-- Modern format first, smaller file size -->
<source type="image/avif" srcset="photo.avif">
<source type="image/webp" srcset="photo.webp">
<img src="photo.jpg" alt="Optimized photo" loading="lazy">
</picture>
<!-- Browser picks the first type it supports.
AVIF and WebP are ~30-50% smaller than JPEG/PNG. -->Acessibilidade (ARIA)
Roles ARIA
Roles ARIA dizem à tecnologia assistiva o que um elemento faz, mas a primeira regra do ARIA é: não use se existir um elemento HTML nativo. header, nav, main, article, footer já expõem os roles banner, navigation, main, article, contentinfo. Use ARIA para widgets personalizados (tab, dialog, slider, menu) sem equivalente nativo, e pareie roles com suporte a teclado.
<div role="banner"> <!-- like <header> -->
<h1>Site title</h1>
</div>
<div role="navigation"> <!-- like <nav> -->
<a href="/">Home</a>
</div>
<div role="main"> <!-- like <main> -->
<div role="article"> <!-- like <article> -->
<p>Content</p>
</div>
</div>
<button role="button" aria-pressed="false">Toggle</button>aria-label e aria-labelledby
aria-label fornece um nome acessível quando não existe texto visível (botões só de ícone etc.). aria-labelledby referencia o id de um texto visível para usar como nome — útil quando um título já rotula uma seção. Prefira um <label for> visível para campos de formulário. aria-describedby aponta para texto de dica lido após o label.
<button aria-label="Close menu">×</button>
<nav aria-labelledby="main-nav-heading">
<h2 id="main-nav-heading" class="sr-only">Main navigation</h2>
<ul>...</ul>
</nav>
<input id="email" type="email">
<label id="email-label" for="email">Email address</label>
<!-- aria-labelledby="email-label" would also work -->aria-hidden
aria-hidden='true' remove um elemento da árvore de acessibilidade — use para ícones puramente decorativos, texto duplicado ou conteúdo fora da tela que não deve ser anunciado. Nunca oculte elementos focáveis. O padrão .sr-only oculta texto visualmente mantendo-o para leitores de tela — essencial para labels que devem ser falados, mas não vistos.
<!-- Decorative icon: hide from screen readers -->
<svg aria-hidden="true" focusable="false">
<use href="#icon-check"></use>
</svg>
<!-- Visually hidden but still announced -->
<span class="sr-only">3 new messages</span>
<style>
.sr-only {
position: absolute;
width: 1px; height: 1px;
padding: 0; margin: -1px;
overflow: hidden;
clip: rect(0, 0, 0, 0);
white-space: nowrap; border: 0;
}
</style>Regiões aria-live
aria-live marca regiões cujas atualizações devem ser anunciadas automaticamente. polite espera uma pausa; assertive interrompe. role='alert' implica assertive e é o padrão para mensagens de erro. aria-atomic='true' anuncia a região inteira ao mudar; aria-relevant controla quais mudanças são faladas. Use com parcimônia — o excesso torna as interfaces ruidosas.
<!-- Polite: announce when screen reader is idle -->
<div aria-live="polite" id="status">Saving...</div>
<!-- Assertive: announce immediately, may interrupt -->
<div aria-live="assertive" role="alert" id="error"></div>
<script>
function show(msg) {
document.getElementById('status').textContent = msg;
}
function fail(msg) {
document.getElementById('error').textContent = msg;
}
</script>Gerenciamento de foco
Usuários de teclado navegam via Tab; o foco deve estar sempre visível e lógico. :focus-visible estiliza o foco apenas para teclado, não mouse. Ao abrir um modal, mova o foco para dentro dele; ao fechar, devolva o foco ao gatilho. Prenda o Tab dentro do modal para que o foco não escape para conteúdo oculto. Nunca defina tabindex > 0; use 0 para tornar elementos focáveis e -1 para focáveis programaticamente.
<style>
:focus-visible {
outline: 3px solid #3498db;
outline-offset: 2px;
}
</style>
<script>
// Move focus into a modal
function openModal(dlg) {
dlg.showModal();
dlg.querySelector('input, button').focus();
}
// Trap focus inside the modal (simplified)
// Restore focus to the trigger on close
const trigger = document.activeElement;
dlg.addEventListener('close', () => trigger.focus());
</script>Skip links
Um skip link é o primeiro elemento focável da página e permite que usuários de teclado pulem a navegação repetitiva até o conteúdo principal. Fica oculto visualmente até receber foco. Essencial para acessibilidade — Critério de Sucesso 2.4.1 do WCAG 2.1. Pareie com um landmark <main id='main'> para que o alvo seja claro.
<body>
<a href="#main" class="skip-link">Skip to main content</a>
<header>...nav with 30 links...</header>
<main id="main">...</main>
</body>
<style>
.skip-link {
position: absolute;
left: -999px;
top: 0;
background: #000; color: #fff;
padding: 8px 16px;
z-index: 1000;
}
.skip-link:focus {
left: 0;
}
</style>Web Components
Custom elements
customElements.define(name, class) registra um custom element. O nome precisa conter um hífen. Estenda HTMLElement para elementos autônomos, ou uma classe específica como HTMLButtonElement (com is='name') para estender um embutido. Custom elements são a base dos web components — UI reutilizável e agnóstica de framework.
<script>
class MyButton extends HTMLElement {
constructor() {
super();
this.addEventListener('click', () => {
console.log('Custom button clicked');
});
}
}
customElements.define('my-button', MyButton);
// Autonomous element: extends HTMLElement
// Customized built-in: extends HTMLButtonElement
// <button is="my-button">
</script>
<my-button>Click me</my-button>Shadow DOM
attachShadow({ mode: 'open' }) cria uma árvore DOM encapsulada anexada ao elemento. Estilos e ids dentro da árvore shadow não vazam para fora, e estilos da página não vazam para dentro (exceto propriedades herdáveis). :host mira o elemento hospedeiro; ::slotted() estiliza filhos slotados. mode: 'closed' bloqueia acesso externo ao shadowRoot — raramente necessário.
<script>
class FancyCard extends HTMLElement {
constructor() {
super();
const shadow = this.attachShadow({ mode: 'open' });
shadow.innerHTML = `
<style>
:host { display: block; padding: 16px;
background: #f4f4f4; border-radius: 8px; }
::slotted(*) { color: #333; }
</style>
<div class="card">
<slot></slot>
</div>
`;
}
}
customElements.define('fancy-card', FancyCard);
</script>Templates HTML
O elemento template guarda HTML inerte que é interpretado, mas não renderizado, até ser clonado. Acesse seu conteúdo via template.content, então cloneNode(true) e append. Templates são perfeitos para estruturas repetidas e formam o lado de marcação dos web components. Diferente de innerHTML, templates podem conter <tr>, <td>, <option> e outros elementos com particularidades de interpretação.
<template id="row-template">
<tr>
<td class="name"></td>
<td class="age"></td>
</tr>
</template>
<script>
const tpl = document.getElementById('row-template');
const tbody = document.querySelector('tbody');
function addRow(name, age) {
const clone = tpl.content.cloneNode(true);
clone.querySelector('.name').textContent = name;
clone.querySelector('.age').textContent = age;
tbody.appendChild(clone);
}
addRow('Ada', 36);
</script>Slots
Slots permitem que consumidores passem filhos do light-DOM para lugares específicos da árvore shadow. Um <slot name='x'> recebe filhos com slot='x'; um <slot> sem nome recebe o resto. Os filhos slotados permanecem no light DOM — o slot é só um ponto de inserção. Escute slotchange no slot para reagir quando os nós slotados mudarem.
<fancy-card>
<h2 slot="title">Card Title</h2>
<p>Body text goes here.</p>
</fancy-card>
<!-- Inside the shadow DOM of <fancy-card>: -->
<template>
<div class="card">
<slot name="title"></slot>
<div class="body"><slot></slot></div>
</div>
</template>Callbacks de ciclo de vida
Custom elements têm callbacks de ciclo de vida: connectedCallback (inserido no DOM), disconnectedCallback (removido), attributeChangedCallback (apenas para atributos listados em observedAttributes) e adoptedCallback (movido para um novo documento). O construtor roda na criação — mantenha-o leve. Faça a configuração em connectedCallback e a limpeza em disconnectedCallback. O upgrade acontece automaticamente para elementos já no DOM quando define() é chamado.
<script>
class Observed extends HTMLElement {
static get observedAttributes() {
return ['count', 'label'];
}
constructor() { super(); }
connectedCallback() {
console.log('Added to DOM');
}
disconnectedCallback() {
console.log('Removed from DOM');
}
attributeChangedCallback(name, oldVal, newVal) {
console.log(name, 'changed', oldVal, '->', newVal);
}
}
customElements.define('observed-el', Observed);
</script>Aplicações offline
Registro de service worker
Um service worker é um script que o navegador roda em segundo plano, separado de uma página, habilitando suporte offline, push notifications e background sync. Registre-o a partir de um script de página; o arquivo do SW deve ser servido sobre HTTPS (ou localhost) e seu escopo é seu diretório por padrão. Uma vez instalado, ele controla os carregamentos de página via eventos fetch.
<script>
if ('serviceWorker' in navigator) {
window.addEventListener('load', () => {
navigator.serviceWorker
.register('/sw.js', { scope: '/' })
.then((reg) => console.log('SW registered', reg.scope))
.catch((err) => console.error('SW failed', err));
});
}
</script>Cache API
A Cache API armazena pares Request/Response, persistidos entre sessões. No evento install, pré-cacheie assets críticos. No evento fetch, responda primeiro do cache e caia para a rede (estratégia cache-first). Outras estratégias: network-first, stale-while-revalidate, cache-only, network-only. Aumente o nome do cache para invalidar entradas antigas.
// sw.js
const CACHE = 'app-v1';
const ASSETS = ['/', '/styles.css', '/app.js', '/offline.html'];
self.addEventListener('install', (e) => {
e.waitUntil(
caches.open(CACHE).then((c) => c.addAll(ASSETS))
);
});
self.addEventListener('fetch', (e) => {
e.respondWith(
caches.match(e.request).then((r) => r || fetch(e.request))
);
});Fallback offline
Uma estratégia network-first com fallback offline tenta a rede, depois o cache, e então uma página offline genérica. O evento activate roda após o install completar e é o lugar certo para apagar caches antigos — senão eles se acumulam. Clientes podem reivindicar abas existentes imediatamente com self.clients.claim() dentro do activate.
// sw.js
self.addEventListener('fetch', (e) => {
e.respondWith(
fetch(e.request).catch(() =>
caches.match(e.request).then((r) =>
r || caches.match('/offline.html')
)
)
);
});
// Activate event: clean up old caches
self.addEventListener('activate', (e) => {
e.waitUntil(
caches.keys().then((keys) =>
Promise.all(
keys.filter((k) => k !== 'app-v1')
.map((k) => caches.delete(k))
)
)
);
});Web App Manifest
Um web app manifest é um arquivo JSON descrevendo como a app deve parecer quando instalada na tela inicial. name/short_name, icons, start_url e display (standalone, fullscreen, minimal-ui, browser) são os campos-chave. Combinado com um service worker, um manifest torna a app instalável (PWA). theme_color afeta a moldura da UI do sistema operacional.
<!-- index.html -->
<link rel="manifest" href="manifest.json">
<!-- manifest.json -->
{
"name": "My App",
"short_name": "App",
"start_url": "/",
"display": "standalone",
"background_color": "#ffffff",
"theme_color": "#3498db",
"icons": [
{ "src": "/icon-192.png", "sizes": "192x192", "type": "image/png" },
{ "src": "/icon-512.png", "sizes": "512x512", "type": "image/png" }
]
}Background Sync
Background Sync (registrado via navigator.serviceWorker.ready.then(r => r.sync.register('tag'))) adia o trabalho até o usuário ter conectividade. O navegador dispara um evento sync no service worker quando a rede volta — mesmo se a página estiver fechada. Use-o para enviar envios de formulários enfileirados, mensagens ou analytics. A tag identifica o sync; duplicatas são coalescidas.
// sw.js
self.addEventListener('sync', (e) => {
if (e.tag === 'send-messages') {
e.waitUntil(sendQueuedMessages());
}
});
async function sendQueuedMessages() {
const queue = await getQueue();
for (const msg of queue) {
try { await fetch('/api/send', { method: 'POST', body: msg }); }
catch (e) { throw e; } // retry later
}
}Boas práticas de SEO
Title e meta description
O title (abaixo de ~60 caracteres) é o sinal de SEO on-page mais importante e aparece como o título do resultado de busca. A meta description (abaixo de ~160 caracteres) é o texto do snippet — não afeta o ranking, mas afeta a taxa de cliques. Use um title por página, inclua a palavra-chave principal e torne-o atraente. canonical previne problemas de conteúdo duplicado.
<head>
<title>HTML5 Cheatsheet - Semantic Elements & APIs</title>
<meta name="description"
content="A quick reference to HTML5 semantic elements,
form types, and browser APIs with examples.">
<meta name="robots" content="index, follow">
<link rel="canonical" href="https://example.com/html5">
</head>Open Graph e Twitter Cards
Tags Open Graph controlam como sua página aparece ao ser compartilhada no Facebook, LinkedIn, Slack e na maioria das redes. og:image deve ter 1200x630px. Twitter Cards usam um conjunto parecido com prefixos twitter: (ou caem para OG). Sem elas, compartilhamentos ganham uma imagem de prévia aleatória ou nenhuma, reduzindo drasticamente os cliques.
<head>
<!-- Open Graph (Facebook, LinkedIn, etc.) -->
<meta property="og:title" content="HTML5 Cheatsheet">
<meta property="og:description" content="Quick HTML5 reference.">
<meta property="og:image" content="https://example.com/og.png">
<meta property="og:url" content="https://example.com/html5">
<meta property="og:type" content="article">
<!-- Twitter Card -->
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:site" content="@example">
</head>Canonical e hreflang
rel='canonical' diz aos motores de busca qual URL é a versão mestre quando várias URLs têm conteúdo parecido (impressão, ordenação, query params) — previne penalidades por conteúdo duplicado. hreflang aponta para versões traduzidas ou regionais, para que o Google sirva a certa. Sempre inclua um x-default para locales não correspondidos. Ambos precisam de URLs absolutas.
<head>
<!-- Canonical: the master URL for duplicate content -->
<link rel="canonical" href="https://example.com/article">
<!-- hreflang: language/region alternatives -->
<link rel="alternate" hreflang="en" href="https://example.com/en/article">
<link rel="alternate" hreflang="es" href="https://example.com/es/article">
<link rel="alternate" hreflang="x-default" href="https://example.com/article">
</head>Dados estruturados (JSON-LD)
Dados estruturados JSON-LD descrevem sua página num formato legível por máquina (vocabulário schema.org) e habilitam resultados ricos na busca: carrosséis de artigos, breadcrumbs, FAQs, avaliações, eventos, produtos. Coloque num <script type='application/ld+json'>. Valide com o Rich Results Test do Google. Não impulsiona o ranking diretamente, mas melhora a aparência dos resultados.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "HTML5 Cheatsheet",
"author": { "@type": "Person", "name": "Ada" },
"datePublished": "2024-07-04",
"image": "https://example.com/cover.png",
"publisher": {
"@type": "Organization",
"name": "Example"
}
}
</script>Títulos semânticos
Motores de busca e leitores de tela usam títulos para entender o esboço da página. Use um h1 (o título da página), depois h2 para seções principais, h3 para subseções — nunca pule níveis (não vá de h2 direto a h4). Não escolha um título pelo tamanho; use CSS para estilizar. Uma hierarquia lógica de títulos melhora SEO e acessibilidade.
<article>
<h1>Article Title (only one h1 per page)</h1>
<p>Intro paragraph.</p>
<section>
<h2>First major section</h2>
<p>Content...</p>
<h3>Subsection</h3>
<p>Detail...</p>
</section>
<section>
<h2>Second major section</h2>
<p>Content...</p>
</section>
</article>Otimização de desempenho
preload
rel='preload' diz ao navegador para buscar com prioridade alta um recurso de que a página atual precisará, antes de ser descoberto normalmente. Sempre especifique as (font, style, script, image, fetch etc.) para que o navegador aplique as prioridades e o CSP corretos. Fontes precisam de crossorigin. Use preload apenas para recursos realmente críticos — o excesso desperdiça banda.
<head>
<!-- Preload critical resources for the current page -->
<link rel="preload" href="/fonts/main.woff2"
as="font" type="font/woff2" crossorigin>
<link rel="preload" href="/css/critical.css" as="style">
<link rel="preload" href="/js/app.js" as="script">
<!-- Preload a hero image -->
<link rel="preload" href="/hero.webp" as="image">
</head>prefetch e preconnect
preconnect completa DNS, TCP e TLS para uma origem cedo, economizando ~100-300ms quando a requisição real acontece — use para domínios de terceiros críticos. dns-prefetch é a versão mais leve (só DNS). prefetch busca um recurso de baixa prioridade para uma navegação provável. Use com parcimônia: preconnects demais desperdiçam sockets, e recursos pré-buscados podem não ser usados.
<head>
<!-- preconnect: early handshake to a third-party origin -->
<link rel="preconnect" href="https://cdn.example.com">
<link rel="preconnect" href="https://api.example.com" crossorigin>
<!-- dns-prefetch: just DNS lookup, lighter -->
<link rel="dns-prefetch" href="https://cdn.example.com">
<!-- prefetch: fetch a resource for the NEXT navigation -->
<link rel="prefetch" href="/next-page.html">
</head>Lazy loading
loading='lazy' em img e iframe adia o carregamento até o elemento se aproximar da viewport — economizando banda e CPU na renderização inicial. decoding='async' impede que a decodificação da imagem bloqueie a thread principal. Sempre defina width/height para evitar deslocamento de layout. Use loading='eager' (padrão) e fetchpriority='high' apenas para imagens hero acima da dobra. Suportado nos navegadores modernos.
<!-- Native lazy loading (no JS needed) -->
<img src="photo.jpg" loading="lazy" decoding="async" alt="...">
<iframe src="embed.html" loading="lazy"></iframe>
<!-- Eager (default) loads immediately -->
<img src="hero.jpg" loading="eager" fetchpriority="high" alt="Hero">
<!-- Defer non-critical images until they near the viewport -->
<img src="below-fold.jpg" loading="lazy" width="800" height="600" alt="">defer e async
Um <script> simples bloqueia a interpretação do HTML enquanto baixa e roda. async baixa em paralelo e roda assim que estiver pronto — use para scripts independentes (analytics, anúncios) em que a ordem não importa. defer baixa em paralelo, mas espera para rodar, em ordem, depois que o documento é interpretado — use para scripts principais da app que dependem do DOM. Scripts defer rodam antes do DOMContentLoaded.
<head>
<!-- async: download in parallel, run ASAP (order not guaranteed) -->
<script src="analytics.js" async></script>
<!-- defer: download in parallel, run after parse, in order -->
<script src="app.js" defer></script>
<script src="page.js" defer></script>
<!-- Classic: block parsing to download and run -->
<script src="blocking.js"></script>
</head>Resumo de resource hints
preload (página atual), prefetch (próxima página), preconnect (handshake com a origem) e dns-prefetch (só DNS) são as dicas de recurso principais. prerender está descontinuado em favor da Speculation Rules API, que pode pré-renderizar páginas inteiras para navegação instantânea. Aplique dicas com base no comportamento real dos usuários — dicas demais desperdiçam dados e podem prejudicar o desempenho.
<head>
<link rel="preload" href="/critical.woff2" as="font" crossorigin>
<link rel="preconnect" href="https://cdn.example.com">
<link rel="dns-prefetch" href="https://cdn.example.com">
<link rel="prefetch" href="/next-page.html">
<!-- Speculation Rules API (Chrome) -->
<script type="speculationrules">
{ "prerender": [{ "where": { "href_matches": "/next/*" } }] }
</script>
</head>Renderização crítica
Inlinar o CSS crítico para o conteúdo acima da dobra remove a requisição bloqueante de renderização e melhora o First Contentful Paint. Carregue o resto via preload+swap. content-visibility: auto permite que o navegador pule a renderização de seções fora da tela, melhorando drasticamente o desempenho de rolagem em páginas longas — pareie com contain-intrinsic-size para reservar espaço e evitar saltos da barra de rolagem.
<head>
<!-- Inline critical CSS for above-the-fold -->
<style>
body { margin: 0; font: system-ui; }
.hero { height: 60vh; background: #3498db; }
</style>
<!-- Load the rest asynchronously -->
<link rel="preload" href="/full.css" as="style" onload="this.rel='stylesheet'">
<noscript><link rel="stylesheet" href="/full.css"></noscript>
</head>
<body>
<!-- Use content-visibility to skip off-screen rendering -->
<section style="content-visibility: auto; contain-intrinsic-size: 500px;">
Heavy content here
</section>
</body>Snippets de HTML5 relacionados
Copy-paste ready code for common tasks.
Semantic Elements
Structure a page with header, nav, main, article, and footer.
Form Input Types
Use native HTML5 input types, validation, and datalist.
Canvas Basics
Draw shapes, lines, and text on a 2D canvas.
Video & Audio
Embed media with multiple sources and control playback.
Local & Session Storage
Persist data in the browser with the Web Storage API.
Geolocation
Get the user's position and watch for changes.
Drag and Drop
Accept dropped files with the Drag and Drop API.
Web Workers
Run heavy computation on a background thread.
Was this helpful?