Elementos semánticos
Estructura del documento
HTML5 introdujo elementos semánticos que describen su significado tanto al navegador como al desarrollador. header, nav, main, article, aside, footer definen la estructura del documento. DOCTYPE html activa el modo estándar, lang mejora la accesibilidad y el SEO, y el charset UTF-8 es necesario para una codificación correcta.
<!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 y footer
header representa el contenido introductorio (logos, títulos, formularios de búsqueda) y puede aparecer varias veces. footer contiene el contenido final como el copyright, enlaces o información de contacto. Ambos pueden usarse dentro de elementos de seccionado como article o section, no solo a nivel de 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 navegación
nav está reservado para los bloques de navegación principales. No toda lista de enlaces necesita nav—solo los grupos significativos para la navegación del sitio. Usa aria-label para distinguir varios elementos nav (por ejemplo, principal vs migas de pan). aria-current indica la página actual.
<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 y article
main envuelve el contenido dominante de la página y debería aparecer solo una vez por página (mapeado al landmark ARIA 'main'). article es una composición autosuficiente—una entrada de blog, una noticia o un widget—reutilizable de forma independiente. section agrupa contenido temáticamente relacionado, siempre con un encabezado.
<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 y aside
section agrupa contenido relacionado y debería incluir siempre un encabezado. aside representa contenido relacionado tangencialmente con el principal—barras laterales, citas destacadas o anuncios. Ambos mejoran el esquema del documento. Usa aria-labelledby para dar a las secciones un nombre accesible.
<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 y figcaption
figure agrupa contenido (imágenes, listados de código, citas) referenciado desde el flujo principal, con figcaption proporcionando una leyenda. figcaption debe ser el primer o el último hijo. figure no se limita a imágenes—funciona con cualquier contenido autosuficiente como fragmentos de código o citas en bloque.
<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>Mejoras de formularios
Nuevos tipos de input
HTML5 añadió tipos de input como email, url, tel, date, time, color, range, number, month, week y datetime-local. Los navegadores proporcionan validación nativa e interfaces especializadas (selectores de fecha, de color). type=email/url disparan la validación automática de formato al enviar el formulario.
<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>Autocompletado con datalist
datalist proporciona sugerencias de autocompletado para un input vía el atributo list. A diferencia de select, los usuarios pueden escribir texto libre o elegir una sugerencia. El value de cada option se convierte en una sugerencia. datalist degrada con elegancia en navegadores sin soporte como un input de texto plano.
<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 el resultado de un cálculo o una acción del usuario. Tiene una propiedad value accesible por JS y un atributo for que referencia los inputs que contribuyeron. Es un elemento asociado a formulario, así que su valor se envía con el formulario. Genial para calculadoras en 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 y meter
progress muestra la finalización de una tarea (value/max); omite value para un estado indeterminado. meter muestra una medición escalar dentro de un rango conocido, con umbrales low/high/optimum que afectan a su color. meter es de solo lectura y no sirve para indicar progreso.
<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 y fieldset
El atributo form asocia un input, un fieldset o un botón con un formulario por id, incluso cuando el elemento no está anidado dentro de él. fieldset agrupa controles relacionados y legend proporciona una leyenda. El atributo disabled en el fieldset desactiva de golpe los controles que contiene.
<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 y autofocus
placeholder muestra una pista dentro del input y desaparece al enfocar—no es un sustituto de la etiqueta. autofocus enfoca el elemento al cargar la página (úsalo con moderación, uno por página). autocomplete controla si el navegador recuerda valores anteriores. title proporciona un tooltip pero no debería reemplazar a las etiquetas accesibles.
<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>Validación de formularios
Atributo required
El atributo booleano required marca un campo como obligatorio; el navegador bloquea el envío y muestra una burbuja de error si está vacío. Funciona en cualquier control de texto, número, checkbox, radio, archivo y select. Emparéjalo con las pseudo-clases CSS :invalid y :valid para retroalimentación 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>Validación con pattern
pattern acepta una expresión regular de JavaScript (sin barras) que el valor debe cumplir. Se recomienda anclar con ^ y $. El atributo title da a los usuarios una pista en caso de fallo. El pattern está anclado implícitamente para type=email/url pero explícitamente para los 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 y step
min y max definen los límites inferior y superior para inputs numéricos y de fecha. step especifica el incremento; los valores deben ser min + n*step. step='any' permite cualquier decimal. El navegador rechaza los valores fuera de rango al enviar y ajusta los clics del 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 y maxlength
minlength y maxlength acotan el número de caracteres para inputs de texto y textareas. minlength dispara la validación solo si el campo tiene valor (combínalo con required para campos obligatorios). maxlength atrapa la entrada más allá del límite, impidiendo escribir.
<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 validación de restricciones
La Constraint Validation API expone validity.valid, valueMissing, typeMismatch, patternMismatch, tooShort, rangeOverflow y más. setCustomValidity(msg) muestra un mensaje personalizado (pasa una cadena vacía para limpiarlo). checkValidity() devuelve un booleano y dispara el evento invalid; reportValidity() también muestra la 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 y formnovalidate
novalidate en el formulario desactiva por completo la validación del navegador, útil cuando validas vía JS. formnovalidate en un botón de envío se salta la validación solo para el envío de ese botón (por ejemplo, un 'Guardar borrador' que permite datos incompletos). Ambos siguen enviando el formulario.
<!-- 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>Dibujo en Canvas
Elemento canvas y contexto 2D
canvas es una superficie de dibujo de mapa de bits. getContext('2d') devuelve el contexto de renderizado 2D; 'webgl' devuelve un contexto 3D. Los atributos width/height fijan el tamaño del búfer de dibujo (no el tamaño CSS). Para un renderizado nítido en pantallas retina, escala el búfer por devicePixelRatio. El contenido de respaldo va entre las etiquetas.
<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>Dibujar rectángulos
fillRect(x, y, w, h) dibuja un rectángulo relleno, strokeRect dibuja solo el contorno, y clearRect borra píxeles a transparente. fillStyle y strokeStyle aceptan colores, degradados o patrones. lineWidth afecta al grosor del trazo, centrado sobre el borde del path.
<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>Paths y líneas
beginPath inicia un nuevo path. moveTo fija la posición del lápiz sin dibujar; lineTo añade un segmento de línea. closePath conecta el último punto con el inicio. Llama a fill() y/o stroke() para renderizar. Los arcos (arc), las curvas (quadraticCurveTo, bezierCurveTo) y los rects también pueden añadirse a un path.
<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>Dibujar texto
font usa la misma forma corta que la propiedad font de CSS. textAlign (start, end, left, right, center) y textBaseline (top, middle, alphabetic, bottom) controlan la alineación. fillText dibuja texto sólido; strokeText dibuja solo el contorno. measureText('foo').width devuelve el ancho renderizado.
<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>Dibujar imágenes
drawImage puede recibir un elemento img, canvas o video. Con 3 argumentos dibuja a tamaño natural; con 5 lo escala a w/h; con 9, los cuatro primeros son el rectángulo fuente (recorte) y los cuatro últimos el rectángulo destino. Espera a onload antes de dibujar, o la imagen podría no 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>Degradados
createLinearGradient(x0, y0, x1, y1) y createRadialGradient(x0, y0, r0, x1, y1, r1) definen degradados. addColorStop(offset, color) añade paradas de color con offset de 0 a 1. Pasa siempre cadenas de color estándar; los formatos que no coinciden (mezclar hex y rgba) pueden romper la interpolación. Asigna el degradado a fillStyle o 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 en línea
Fundamentos del elemento SVG
El SVG en línea usa el elemento svg con width/height para el tamaño de visualización y viewBox para el sistema de coordenadas. xmlns es obligatorio cuando el SVG se usa de forma independiente, opcional en línea. SVG es vectorial: escala con nitidez a cualquier tamaño y es buscable y estilizable con 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
Las primitivas de SVG incluyen rect, circle, ellipse, line, polyline (abierta) y polygon (cerrada). cx/cy son las coordenadas del centro; r es el radio. fill es el color del interior, stroke el del contorno. stroke-width fija el grosor del contorno. Cada atributo también puede fijarse vía 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 es el elemento más potente de SVG, dibuja mediante un atributo d de comandos. M = moveTo, L = lineTo, H/V = líneas horizontal/vertical, C = bezier cúbica, Q = bezier cuadrática, A = arco, Z = cerrar path. Las letras minúsculas usan coordenadas relativas. La mayoría de SVG exportados por editores usan 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 en SVG
text renderiza texto escalable y seleccionable. x/y posicionan la línea base. text-anchor (start/middle/end) y dominant-baseline controlan la alineación. tspan permite estilos, posiciones y saltos de línea por segmento. El texto SVG permanece nítido a cualquier zoom y es accesible, a diferencia del texto dibujado en 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>Degradados y patrones
Los degradados viven dentro de defs y se referencian por id vía fill='url(#id)'. linearGradient usa x1/y1/x2/y2 (objectBoundingBox por defecto, 0-1). radialGradient por defecto es un círculo centrado. Los elementos stop definen las paradas de color. defs también guarda patrones, rutas de recorte y símbolos reutilizables.
<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 en línea vs canvas
SVG es independiente de la resolución; cada forma es un nodo del DOM que puedes estilizar y al que puedes adjuntar eventos—ideal para iconos, gráficos con pocos elementos y gráficos accesibles. Canvas es un único mapa de bits, más rápido para miles de objetos o manipulación de píxeles (juegos, procesamiento de imágenes), pero no escalable ni accesible por 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>Audio y vídeo
Elemento video
video inserta vídeo sin plugins. controls muestra la UI nativa; poster es la miniatura antes de la reproducción. Varios elementos source permiten que el navegador elija el primer códec soportado. El texto de respaldo entre las etiquetas se muestra en navegadores sin soporte. Incluye siempre width/height para evitar saltos 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 sin dimensiones visuales. controls añade la UI de reproducir/pausar/avanzar/volumen. Sin controls, el elemento es invisible y debe controlarse vía JS. Proporciona múltiples fuentes (mp3, ogg) para soporte entre navegadores. autoplay puede ser bloqueado por los navegadores salvo que esté 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últiples fuentes
Los navegadores eligen la primera fuente cuyo type puedan reproducir. Incluir el parámetro codecs les ayuda a decidir sin descargar. Lista primero los formatos modernos (webm/av1) por sus payloads más pequeños, y mp4 como respaldo universal. Un enlace de descarga dentro de las etiquetas es un respaldo elegante.
<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 (subtítulos)
track añade pistas de texto temporizado vía archivos WebVTT (.vtt). kind puede ser subtitles, captions, descriptions, chapters o metadata. srclang declara el idioma, label se muestra en el menú y default elige la pista inicial. Los subtítulos son esenciales para la accesibilidad y mejoran el 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 medios
autoplay inicia la reproducción automáticamente pero se bloquea salvo que muted también esté fijado. loop repite para siempre. playsinline impide la pantalla completa forzada en iOS (esencial para fondos en línea). preload puede ser none, metadata (solo duración/dimensiones) o auto (búfer del archivo completo). Evita autoplay+preload=auto juntos para ahorrar ancho de 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 medios
La API HTMLMediaElement expone play(), pause(), load(), currentTime, duration, volume, muted, playbackRate y readyState. Los eventos incluyen play, pause, timeupdate, ended, volumechange, loadedmetadata y waiting. Construye reproductores personalizados ocultando controls y conectando botones a estas funciones.
<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>Geolocalización
getCurrentPosition
getCurrentPosition recibe callbacks de éxito y de error opcionales más un objeto de opciones. El objeto position expone coords.latitude, longitude, accuracy y—cuando están disponibles—altitude, heading y speed. La geolocalización solo funciona en HTTPS (o localhost) y pide permiso al usuario.
<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>Opciones de posición
enableHighAccuracy pide el resultado más preciso (GPS) a costa de tiempo y batería. timeout acota la espera; si se supera, error.code es TIMEOUT (3). maximumAge permite al navegador devolver una posición cacheada si es más reciente que los milisegundos dados, evitando llamadas GPS repetidas.
<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 llama al callback de éxito cada vez que la posición cambia, devolviendo un ID. Pasa ese ID a clearWatch para detener las actualizaciones. Es esencial para apps de navegación. Cuida la batería—usa un intervalo de actualización razonable y deja de observar cuando no haga falta.
<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>Manejo de errores
El callback de error recibe un GeolocationPositionError con code y message. PERMISSION_DENIED (1) significa que el usuario declinó o el navegador lo bloqueó. POSITION_UNAVAILABLE (2) significa que el dispositivo no pudo determinar la posición. TIMEOUT (3) significa que la petición tardó más que la opción timeout. Maneja con elegancia los tres casos.
<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 permisos
La Permissions API permite comprobar el estado de un permiso sin disparar un aviso. query({ name: 'geolocation' }) devuelve un PermissionStatus cuyo state es granted, denied o prompt. Escucha onchange para reaccionar cuando el usuario concede o revoca el permiso en otro lugar. Soportado para geolocation, notifications, camera, microphone y otros.
<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
Fundamentos de localStorage
localStorage almacena pares clave/valor de cadenas sin expiración; los datos persisten entre pestañas y sesiones. Los valores son cadenas, así que los números y booleanos se convierten automáticamente. El límite es ~5MB por origen. El almacenamiento es sincrónico y bloquea el hilo principal, así que evita escrituras grandes. Acceder en modo privado puede lanzar un error, así que envuélvelo en 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 tiene la misma API que localStorage pero está acotado a una sola pestaña y se limpia al cerrarla. Es útil para datos transitorios como el borrador de un formulario de varios pasos, un carrito temporal o tokens CSRF. Los datos no se comparten entre pestañas ni siquiera en el mismo origen.
<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>Almacenamiento de datos JSON
Como Web Storage solo almacena cadenas, usa JSON.stringify y JSON.parse para objetos y arrays. Envuelve siempre el parse en try/catch porque los datos corruptos o editados a mano lanzarán un error. Para datos complejos, versiona la clave (por ejemplo, 'settings.v2') para que los cambios de esquema no rompan los datos antiguos.
<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 almacenamiento
El evento storage se dispara en todas las demás pestañas del mismo origen cuando cambia localStorage o sessionStorage—pero NO en la pestaña que hizo el cambio. Es el canal de comunicación entre pestañas más simple. El objeto de evento lleva key, oldValue, newValue, url y storageArea. Úsalo para sincronizar el cierre de sesión, cambios de tema o actualizaciones en vivo entre pestañas.
<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>Limpiar el almacenamiento
clear() elimina todas las claves del origen—úsalo con moderación y confírmalo con el usuario. key(n) devuelve el nombre de la clave en el índice n, o null si está fuera de rango. El orden de iteración depende de la implementación, así que no confíes en él. Para una limpieza parcial, lista las claves con un prefijo (por ejemplo, 'cache:') y elimínalas con removeItem en un bucle.
<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
Abrir una base de datos
indexedDB.open(name, version) abre o crea una base de datos. onupgradeneeded se dispara cuando la versión aumenta o la base se crea por primera vez—es el ÚNICO lugar donde puedes crear o alterar object stores e índices. Incrementa el número de versión cada vez que cambies el esquema. Los stores necesitan un keyPath (la propiedad usada como clave) o una clave autoincremental.
<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
Un object store es como una tabla; cada registro tiene una clave y un valor (cualquier objeto clonable estructuradamente). keyPath indica al store qué propiedad contiene la clave. autoIncrement asigna claves enteras secuenciales. Los índices permiten consultar por una propiedad que no sea clave; unique: true impide duplicados en ese 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>Añadir datos
Todas las operaciones ocurren dentro de una transacción creada con db.transaction(storeName, mode). El modo es 'readonly' (por defecto) o 'readwrite'. add() rechaza duplicados; put() hace upsert. La transacción hace commit automáticamente cuando todas las peticiones se completan; escucha oncomplete. Mantén las transacciones cortas—bloquean otras transacciones sobre los mismos 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>Leer datos
get(key) lee un único registro por clave primaria; getAll() devuelve el conjunto completo de registros como un array. Para buscar por un campo que no es clave, abre el índice con store.index(name) y llama a get/getAll sobre él. Cada petición tiene onsuccess y onerror. Los resultados están en event.target.result o 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>Cursores e índices
openCursor() permite iterar los registros de uno en uno, ideal para datasets grandes que no caben en memoria. Llama a cursor.continue() para avanzar. cursor.update(value) modifica el registro actual; cursor.delete() lo elimina. IDBKeyRange (bound, only, lowerBound, upperBound) acota las consultas de índice—útil para búsquedas por prefijo o rango.
<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 arrastrar y soltar
Hacer elementos arrastrables
Fija draggable='true' en cualquier elemento para hacerlo arrastrable. El evento dragstart se dispara al comenzar el arrastre; usa dataTransfer.setData para empaquetar los datos para el objetivo de soltar. effectAllowed (copy, move, link, all, none) insinúa la operación prevista. dragend se dispara al terminar el arrastre, independientemente de si se soltó.
<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 arrastre
Para aceptar un soltado, DEBES llamar a preventDefault() tanto en dragover como en drop—de lo contrario el navegador no hace nada. dragenter/dragleave se disparan cuando el puntero entra/sale del objetivo. dropEffect (copy, move, link, none) controla el cursor. El evento drag se dispara continuamente sobre el origen durante el arrastre.
<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 lleva los datos entre el origen del arrastre y el objetivo de soltar. setData(formato, datos) guarda una cadena; getData(formato) la lee. Los formatos estándar incluyen text/plain, text/uri-list, text/html y files. También puedes registrar tipos MIME personalizados. Algunos navegadores restringen getData a los eventos drop por seguridad.
<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 soltado
Un patrón común: resalta la zona de soltado en dragenter/dragover y límpiala en dragleave/drop. dataTransfer.files da un FileList al arrastrar archivos desde el sistema operativo, habilitando subidas por arrastrar y soltar. Haz siempre preventDefault en dragover o el evento drop no se disparará. Usa contadores de dragenter/leave si tienes elementos anidados.
<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>Imagen de arrastre
setDragImage(elemento, offsetX, offsetY) reemplaza el fantasma de arrastre por defecto con un elemento personalizado. El elemento debe estar en el DOM y renderizado, así que créalo, añádelo y luego quítalo tras dragstart. Los offsets posicionan el cursor respecto a la esquina superior izquierda de la imagen. Si no pasas imagen, el navegador hace una captura del elemento arrastrado.
<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
Fundamentos de los workers
new Worker(url) genera un hilo en segundo plano que ejecuta el archivo de script. La comunicación es vía postMessage y onmessage, con los datos copiados (structured clone) entre hilos. Los workers no pueden tocar el DOM, window ni document—pero pueden usar fetch, IndexedDB y setTimeout. Úsalos para computación pesada y que la UI siga respondiendo.
<!-- 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 del worker
Dentro de un worker, self (o this) es el ámbito global—postMessage y onmessage cuelgan de él. No hay window ni document. Los workers pueden usar fetch, importScripts(), setTimeout/setInterval e IndexedDB. importScripts('a.js','b.js') carga sincrónicamente otros scripts en el worker. Cada worker corre en su propio aislamiento.
// 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';
}Enviar mensajes
postMessage(datos, transferibles) envía datos, copiándolos vía structured clone. Pasa un array de ArrayBuffer, MessagePort o ImageBitmap en el segundo argumento para TRANSFERIR la propiedad en lugar de copiar—mucho más rápido para búferes grandes, pero el original queda inservible en el hilo emisor.
<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 transferibles
Los objetos transferibles (ArrayBuffer, MessagePort, ImageBitmap, OffscreenCanvas) se mueven entre hilos sin copiarse. transferControlToOffscreen entrega un canvas a un worker, que luego puede renderizarlo de forma independiente—genial para animaciones suaves mientras el hilo principal está ocupado. El hilo principal pierde el acceso al 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
Un SharedWorker es un único worker compartido por varias pestañas del mismo origen. Cada conexión obtiene un MessagePort vía el evento connect. Úsalo para estado entre pestañas (contadores en vivo, cachés compartidas) o un único fan-out de WebSocket. Los SharedWorkers no están soportados en Safari de iOS y tienen peculiaridades; pruébalos antes de depender de ellos.
<!-- 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
Abrir una conexión
new WebSocket(url) abre una conexión persistente y bidireccional. Usa wss:// (TLS) en producción—ws:// es texto plano y está bloqueado en páginas HTTPS. El readyState va de CONNECTING (0) a OPEN (1) a CLOSING (2) a CLOSED (3). Escucha los eventos open, message, error y 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>Enviar mensajes
send() acepta cadenas, Blobs, ArrayBuffers y ArrayBufferViews. Para datos estructurados, JSON.stringify primero y parse en el otro extremo. Los mensajes se encolan si se envían antes del open, pero por seguridad comprueba readyState === OPEN. El protocolo es full-duplex—cualquiera de los lados puede enviar en cualquier 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>Recibir mensajes
Los eventos message entregan e.data como cadena (texto), Blob (binario por defecto) o ArrayBuffer (fija ws.binaryType = 'arraybuffer'). Para protocolos de texto, JSON es la codificación más común. Para binario, elige Blob para archivos/imágenes y ArrayBuffer para parseo numérico. Define un esquema de mensajes para que ambos lados acuerden la 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>Errores y cierre
Los eventos error llevan pocos detalles por seguridad; comprueba después el evento close. close(code, reason) inicia un apagado limpio; el código 1000 es cierre normal, 1006 significa que la conexión se cayó sin trama de cierre (problema de red). Los códigos 4000-4999 están reservados para la aplicación. wasClean es true solo cuando ambos lados completaron el 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>Reconexión
Los navegadores no se reconectan solos, así que impleméntalo tú con backoff exponencial (retardo = min(base * 2^reintento, max)). Envía pings periódicos para detectar y cerrar sockets muertos. Reconecta en close pero acota el intervalo de reintento para no machacar al servidor. Reinicia el contador de reintentos al conectarte con éxito.
<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) añade una nueva entrada al historial de sesión y actualiza la barra de direcciones sin recargar la página—el núcleo del enrutado del lado del cliente. La URL debe ser del mismo origen o pushState lanza un error. El argumento title es actualmente ignorado por los navegadores. El objeto de estado es serializable y recuperable vía 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 pero reemplaza la entrada actual en lugar de añadir una nueva—de modo que atrás/adelante se saltan la original. Úsalo para actualizar la URL o el estado sin contaminar el historial, por ejemplo, tras aplicar un filtro por el que no quieres que el usuario 'vuelva atrás'.
<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 se dispara cuando el usuario hace clic en atrás/adelante o se llama a history.go/back/forward—no en pushState/replaceState. event.state es el objeto de estado de la entrada a la que se navega. La mayoría de routers de SPA llaman a la función de render tanto en navigate() como en el manejador de popstate para que todas las navegaciones actualicen la vista.
<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>Funciones de navegación
back(), forward() y go(delta) se mueven por el historial de sesión; go(0) recarga. history.length es el número de entradas de la sesión actual, con tope del navegador. Estas funciones son asíncronas—popstate se dispara cuando la navegación se completa. Llamar a go más allá de los límites no hace 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>Enrutado SPA
Un router SPA mínimo: intercepta los clics en enlaces internos, hace pushState para actualizar la URL y renderiza la nueva vista. Maneja popstate para que atrás/adelante funcione. Usa data-link o una clase para marcar los enlaces internos, y salta los externos o con target=_blank. Los frameworks reales añaden rutas anidadas, parámetros, guards y restauración del scroll.
<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 en línea
Elemento time
time representa una fecha, hora o duración concreta. El valor legible por máquina va en el atributo datetime (YYYY-MM-DD, HH:MM o ISO 8601 completo con zona horaria); el texto legible por humanos es el contenido. Los motores de búsqueda y las apps de calendario usan datetime para extraer eventos. Sin datetime, el contenido en sí debe ser una cadena de fecha 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 resalta texto como relevante para el contexto actual del usuario, como coincidencias de términos de búsqueda o notas que el usuario añadió. A diferencia de strong o em, no lleva énfasis semántico—solo resaltado visual. El estilo por defecto es un fondo amarillo. También es útil dentro de blockquotes para marcar el texto al que quien cita quiere llamar la atención.
<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 y summary
details crea un widget de divulgación que el usuario puede expandir o colapsar—sin necesidad de JS. summary es la etiqueta siempre visible; haz clic en ella para alternar. Añade el atributo open para expandir por defecto. El evento toggle se dispara al abrirse o cerrarse. Genial para FAQs, ajustes avanzados y divulgación progresiva de contenido.
<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 una caja modal o no modal. show() lo abre de forma no modal; showModal() lo abre modalmente con un backdrop y el resto de la página inerte. method='dialog' en un formulario cierra el dialog y fija returnValue con el valor del botón clicado. El evento close se dispara tras cerrarse. ::backdrop estiliza la capa superpuesta.
<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 y q
abbr expande abreviaturas vía title (tooltip al pasar el ratón) y ayuda a los lectores de pantalla. cite marca el título de una obra (libro, artículo, película)—no al autor. q es una cita en línea (los navegadores añaden comillas); blockquote es para nivel de bloque. dfn marca la instancia definitoria de un término; los usos posteriores pueden enlazar a ella con 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>Diseño responsivo
Meta viewport
La etiqueta meta viewport indica a los navegadores móviles que usen el ancho del dispositivo como viewport de layout y que empiecen a escala 1. Sin ella, los teléfonos se hacen pasar por 980px de ancho. initial-scale=1 evita el zoom al cargar. viewport-fit=cover te permite usar el área del notch con env(safe-area-inset-*). Evita user-scalable=no—rompe la accesibilidad.
<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 imágenes distintas según condiciones de medios (dirección de arte). El navegador elige la primera source cuyo media coincida e ignora el resto. El img es obligatorio como respaldo y proporciona el texto alt. Úsalo cuando necesites recortar o cambiar por completo la imagen por breakpoint, no solo redimensionarla.
<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 y sizes
srcset lista los candidatos de imagen con su ancho intrínseco (480w = 480px de ancho). sizes indica al navegador cuán ancho se mostrará la imagen en cada breakpoint. El navegador elige entonces el mejor candidato según el viewport y el device pixel ratio—sin JS. Úsalo cuando la misma imagen solo necesita distintas resoluciones.
<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 y vh son porcentajes del ancho/alto del viewport. En móvil, 100vh puede incluir la barra de URL, causando saltos—prefiere dvh (dinámico), svh (pequeño) o lvh (grande). clamp(min, preferido, max) es la forma más limpia de tipografía fluida que no se hace demasiado pequeña ni demasiado grande. vmin/vmax usan la dimensión menor/mayor.
<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 con type
source con type permite servir formatos de imagen modernos con un respaldo JPEG/PNG. El navegador elige el primer type que soporta e ignora el resto. AVIF y WebP ofrecen archivos 30-50% menores que JPEG a igual calidad. Combinado con loading='lazy' en el img, es la forma más eficiente de entregar imágenes.
<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. -->Accesibilidad (ARIA)
Roles ARIA
Los roles ARIA le dicen a las tecnologías de asistencia qué hace un elemento, pero la primera regla de ARIA es: no lo uses si existe un elemento HTML nativo. header, nav, main, article, footer ya exponen los roles banner, navigation, main, article y contentinfo. Usa ARIA para widgets personalizados (tab, dialog, slider, menu) sin equivalente nativo, y emparéjalos con soporte de 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 y aria-labelledby
aria-label proporciona un nombre accesible cuando no existe texto visible (botones de solo icono, etc.). aria-labelledby referencia el id de un texto visible para usarlo como nombre—útil cuando un encabezado ya etiqueta una sección. Prefiere un <label for> visible para los campos del formulario. aria-describedby apunta al texto de pista que se lee después de la etiqueta.
<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' elimina un elemento del árbol de accesibilidad—úsalo para iconos puramente decorativos, texto duplicado o contenido fuera de pantalla que no deba anunciarse. Nunca ocultes elementos enfocables. El patrón .sr-only oculta el texto visualmente manteniéndolo para los lectores de pantalla—esencial para etiquetas que deben hablarse pero no verse.
<!-- 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>Regiones aria-live
aria-live marca regiones cuyas actualizaciones deben anunciarse automáticamente. polite espera una pausa; assertive interrumpe. role='alert' implica assertive y es el estándar para mensajes de error. aria-atomic='true' anuncia toda la región al cambiar; aria-relevant controla qué cambios se verbalizan. Úsalo con moderación—el abuso hace las 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>Gestión del foco
Los usuarios de teclado navegan con Tab; el foco debe ser siempre visible y lógico. :focus-visible estiliza el foco solo para teclado, no para ratón. Al abrir un modal, mueve el foco dentro de él; al cerrarlo, devuelve el foco al disparador. Atrapa Tab dentro del modal para que el foco no escape a contenido oculto. Nunca fijes tabindex > 0; usa 0 para hacer elementos enfocables y -1 para enfocables programáticamente.
<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>Enlaces de salto
Un skip link es el primer elemento enfocable de la página y permite a los usuarios de teclado saltar la navegación repetitiva hasta el contenido principal. Está oculto visualmente hasta recibir el foco. Esencial para la accesibilidad—Criterio de Éxito 2.4.1 de WCAG 2.1. Emparéjalo con un landmark <main id='main'> para que el objetivo sea 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
Elementos personalizados
customElements.define(name, class) registra un elemento personalizado. El nombre debe contener un guion. Hereda de HTMLElement para elementos autónomos, o de una clase concreta como HTMLButtonElement (con is='name') para extender una integrada. Los elementos personalizados son la base de los web components—UI reutilizable e independiente del 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' }) crea un árbol DOM encapsulado adjunto al elemento. Los estilos y ids dentro del árbol shadow no se filtran hacia afuera, y los estilos de la página no se filtran hacia adentro (salvo las propiedades heredables). :host apunta al elemento host; ::slotted() estiliza los hijos slotted. mode: 'closed' bloquea el acceso externo al shadowRoot—rara vez necesario.
<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>Plantillas HTML
El elemento template guarda HTML inerte que se parsea pero no se renderiza hasta clonarse. Accede a su contenido vía template.content, luego cloneNode(true) y añádelo. Las plantillas son perfectas para estructuras repetidas y forman el lado del marcado de los web components. A diferencia de innerHTML, las plantillas pueden contener <tr>, <td>, <option> y otros elementos con peculiaridades de parseo.
<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
Los slots permiten a los consumidores pasar hijos del light-DOM a lugares concretos del árbol shadow. Un <slot name='x'> recibe los hijos con slot='x'; un <slot> sin nombre recibe el resto. Los hijos slotted permanecen en el light DOM—el slot es solo un punto de inserción. Escucha slotchange en el slot para reaccionar cuando cambien los nodos slotted.
<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
Los elementos personalizados tienen callbacks de ciclo de vida: connectedCallback (insertado en el DOM), disconnectedCallback (eliminado), attributeChangedCallback (solo para atributos listados en observedAttributes) y adoptedCallback (movido a un documento nuevo). El constructor corre al crearse—mantenlo ligero. Haz la preparación en connectedCallback y la limpieza en disconnectedCallback. La actualización ocurre automáticamente para elementos ya en el DOM cuando se llama a define().
<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>Aplicaciones sin conexión
Registro del service worker
Un service worker es un script que el navegador ejecuta en segundo plano, separado de la página, que habilita soporte sin conexión, notificaciones push y sincronización en segundo plano. Regístralo desde un script de página; el archivo del SW debe servirse por HTTPS (o localhost) y su ámbito es su directorio por defecto. Una vez instalado, controla las cargas de página vía 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>API de caché
La Cache API almacena pares Request/Response, persistidos entre sesiones. En el evento install, precachea los recursos críticos. En el evento fetch, responde primero desde la caché y recurre a la red (estrategia cache-first). Otras estrategias: network-first, stale-while-revalidate, cache-only, network-only. Incrementa el nombre de la caché para invalidar las entradas antiguas.
// 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))
);
});Respaldo sin conexión
Una estrategia network-first con respaldo sin conexión prueba la red, luego la caché y luego una página genérica offline. El evento activate corre tras completarse install y es el lugar adecuado para eliminar las cachés antiguas—de lo contrario se acumulan. Los clientes pueden reclamar las pestañas existentes de inmediato con self.clients.claim() dentro de 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
Un web app manifest es un archivo JSON que describe cómo debe verse la app al instalarse en la pantalla de inicio. name/short_name, icons, start_url y display (standalone, fullscreen, minimal-ui, browser) son los campos clave. Combinado con un service worker, un manifest hace la app instalable (PWA). theme_color afecta al chrome de la interfaz del sistema operativo.
<!-- 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 vía navigator.serviceWorker.ready.then(r => r.sync.register('tag'))) difiere el trabajo hasta que el usuario tenga conectividad. El navegador dispara un evento sync en el service worker cuando vuelve la red—incluso si la página está cerrada. Úsalo para enviar envíos de formulario en cola, mensajes o analítica. El tag identifica la sincronización; los duplicados se fusionan.
// 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
}
}Buenas prácticas de SEO
Title y meta description
El title (menos de ~60 caracteres) es la señal de SEO en página más importante y aparece como el titular del resultado de búsqueda. La meta description (menos de ~160 caracteres) es el texto del fragmento—no afecta al ranking pero sí al porcentaje de clics. Usa un title por página, incluye la palabra clave principal y hazlo atractivo. canonical evita problemas de contenido 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 y Twitter Cards
Las etiquetas Open Graph controlan cómo se ve tu página al compartirla en Facebook, LinkedIn, Slack y la mayoría de plataformas sociales. og:image debería ser de 1200x630px. Las Twitter Cards usan un conjunto similar con prefijos twitter: (o recurren a OG). Sin estas, los compartidos obtienen una imagen de vista previa aleatoria o ninguna, reduciendo drásticamente el porcentaje de clics.
<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 y hreflang
rel='canonical' indica a los motores de búsqueda qué URL es la versión maestra cuando varias URLs tienen contenido similar (impresión, ordenación, parámetros de query)—evita penalizaciones por contenido duplicado. hreflang apunta a las versiones traducidas o regionales para que Google sirva la correcta. Incluye siempre un x-default para los locales sin coincidencia. Ambos deben ser 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>Datos estructurados (JSON-LD)
Los datos estructurados JSON-LD describen tu página en un formato legible por máquina (vocabulario de schema.org) y habilitan resultados enriquecidos en las búsquedas: carruseles de artículos, migas de pan, FAQs, reseñas, eventos, productos. Ponlo en un <script type='application/ld+json'>. Valida con el Rich Results Test de Google. No impulsa directamente el ranking pero mejora el aspecto de los 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>Encabezados semánticos
Los motores de búsqueda y los lectores de pantalla usan los encabezados para entender el esquema de la página. Usa un h1 (el título de la página), luego h2 para las secciones principales, h3 para las subsecciones—nunca te saltes niveles (no de h2 directo a h4). No elijas un encabezado por su tamaño; usa CSS para el estilo. Una jerarquía de encabezados lógica mejora tanto el SEO como la accesibilidad.
<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>Optimización de rendimiento
preload
rel='preload' indica al navegador que obtenga con prioridad alta un recurso que la página actual necesitará, antes de que normalmente lo descubra. Especifica siempre as (font, style, script, image, fetch, etc.) para que el navegador aplique las prioridades y la CSP correctas. Las fuentes necesitan crossorigin. Usa preload solo para recursos verdaderamente críticos—el abuso desperdicia ancho de 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 y preconnect
preconnect completa DNS, TCP y TLS con un origen por adelantado, ahorrando ~100-300ms cuando ocurre la petición real—úsalo para dominios de terceros críticos. dns-prefetch es la versión más ligera (solo DNS). prefetch obtiene un recurso de prioridad baja para una siguiente navegación probable. Úsalos con moderación: demasiados preconnect desperdician sockets y los recursos precargados pueden no usarse.
<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>Carga diferida
loading='lazy' en img e iframe difiere la carga hasta que el elemento se acerca al viewport—ahorrando ancho de banda y CPU en el render inicial. decoding='async' evita que la decodificación de imágenes bloquee el hilo principal. Fija siempre width/height para evitar saltos de layout. Usa loading='eager' (por defecto) y fetchpriority='high' solo para imágenes hero sobre el pliegue. Soportado en cualquier navegador moderno.
<!-- 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 y async
Un <script> plano bloquea el parseo del HTML mientras se descarga y ejecuta. async descarga en paralelo y corre en cuanto está listo—úsalo para scripts independientes (analítica, anuncios) donde el orden no importa. defer descarga en paralelo pero espera para correr, en orden, tras parsearse el documento—úsalo para los scripts principales de la app que dependen del DOM. Los scripts defer corren antes de 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>Resumen de resource hints
preload (página actual), prefetch (siguiente página), preconnect (handshake de origen) y dns-prefetch (solo DNS) son las sugerencias de recursos principales. prerender está obsoleto en favor de la Speculation Rules API, que puede prerrenderizar páginas completas para una navegación instantánea. Aplica las sugerencias según el comportamiento real de los usuarios—el exceso desperdicia datos y puede perjudicar el rendimiento.
<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>Renderizado crítico
Incrustar el CSS crítico para el contenido sobre el pliegue elimina la petición bloqueante del render y mejora el First Contentful Paint. Carga el resto vía preload+cambio. content-visibility: auto permite al navegador saltarse el renderizado de las secciones fuera de pantalla, mejorando drásticamente el rendimiento de scroll en páginas largas—emparéjalo con contain-intrinsic-size para reservar espacio y evitar saltos de la barra de scroll.
<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>Fragmentos 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?