Curso HTML – Módulo 14: Elementos misceláneos en HTML y APIs avanzadas
Curso HTML – Módulo 14: Elementos misceláneos en HTML y APIs avanzadas
En este módulo de HTML avanzado aprenderás a representar fórmulas, describir datos con significado y guardar información estructurada en el navegador. También verás cómo se comunican dos páginas, qué papel cumple CORS cuando una web consulta una API externa y cómo abrir un canal de datos con WebRTC.
El módulo anterior introdujo Web Storage, WebSocket y Server-Sent Events. Ahora vamos a resolver problemas distintos. Por ejemplo, una aplicación de apuntes necesita almacenar y buscar registros. Un editor con un iframe necesita intercambiar mensajes entre documentos. Una videollamada necesita establecer una conexión entre participantes.
Curso de HTML de TecnoPS
Módulo anterior: 13. APIs web y funcionalidades avanzadas.
Módulo actual: 14. Elementos misceláneos en HTML y APIs avanzadas.
Próximo módulo: 15. Demostraciones y ejemplos prácticos.
Objetivos del módulo
- Escribir fórmulas con MathML.
- Describir el significado de un contenido con microdatos.
- Guardar, recuperar y borrar registros mediante IndexedDB.
- Enviar mensajes entre una página y un iframe con postMessage().
- Entender cuándo interviene CORS y dónde se configura.
- Crear un canal de datos con WebRTC.
- Sustituir elementos y atributos obsoletos por HTML semántico y CSS.
1. HTML avanzado: qué tecnología resuelve cada problema
| Tecnología | Para qué sirve | Ejemplo |
|---|---|---|
| MathML | Representar notación matemática. | Mostrar una fracción en un tutorial. |
| Microdatos | Asociar tipos y propiedades al contenido HTML. | Identificar el nombre y la URL de un curso. |
| IndexedDB | Guardar y consultar registros en el navegador. | Conservar una colección de apuntes. |
| Web Messaging | Intercambiar mensajes entre contextos. | Enviar el tema de color a un iframe. |
| CORS | Controlar el acceso desde otro origen a una respuesta HTTP. | Permitir que un frontend lea los datos de una API. |
| WebRTC | Comunicar participantes mediante audio, vídeo o datos. | Enviar un mensaje a otro participante de una sesión. |
2. Representar fórmulas con MathML
MathML permite describir la estructura de una expresión matemática. Una fracción tiene un numerador y un denominador. Una potencia tiene una base y un exponente. El marcado expresa esas relaciones para que el navegador pueda presentar la fórmula.
El siguiente ejemplo representa la ecuación v = d / t. Debajo, el texto explica qué significa cada símbolo.
<p>La velocidad media se calcula así.</p>
<math display="block">
<mi>v</mi>
<mo>=</mo>
<mfrac>
<mi>d</mi>
<mi>t</mi>
</mfrac>
</math>
<p>La velocidad media es la distancia recorrida dividida entre el tiempo empleado.</p>
| Elemento | Función |
|---|---|
| <math> | Contiene la expresión. |
| <mi> | Representa un identificador, como una variable. |
| <mn> | Representa un número. |
| <mo> | Representa un operador, como + o =. |
| <mfrac> | Recibe el numerador y el denominador. |
| <msup> | Recibe la base y el exponente. |
| <msub> | Recibe la base y el subíndice. |
| <msqrt> | Representa una raíz cuadrada. |
| <mrow> | Agrupa varios elementos de una expresión. |
Potencias y agrupaciones
En (a + b)², el exponente afecta a toda la expresión entre paréntesis. Por eso agrupamos la base con <mrow>.
<math display="block">
<msup>
<mrow>
<mo>(</mo>
<mi>a</mi>
<mo>+</mo>
<mi>b</mi>
<mo>)</mo>
</mrow>
<mn>2</mn>
</msup>
</math>
Usa display=»block» para presentar una fórmula destacada. Para una expresión breve dentro de un párrafo, puedes usar <math> en línea. Comprueba la lectura con los navegadores y tecnologías de asistencia de tu público. En un tutorial, una frase que explique la fórmula también ayuda a interpretar sus símbolos. Especificación MathML Core del W3C.
3. Microdatos y datos estructurados
Al leer «Curso de HTML» en una página puedes deducir que es el nombre de una formación. Con microdatos puedes expresar esa relación de forma explícita mediante atributos HTML. El vocabulario de Schema.org proporciona tipos como Course, Person y Organization.
<article itemscope itemtype="https://schema.org/Course">
<h2 itemprop="name">Curso de HTML de TecnoPS</h2>
<p itemprop="description">
Aprende a estructurar páginas web con ejemplos y ejercicios.
</p>
<p itemprop="provider" itemscope itemtype="https://schema.org/Organization">
Impartido por
<a itemprop="url" href="https://tecnops.es/">
<span itemprop="name">TecnoPS</span>
</a>.
</p>
</article>
- itemscope abre un elemento de datos.
- itemtype identifica su tipo mediante una URL.
- itemprop identifica una propiedad. Su valor depende del elemento. Por ejemplo, en un enlace se toma de href.
- Un elemento con itemprop e itemscope permite describir una propiedad que, a su vez, tiene sus propios datos. Aquí provider es una organización con nombre y URL.
Otra forma de expresar datos estructurados es JSON-LD, que reúne los datos en un bloque separado del contenido visible. En WordPress, revisa el marcado que genera tu plugin SEO antes de añadir una segunda descripción de la misma entidad. Describe el contenido real de la página y distingue entre que el marcado sea válido y que un buscador decida mostrarlo de una forma especial. Microdatos en el estándar HTML · Tipo Course en Schema.org.
4. IndexedDB: una base de datos dentro del navegador
IndexedDB guarda datos estructurados de forma asíncrona. En el módulo 13, localStorage servía para recordar un tema de color. Una colección de apuntes plantea otras necesidades. Cada apunte tiene una clave, un texto y una fecha. Quizá también quieras buscarlo por tema o borrarlo sin reescribir la colección entera.
| Concepto | Qué representa |
|---|---|
| Base de datos | Conjunto de almacenes asociado al origen de la página. |
| Almacén de objetos | Colección de registros, como los apuntes del curso. |
| Clave primaria | Identificador de un registro dentro del almacén. |
| Índice | Permite consultar registros por otra propiedad, como el tema. |
| Transacción | Agrupa operaciones de lectura o escritura. Puede completarse o abortarse. |
La primera vez que abres la base, upgradeneeded permite crear su estructura. Para cambiar esa estructura en una versión futura, incrementa el número de versión y aplica la migración correspondiente. Después de una escritura, espera a transaction.complete antes de anunciar que el registro se guardó. La transacción puede abortarse aunque una solicitud individual haya tenido éxito.
5. Laboratorio de IndexedDB: cuaderno de apuntes
Guarda este archivo como apuntes.html. Sírvelo desde una carpeta de práctica mediante python -m http.server 8000 –bind 127.0.0.1 y abre http://127.0.0.1:8000/apuntes.html. Si en tu equipo el comando es python3, úsalo en lugar de python.
<!doctype html>
<html lang="es">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Cuaderno con IndexedDB</title>
</head>
<body>
<h1>Cuaderno de apuntes</h1>
<form id="formulario">
<label for="texto">Nuevo apunte</label>
<input id="texto" required maxlength="200">
<button id="guardar" disabled>Guardar</button>
</form>
<p id="estado" role="status">Abriendo el cuaderno…</p>
<h2>Apuntes guardados</h2>
<ul id="lista"></ul>
<script>
const formulario = document.querySelector("#formulario");
const texto = document.querySelector("#texto");
const guardar = document.querySelector("#guardar");
const estado = document.querySelector("#estado");
const lista = document.querySelector("#lista");
if ("indexedDB" in window) {
abrirCuaderno();
} else {
estado.textContent = "IndexedDB no está disponible.";
}
function abrirCuaderno() {
let apertura;
try {
apertura = indexedDB.open("curso-html-cuaderno", 1);
} catch {
estado.textContent = "No se pudo acceder al almacenamiento.";
return;
}
apertura.addEventListener("upgradeneeded", () => {
apertura.result.createObjectStore("apuntes", {
keyPath: "id",
autoIncrement: true
});
});
apertura.addEventListener("error", () => {
estado.textContent = "No se pudo abrir el cuaderno.";
});
apertura.addEventListener("blocked", () => {
estado.textContent = "Cierra las otras pestañas del cuaderno y vuelve a intentarlo.";
});
apertura.addEventListener("success", () => iniciar(apertura.result));
}
function iniciar(base) {
let disponible = true;
base.addEventListener("versionchange", () => {
disponible = false;
base.close();
guardar.disabled = true;
lista.replaceChildren();
estado.textContent = "La base de datos ha cambiado. Recarga la página.";
});
function mostrarApuntes() {
if (!disponible) return;
const transaccion = base.transaction("apuntes", "readonly");
const consulta = transaccion.objectStore("apuntes").getAll();
transaccion.addEventListener("abort", () => {
estado.textContent = "No se pudieron leer los apuntes.";
});
transaccion.addEventListener("complete", () => {
if (!disponible) return;
const elementos = consulta.result.map((apunte) => {
const elemento = document.createElement("li");
const borrar = document.createElement("button");
borrar.type = "button";
borrar.textContent = "Borrar";
borrar.setAttribute("aria-label", "Borrar apunte: " + apunte.texto);
borrar.addEventListener("click", () => {
const cambio = base.transaction("apuntes", "readwrite");
cambio.objectStore("apuntes").delete(apunte.id);
cambio.addEventListener("complete", () => {
estado.textContent = "Apunte borrado.";
mostrarApuntes();
texto.focus();
});
cambio.addEventListener("abort", () => {
estado.textContent = "No se pudo borrar el apunte.";
});
});
elemento.append(apunte.texto + " ", borrar);
return elemento;
});
lista.replaceChildren(...elementos);
});
}
formulario.addEventListener("submit", (evento) => {
evento.preventDefault();
const contenido = texto.value.trim();
if (!disponible || !contenido) return;
guardar.disabled = true;
texto.readOnly = true;
const cambio = base.transaction("apuntes", "readwrite");
cambio.objectStore("apuntes").add({
texto: contenido,
creadoEn: Date.now()
});
cambio.addEventListener("complete", () => {
texto.value = "";
texto.readOnly = false;
guardar.disabled = !disponible;
estado.textContent = "Apunte guardado.";
mostrarApuntes();
});
cambio.addEventListener("abort", () => {
texto.readOnly = false;
guardar.disabled = !disponible;
estado.textContent = "No se pudo guardar el apunte.";
});
});
guardar.disabled = false;
estado.textContent = "Cuaderno preparado.";
mostrarApuntes();
}
</script>
</body>
</html>
Guarda dos apuntes y recarga. Los registros deben volver a aparecer. Después borra uno y recarga de nuevo. Prueba a guardar el texto <b>Mi apunte</b>. Debe aparecer escrito tal cual, porque el ejemplo añade el valor como texto.
getAll() resulta cómodo para una colección pequeña. Si trabajas con miles de registros, utiliza índices, límites o cursores para leer solo los datos que necesitas. El navegador puede eliminar datos locales según sus políticas y ajustes. Si el usuario necesita conservar su trabajo en otros dispositivos, añade una opción de exportación o sincronización. Especificación de IndexedDB.
6. Web Messaging: enviar mensajes entre páginas
Una página y un iframe tienen ventanas distintas. Con window.postMessage() puedes enviar un mensaje a otra ventana sin acceder directamente a su DOM. El receptor recibe un evento message con el dato, el origen y una referencia a la ventana que lo envió.
En este ejercicio, la página principal pide a un iframe que cambie su esquema de color. Los dos archivos comparten origen para facilitar la prueba. Guárdalos en la misma carpeta que el ejercicio anterior.
Archivo mensajeria.html
<!doctype html>
<html lang="es">
<head>
<meta charset="utf-8">
<title>Página principal</title>
</head>
<body>
<h1>Enviar un tema al iframe</h1>
<button id="tema" type="button" disabled>Cambiar tema del visor</button>
<p id="estado" role="status">Cargando visor…</p>
<iframe id="visor" title="Visor de temas"></iframe>
<script>
const visor = document.querySelector("#visor");
const boton = document.querySelector("#tema");
const estado = document.querySelector("#estado");
const origenVisor = location.origin;
let tema = "claro";
window.addEventListener("message", (evento) => {
if (evento.origin !== origenVisor || evento.source !== visor.contentWindow) return;
const datos = evento.data;
if (datos?.tipo === "visor-listo") {
boton.disabled = false;
estado.textContent = "Visor preparado.";
}
if (datos?.tipo === "tema-aplicado" &&
(datos.tema === "claro" || datos.tema === "oscuro")) {
estado.textContent = `El visor ha aplicado el tema ${datos.tema}.`;
}
});
boton.addEventListener("click", () => {
tema = tema === "claro" ? "oscuro" : "claro";
visor.contentWindow.postMessage({ tipo: "cambiar-tema", tema }, origenVisor);
});
visor.src = "./visor.html";
</script>
</body>
</html>
Archivo visor.html
<!doctype html>
<html lang="es">
<head>
<meta charset="utf-8">
<title>Visor de temas</title>
</head>
<body>
<p>Este texto pertenece al iframe.</p>
<script>
const origenPadre = location.origin;
document.body.style.backgroundColor = "Canvas";
document.body.style.color = "CanvasText";
window.addEventListener("message", (evento) => {
if (evento.origin !== origenPadre || evento.source !== window.parent) return;
const datos = evento.data;
if (datos?.tipo !== "cambiar-tema") return;
if (datos.tema !== "claro" && datos.tema !== "oscuro") return;
document.documentElement.style.colorScheme =
datos.tema === "oscuro" ? "dark" : "light";
window.parent.postMessage({
tipo: "tema-aplicado",
tema: datos.tema
}, origenPadre);
});
window.parent.postMessage({ tipo: "visor-listo" }, origenPadre);
</script>
</body>
</html>
Abre http://127.0.0.1:8000/mensajeria.html. El iframe anuncia que está listo, la página activa el botón y, al pulsarlo, el visor confirma el tema aplicado.
Si los archivos viven en orígenes diferentes, configura el origen esperado de cada extremo. En el envío, targetOrigin limita dónde se entrega el mensaje. En la recepción, comprueba event.origin, event.source y los campos de event.data antes de actuar. Web Messaging en el estándar HTML.
7. CORS: cuando el frontend y la API tienen orígenes distintos
CORS significa Cross-Origin Resource Sharing. El navegador aplica este protocolo al determinar si un script puede acceder a una respuesta de otro origen. Dos direcciones tienen distinto origen si cambia el protocolo, el host o el puerto.
Imagina que el frontend se sirve en http://127.0.0.1:8000 y la API en http://127.0.0.1:3100. Como cambia el puerto, la API debe responder con las cabeceras CORS apropiadas para que el JavaScript del frontend pueda leer los datos.
Access-Control-Allow-Origin: http://127.0.0.1:8000 Vary: Origin
Para algunas solicitudes, como un POST con Content-Type: application/json, el navegador envía antes una petición OPTIONS. Esta comprobación se llama preflight. La respuesta indica qué origen, método y cabeceras permite el servidor. Si el preflight falla, el navegador detiene el envío de la solicitud prevista. En peticiones que no requieren preflight, el servidor puede recibir la solicitud aunque el navegador después impida que el script lea su respuesta.
Prueba local con dos puertos
Deja la página de práctica abierta en http://127.0.0.1:8000. En otra terminal, guarda y ejecuta el siguiente archivo con node api-cors.cjs. Usa la misma dirección en el navegador. localhost y 127.0.0.1 identifican hosts distintos para esta comprobación.
const http = require("node:http");
const origenPermitido = "http://127.0.0.1:8000";
http.createServer((peticion, respuesta) => {
if (peticion.method !== "GET" || peticion.url !== "/saludo") {
respuesta.writeHead(404);
respuesta.end();
return;
}
respuesta.setHeader("Vary", "Origin");
if (peticion.headers.origin === origenPermitido) {
respuesta.setHeader("Access-Control-Allow-Origin", origenPermitido);
}
respuesta.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
respuesta.end(JSON.stringify({ mensaje: "Hola desde el puerto 3100" }));
}).listen(3100, "127.0.0.1", () => {
console.log("API disponible en http://127.0.0.1:3100/saludo");
});
Desde la consola de la página servida en el puerto 8000, ejecuta este código.
fetch("http://127.0.0.1:3100/saludo")
.then((respuesta) => {
if (!respuesta.ok) {
throw new Error(`Error HTTP ${respuesta.status}`);
}
return respuesta.json();
})
.then(console.log)
.catch(console.error);
El navegador debe mostrar el saludo. Cambia temporalmente el origen permitido a http://127.0.0.1:8001, reinicia la API y repite desde el puerto 8000. El panel de red te permite comparar la respuesta del servidor con el error que recibe JavaScript.
- Permisos de lectura. Configura CORS en el servidor que responde. Enviar Access-Control-Allow-Origin desde fetch() no concede acceso.
- Credenciales. Si la solicitud usa credenciales entre orígenes, el servidor debe indicar el origen concreto y permitir credenciales con Access-Control-Allow-Credentials: true. Las cookies también están sujetas a sus propios atributos y a las políticas del navegador.
- Respuestas opacas. Una solicitud permitida con mode: «no-cors» a otro origen puede devolver una respuesta opaca. El script no puede leer su cuerpo como JSON.
- Autorización. Comprueba en el servidor quién puede consultar o modificar cada recurso. CORS regula el acceso a la respuesta desde el navegador.
Protocolo CORS en el estándar Fetch.
8. WebRTC: audio, vídeo y datos entre participantes
WebRTC permite establecer una conexión para compartir medios o datos. Una aplicación de videollamadas puede enviar audio y vídeo. Una herramienta colaborativa puede utilizar un canal de datos para intercambiar acciones entre participantes.
| Concepto | Papel en la conexión |
|---|---|
| RTCPeerConnection | Gestiona la conexión entre dos extremos. |
| Oferta y respuesta | Describen los parámetros que negocian ambos extremos. |
| Señalización | Intercambia esas descripciones y candidatos. La aplicación elige el canal, por ejemplo WebSocket. |
| ICE | Reúne y comprueba posibles rutas de conexión. |
| STUN | Ayuda a descubrir cómo aparece un extremo desde fuera de su red. |
| TURN | Puede retransmitir el tráfico cuando la ruta requiere un servidor intermedio. |
| RTCDataChannel | Permite intercambiar datos, como texto o mensajes binarios. |
Para una llamada, getUserMedia() solicita acceso a la cámara o al micrófono en un contexto seguro y entrega pistas multimedia. Puedes agregarlas a la conexión con addTrack() y recibir las del otro extremo mediante el evento track. Al finalizar la captura local, detén las pistas con track.stop().
9. Laboratorio WebRTC: dos extremos en una página
Guarda este archivo como webrtc-local.html y ábrelo desde el servidor HTTP local. La página contiene los dos extremos de la conexión y pasa los datos de señalización directamente entre ellos. En este caso esperamos a reunir los candidatos ICE antes de compartir cada descripción. El canal transmite texto y se abre al pulsar el botón.
<!doctype html>
<html lang="es">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Canal de datos WebRTC</title>
</head>
<body>
<h1>Canal de datos WebRTC</h1>
<button id="conectar" type="button">Conectar</button>
<button id="cerrar" type="button" disabled>Cerrar conexión</button>
<p id="estado" role="status">Conexión cerrada.</p>
<form id="formulario">
<label for="mensaje">Mensaje de A para B</label>
<input id="mensaje" required maxlength="200">
<button id="enviar" disabled>Enviar</button>
</form>
<p id="recibido" role="status"></p>
<script>
const conectar = document.querySelector("#conectar");
const cerrar = document.querySelector("#cerrar");
const enviar = document.querySelector("#enviar");
const mensaje = document.querySelector("#mensaje");
const estado = document.querySelector("#estado");
const recibido = document.querySelector("#recibido");
let extremoA;
let extremoB;
let canal;
function esperarCandidatos(conexion) {
if (conexion.iceGatheringState === "complete") {
return Promise.resolve();
}
return new Promise((resolver, rechazar) => {
const temporizador = setTimeout(() => {
conexion.removeEventListener("icegatheringstatechange", comprobar);
rechazar(new Error("Tiempo agotado al reunir candidatos ICE."));
}, 8000);
function comprobar() {
if (conexion.iceGatheringState === "complete") {
clearTimeout(temporizador);
conexion.removeEventListener("icegatheringstatechange", comprobar);
resolver();
}
}
conexion.addEventListener("icegatheringstatechange", comprobar);
});
}
function limpiar(mensajeEstado) {
canal?.close();
extremoA?.close();
extremoB?.close();
canal = null;
extremoA = null;
extremoB = null;
enviar.disabled = true;
cerrar.disabled = true;
conectar.disabled = false;
estado.textContent = mensajeEstado;
}
conectar.addEventListener("click", async () => {
conectar.disabled = true;
recibido.textContent = "";
estado.textContent = "Negociando conexión…";
try {
extremoA = new RTCPeerConnection();
extremoB = new RTCPeerConnection();
extremoB.addEventListener("datachannel", ({ channel }) => {
channel.addEventListener("message", ({ data }) => {
recibido.textContent = `B ha recibido: ${data}`;
});
});
canal = extremoA.createDataChannel("mensajes");
const canalActual = canal;
canalActual.addEventListener("open", () => {
if (canal !== canalActual) return;
enviar.disabled = false;
estado.textContent = "Canal abierto.";
});
canalActual.addEventListener("close", () => {
if (canal === canalActual) limpiar("Canal cerrado.");
});
await extremoA.setLocalDescription(await extremoA.createOffer());
await esperarCandidatos(extremoA);
await extremoB.setRemoteDescription(extremoA.localDescription);
await extremoB.setLocalDescription(await extremoB.createAnswer());
await esperarCandidatos(extremoB);
await extremoA.setRemoteDescription(extremoB.localDescription);
cerrar.disabled = false;
} catch (error) {
limpiar(`No se pudo establecer la conexión. ${error.message}`);
}
});
document.querySelector("#formulario").addEventListener("submit", (evento) => {
evento.preventDefault();
const texto = mensaje.value.trim();
if (canal?.readyState === "open" && texto) {
canal.send(texto);
mensaje.value = "";
}
});
cerrar.addEventListener("click", () => {
limpiar("Conexión cerrada.");
});
</script>
</body>
</html>
Pulsa Conectar, espera a que se abra el canal y envía un mensaje. Debe aparecer debajo del formulario como texto recibido por B. Pulsa Cerrar conexión y vuelve a conectar para repetir el ejercicio.
Para llevar este ejemplo a dos equipos, cada navegador crearía su propia conexión. La aplicación tendría que intercambiar las descripciones y los candidatos mediante un canal de señalización. El WebSocket del módulo 13 puede servir como punto de partida para ese intercambio. La prueba local permite estudiar la negociación, mientras que una prueba entre redes distintas permite comprobar si hace falta configurar TURN. Especificación WebRTC del W3C.
10. Etiquetas obsoletas y alternativas modernas
Al mantener una web antigua puedes encontrar elementos que los navegadores siguen interpretando por compatibilidad. Para actualizarlos, identifica primero qué intención tenía el marcado. Después decide qué corresponde a la estructura del documento y qué se resuelve con CSS o JavaScript.
| Marcado antiguo | Alternativa |
|---|---|
| <font> | Aplica color, font-family y font-size con CSS. |
| <center> | Usa text-align: center para texto o alinea el bloque con márgenes, Flexbox o Grid. |
| <big> | Ajusta el tamaño con CSS. Usa un encabezado si el texto introduce una sección. |
| <marquee> | Presenta el aviso como texto. Si el movimiento cumple una función, ofrece controles y respeta la preferencia de movimiento reducido. |
| <strike> | Usa <del> para una eliminación del documento o <s> para información que ya no es válida. |
| Tablas usadas para maquetar | Reserva las tablas para datos y distribuye el contenido mediante CSS. |
Ejemplo de migración
<!-- Marcado antiguo --> <center><font color="blue" size="5">Material de estudio</font></center> <!-- Si introduce una sección, utiliza un encabezado --> <h2 class="titulo-material">Material de estudio</h2>
.titulo-material {
text-align: center;
color: #155397;
font-size: 1.5rem;
}
<b>, <i> y <u> siguen teniendo usos definidos en HTML. Elige el elemento según el significado. Por ejemplo, <strong> indica importancia y <em> indica énfasis. Cuando solo quieras cambiar la apariencia, puedes aplicar una clase de CSS. Elementos y atributos obsoletos en el estándar HTML.
11. Errores frecuentes y buenas prácticas
- El exponente solo afecta a una letra. Agrupa la base completa con <mrow> antes de usar <msup>.
- El tipo de los microdatos aparece vacío. Comprueba que has declarado itemscope y que itemtype apunta al tipo que quieres describir.
- La actualización de IndexedDB queda bloqueada. Revisa si otra pestaña mantiene abierta una conexión con la versión anterior.
- Un iframe ignora el mensaje. Comprueba el protocolo, host y puerto de ambos orígenes, y verifica que el receptor ya registró el evento message.
- La API responde, pero fetch() falla. Inspecciona la cabecera Origin de la petición y compara su valor con Access-Control-Allow-Origin. Si hay preflight, revisa también la respuesta a OPTIONS.
- WebRTC conecta en local, pero falla entre redes. Revisa el intercambio de candidatos y comprueba si ambos extremos disponen de una ruta directa o de una ruta mediante TURN.
12. Ejercicios prácticos
- Fórmula matemática. Representa el teorema de Pitágoras con <msup> y añade una frase que explique qué representa cada variable.
- Microdatos. Describe dos cursos con nombre y descripción. Añade a cada uno una organización como proveedor y verifica qué propiedades pertenecen a cada elemento.
- Cuaderno de apuntes. Muestra la fecha de creación junto a cada registro. Añade varios apuntes y comprueba que las fechas se conservan al recargar.
- Mensajería. Añade un botón en el iframe que envíe un mensaje propio a la página principal. Define un tipo nuevo y comprueba su origen antes de mostrarlo.
- CORS. Abre la misma página mediante localhost y 127.0.0.1. Compara el valor de Origin y explica por qué el resultado cambia.
- WebRTC. Amplía el laboratorio para que B responda a A por el mismo canal. Comprueba que puedes cerrar y volver a abrir la conexión.
13. Ejercicios avanzados
Clasificar y buscar apuntes
Añade un campo tema al cuaderno. Aumenta la versión de la base a 2 y crea un índice sobre esa propiedad durante upgradeneeded. Conserva los apuntes de la versión anterior y decide cómo mostrar los que todavía no tienen tema. Comprueba que puedes listar todos los apuntes y filtrar por uno de los temas nuevos.
Observar un preflight
Amplía la API de práctica con un POST /saludo que acepte JSON. Implementa la respuesta a OPTIONS para el origen permitido y declara POST y Content-Type como método y cabecera autorizados. Abre el panel de red y comprueba en qué orden aparecen OPTIONS y POST.
Actualizar una página antigua
Crea una página de prueba con <font>, <center> y una tabla utilizada para maquetar. Migra el contenido a encabezados, párrafos y CSS. Aplica lo aprendido sobre columnas y tamaños adaptables en el módulo 11. Comprueba que puedes ampliar el texto y recorrer todos los enlaces con el teclado.
14. Conclusión
Una página de formación puede usar MathML para sus fórmulas, microdatos para describir sus cursos e IndexedDB para conservar apuntes en el equipo del estudiante. Si añade un visor en un iframe, postMessage() permite coordinarlo con la página principal. Si consulta una API en otro origen, el servidor debe configurar CORS. Para una sesión entre participantes, WebRTC introduce la negociación y los canales de medios o datos.
En el próximo módulo reuniremos estructura, estilos e interacción en demostraciones completas que puedas adaptar a tus propios proyectos.
Módulo anterior: 13. APIs web y funcionalidades avanzadas.
Siguiente módulo: 15. Demostraciones y ejemplos prácticos.
Otra lectura del curso: Módulo 9. Medios en HTML.
