2. Primeros pasos con React
2.1. Ejemplo 01: la estructura de una aplicación React
2.1.1. El archivo package.json
El archivo [package.json] de la carpeta examples declara las bibliotecas utilizadas y los comandos del proyecto:
| {
"name": "examples-react",
"private": true,
"version": "1.0.0",
"type": "module",
"scripts": {
"start": "vite --config vite.config.ts",
"build": "vite build --config vite.config.ts",
"check": "tsc --noEmit"
},
"dependencies": {
"@tanstack/react-query": "^5.104.0",
"bootstrap": "^5.3.8",
"i18next": "^26.4.2",
"react": "^19.3.0",
"react-dom": "^19.3.0",
"react-hook-form": "^7.89.0",
"react-i18next": "^17.0.15",
"react-router": "^8.4.0",
"zustand": "^5.0.15"
},
"devDependencies": {
"@types/react": "^19.2.18",
"@types/react-dom": "^19.2.7",
"@vitejs/plugin-react": "^6.1.1",
"typescript": "~6.0.2",
"vite": "^8.3.0"
}
}
|
Analicemos este archivo:
- Línea 5: los archivos [JavaScript] del proyecto son módulos ES ([import] / [export]), que es el estándar actual del lenguaje;
- Líneas 6–10: los comandos del proyecto, que se lanzan con [npm run <name>] (o [npm start] para el comando [start]):
- [npm start 05-controlled-fields] lanza [vite --config vite.config.ts 05-controlled-fields]: el servidor de desarrollo del ejemplo 05;
- [npm run build 05-controlled-fields] lanza [vite build ...]: la versión de producción del ejemplo 05, ubicada en la carpeta [05-controlled-fields/dist/];
- [npm run check] lanza el compilador [TypeScript] ([tsc]), que verifica los tipos de TODOS los ejemplos sin generar nada ([--noEmit]);
- líneas 11–21: las bibliotecas que la aplicación necesita en el navegador: [react] (el núcleo: componentes, estado, hooks) y [react-dom] (visualización en una página web), [react-router] (el enrutador, ejemplos 17 y 18), [react-hook-form] (ejemplo 08), [zustand] (ejemplo 20), [i18next] y [react-i18next] (idiomas, ejemplo 21), [@tanstack/react-query] (lectura de datos del servidor, ejemplo 24) y [Bootstrap] para el formato;
- Líneas 22–28: herramientas de desarrollo: [Vite] ([vite]), su complemento para [React] ([@vitejs/plugin-react]), el compilador de [TypeScript] y las descripciones de tipos de [React] para [TypeScript] ([@types/react], [@types/react-dom]). No forman parte de la aplicación entregada a los usuarios.
El prefijo [^] en una versión ([^19.3.0]) permite que [npm] instale una versión más reciente de la misma versión mayor (19.x.y); el prefijo [~] ([~6.0.2]) permite solo correcciones urgentes (6.0.x).
En un proyecto estándar, este archivo se crea con el comando [npm create vite@latest project-name -- --template react-ts], que genera una aplicación [React] completa y lista para ejecutarse. Los ejemplos de este curso se escribieron a mano para poder incluir veinticinco de ellos en una sola carpeta.
2.1.2. El archivo vite.config.ts
[Vite] es la herramienta de compilación recomendada para una aplicación [React]: un servidor de desarrollo muy rápido y un compilador de producción. Su configuración, común a todos los ejemplos:
| // =========================================================================
// vite.config.ts - la configuración de Vite, común a todos los ejemplos
// -------------------------------------------------------------------------
// Vite es la herramienta de compilación de React: un servidor de desarrollo
// (npm start) y un compilador de producción (npm run build). Cada
// ejemplo es una carpeta que tiene su propia página index.html; su
// nombre se le da a Vite, que lo convierte en la RAÍZ de la aplicación:
//
// npm start 05-controlled-fields -> vite --config vite.config.ts 05-controlled-fields
// npm run build 05-controlled-fields -> el resultado en 05-controlled-fields/dist/
// =========================================================================
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
export default defineConfig({
// el plugin de React: la sintaxis JSX y la recarga "en caliente" (una
// modificación del código actualiza la página sin perder el estado mostrado)
plugins: [react()],
server: {
port: 5173,
// el PROXY: toda solicitud del navegador a /api/... se reenvía
// al servidor JSON de RdvMedecins (puerto 8080). Solo se usa a partir del
// ejemplo 22 (cf. el capítulo "Comunicarse con el servidor").
proxy: {
'/api': 'http://localhost:8080',
},
},
});
|
- líneas 9–10 (comentario): el nombre del ejemplo, proporcionado al comando, se convierte en la raíz ([root]) de la aplicación: [Vite] busca allí la página [index.html] y la carpeta [public/], y almacena allí el resultado de la compilación ([dist/]);
- línea 19: el complemento de [React]: compila la sintaxis JSX (véase más adelante) y habilita la recarga en caliente: un cambio en el código de un componente se aplica a la página sin recargarla, conservando en lo posible el estado mostrado;
- línea 21: el puerto del servidor de desarrollo;
- líneas 25–27: el proxy, que solo se utilizará a partir del ejemplo 22: toda solicitud del navegador a una dirección que comience con [/api] se reenvía al servidor JSON [RdvMedecins]. Volveremos sobre esto más adelante.
2.1.3. El archivo tsconfig.json
La configuración de [TypeScript] común a todos los ejemplos:
| {
"compilerOptions": {
"target": "ES2023",
"lib": ["ES2023", "DOM", "DOM.Iterable"],
"module": "ESNext",
"moduleResolution": "bundler",
"types": ["vite/client"],
"jsx": "react-jsx",
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"noFallthroughCasesInSwitch": true,
"noImplicitReturns": true,
"verbatimModuleSyntax": true,
"erasableSyntaxOnly": true,
"resolveJsonModule": true,
"skipLibCheck": true,
"noEmit": true
},
"include": ["*/src", "common", "vite.config.ts"]
}
|
- líneas 3–6: código [JavaScript] moderno (ES2023), definiciones del navegador ([DOM]) y módulos resueltos como lo hace la herramienta de compilación;
- línea 7: definiciones específicas de [Vite] (por ejemplo, se permite importar una hoja de estilos, [import './App.css']);
- línea 8: la sintaxis JSX se acepta y se compila para [React];
- Líneas 9–13: el modo estricto de [TypeScript] (tipos verificados estrictamente, incluidos [null] y [undefined]) y verificaciones adicionales: una variable o un parámetro sin usar se informa como error;
- línea 14: una importación que se aplica solo a tipos se escribe como [import type { ... }] (o [import { type X }]): esto indica a la herramienta de compilación que ya no existe en el archivo [JavaScript] generado;
- línea 16: un archivo con nombre JSON puede importarse como módulo (ejemplo 21);
- línea 18: [tsc] solo verifica los tipos; es [Vite] quien realmente compila el código (simplemente elimina los tipos sin verificarlos: de ahí el comando [npm run check]);
- línea 20: los archivos que se verifican: los de todos los ejemplos.
El editor [VS Code] utiliza esta configuración: un error tipográfico en un componente ([{titl}] en lugar de [{title}]) se subraya en rojo en cuanto se escribe.
2.1.4. La página index.html
Cada ejemplo tiene su propia página HTML. La página del ejemplo 01:
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Example 01 - a first application</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<!-- la aplicación React se muestra en este elemento (cf. src/main.tsx) -->
<div id="root"></div>
<!-- el punto de entrada: un módulo JavaScript, compilado sobre la marcha por Vite -->
<script type="module" src="/src/main.tsx"></script>
</body>
</html>
|
Esta es la única página que cargará el navegador. Está casi vacía:
- línea 10: el elemento en el que [React] mostrará la aplicación;
- línea 12: el punto de entrada de la aplicación, un módulo [TypeScript]. El navegador no entiende [TypeScript]: es [Vite] quien compila este archivo —y los archivos que importa— cuando el navegador los solicita.
Aquí no hay etiquetas [<link>]: las hojas de estilo las importa el código (véase [main.tsx]), y [Vite] las agrega a la página por sí mismo.
2.1.5. El punto de entrada: main.tsx
| // =========================================================================
// 01-first-application/src/main.tsx - el punto de entrada de la aplicación
// -------------------------------------------------------------------------
// index.html carga este archivo. Inicia la aplicación React:
// 1. createRoot(element): React toma posesión del elemento <div id="root">
// de la página;
// 2. root.render(<App />): muestra en él el componente RAÍZ, App.
// Las hojas de estilo son módulos como cualquier otro: se importan.
// =========================================================================
import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App';
// el "!" le indica a TypeScript: este elemento existe (está en index.html)
createRoot(document.getElementById('root')!).render(
// StrictMode: solo en desarrollo, React realiza verificaciones
// adicionales (cf. ejemplo 13). No muestra nada por sí mismo.
<StrictMode>
<App />
</StrictMode>,
);
|
Un archivo [.tsx] es un archivo [TypeScript] que contiene JSX.
- Línea 12: la función de [react-dom] que lanza una aplicación dentro de una página web;
- línea 13: la hoja de estilos de [Bootstrap]: una importación sin nombre, utilizada únicamente para agregarla a la página;
- Línea 14: el componente raíz de la aplicación, la función exportada por [App.tsx];
- línea 17: [React] toma el control del elemento [<div id="root">]. [document.getElementById('root')] puede devolver [null] para [TypeScript]: [!] afirma que existe;
- líneas 20–22: [render(...)] muestra el componente [App] dentro de este elemento. [<App />] forma parte de JSX: el uso del componente [App] como una etiqueta. [<StrictMode>] es un componente de [React], que no muestra nada por sí mismo, pero habilita verificaciones adicionales durante el desarrollo (ejemplo 13).
2.1.6. Los componentes raíz: App.tsx y App.css
Un componente [React] es una función:
| // =========================================================================
// 01-first-application/src/App.tsx - un primer componente
// -------------------------------------------------------------------------
// Un componente de React es una FUNCIÓN, cuyo nombre empieza con una
// letra mayúscula, que DEVUELVE lo que debe mostrarse, escrito en JSX: HTML
// dentro del código TypeScript. React llama a esta función para construir la
// página; la llama DE NUEVO cada vez que cambia el estado del componente, y
// actualiza la página con el nuevo resultado.
// =========================================================================
import { useState } from 'react';
// una hoja de estilo, importada por el componente que la usa
import './App.css';
// datos "ordinarios", fuera del componente: nunca cambian
const title = 'Welcome to React';
const languages = ['TypeScript', 'HTML', 'CSS'];
export default function App() {
// useState(0): un fragmento de ESTADO, con valor inicial 0. Obtenemos su
// valor ACTUAL (counter) y la función que lo cambia (setCounter).
// Llamar a setCounter le pide a React que llame a App DE NUEVO para actualizar
// la página. Nunca modificamos la página nosotros mismos.
const [counter, setCounter] = useState(0);
const [time, setTime] = useState(() => new Date().toLocaleTimeString());
// una función llamada por el botón
function increment() {
setCounter((n) => n + 1);
setTime(new Date().toLocaleTimeString());
}
// el JSX devuelto: { expresión } inserta el valor de una expresión;
// className reemplaza al atributo HTML class (una palabra reservada en JavaScript)
return (
<div className="container py-4">
<h1 className="h3">{title}</h1>
<p>This page is built in the browser, by React, from index.html, main.tsx and the App component.</p>
<p>
It is written in {languages.join(', ')} ({languages.length} languages).
</p>
{/* onClick: la función a llamar al hacer clic (cf. ejemplo 04) */}
<button className="btn btn-primary" onClick={increment}>
Click me
</button>
<p className="mt-3 counter">
You clicked {counter} times (last click: {time}).
</p>
</div>
);
}
|
- Línea 11: el hook [useState], proporcionado por [React];
- línea 13: la hoja de estilos del componente;
- líneas 16–17: dos datos ordinarios, declarados fuera del componente: nunca cambian;
- línea 19: el componente: una función cuyo nombre comienza con una letra mayúscula (así distingue JSX un componente, [<App />], de un elemento HTML, [<div>]). [export default]: es lo que el módulo exporta por defecto, importado en [main.tsx] mediante [import App from './App'];
- Línea 24: [useState(0)] crea una variable de estado con un valor inicial de 0. Devuelve un arreglo de dos elementos, que "desempaquetamos": el valor actual ([counter]) y la función que lo cambia ([setCounter]). El estado lo almacena [React]: persiste de una llamada a la función a la siguiente;
- Línea 25: se puede pasar una función a [useState] que calcule el valor inicial; se llama solo la primera vez que se muestra la página;
- Líneas 28–30: una función llamada por el botón. No modifica la página; cambia el estado. [setCounter((n) => n + 1)] calcula el nuevo valor a partir del anterior. Cada llamada a la función [setXxx] indica a [React] que llame a [App]; [React] compara el nuevo resultado con el anterior y actualiza solo las partes de la página que han cambiado;
- líneas 35–51: el JSX devuelto, es decir, lo que debe mostrarse:
- el JSX se parece al HTML, con algunas diferencias: el atributo [class] se escribe [className] ([class] es una palabra reservada de [JavaScript]), cada etiqueta debe cerrarse ([<br />], [<input />]) y toda la estructura debe tener UN solo elemento raíz;
- Línea 37: [{ expression }] inserta el valor de una expresión [TypeScript]. Se escapa: si [title] contuviera [<b>], [<b>] se mostraría sin que la etiqueta se interprete;
- línea 40: la expresión puede ser cualquier cosa: una llamada a un método, un cálculo;
- línea 43: un comentario en JSX se escribe [{/* ... */}];
- línea 44: al hacer clic en el botón se llama a la función [increment] (véase el ejemplo 04). La función se proporciona sin paréntesis: [onClick={increment()}] la llamaría de inmediato, mientras se muestra la página;
- línea 48: el valor actual del estado. Cuando el estado cambia, se vuelve a llamar a [App] y este texto cambia.
JSX no es lo mismo que HTML: es una notación cómoda para llamadas a funciones. El compilador transforma [<h1 className="h3">{title}</h1>] en una llamada de la forma [jsx('h1', { className: 'h3', children: title })], que crea un objeto que describe el elemento. Por lo tanto, el componente devuelve un árbol de objetos (el "DOM virtual"), que [React] compara con el árbol anterior para determinar qué cambiar en la página real.
Y su hoja de estilos:
| /* una hoja de estilo importada por App.tsx; ADVERTENCIA: se aplica a toda la
página, y no solo al componente App (cf. ejemplo 10) */
.counter {
font-weight: bold;
color: #087ea4;
}
|
A diferencia de [Angular] o [Vue.js], [React] no aísla los estilos de un componente: una hoja de estilos importada se aplica a toda la página. El ejemplo 10 mostrará los "módulos CSS", que restringen una clase a un solo componente.
2.1.7. Ejecución
En la consola abierta en la carpeta [examples-react]:
npm start 01-first-application
La consola muestra:
| > examples-react@1.0.0 start
> vite --config vite.config.ts 01-first-application
VITE v8.3.1 ready in 264 ms
➜ Local: http://localhost:5173/
➜ Network: use --host to expose
|
Abra la URL http://localhost:5173/ y haga clic tres veces en el botón:

Dos experimentos para probar:
- cambie el texto del título en [App.tsx] y guarde el archivo: la página se actualiza de inmediato, sin necesidad de recargarla, y el contador conserva su valor. El servidor de desarrollo vigila los archivos, recompila los cambios y notifica al navegador;
- vea el código fuente de la página (Ctrl-U): solo encontrará la página [index.html], que está casi vacía. La página HTML mostrada fue generada por [React] dentro del navegador. Para verla, use el inspector de las herramientas de desarrollo (F12, pestaña Elements) o la extensión [React Developer Tools], que también muestra los componentes y su estado.
2.2. Ejemplo 02: estado y valores calculados
El estado está en el corazón de [React]. Este ejemplo calcula el precio de un artículo con IVA incluido:
| // =========================================================================
// 02-state/src/App.tsx - estado, valores calculados, useEffect
// -------------------------------------------------------------------------
// Una pequeña calculadora de precios con IVA incluido:
// - useState : un valor de ESTADO; al cambiarlo (setXxx) se llama de nuevo
// al componente, que construye la página con el nuevo valor;
// - un valor CALCULADO a partir del estado NO es un estado: es una
// simple variable, recalculada en cada llamada al componente;
// - useMemo : lo mismo, pero el cálculo solo se rehace si sus
// dependencias han cambiado (útil para un cálculo costoso);
// - useEffect : código ejecutado DESPUÉS de mostrar la página, cuando ciertos
// valores han cambiado: un "efecto secundario" (actuar sobre algo
// distinto de la página: aquí, el título de la pestaña).
// =========================================================================
import { useEffect, useMemo, useState } from 'react';
// un formateador de montos en euros, a la manera inglesa (€1,234.50)
const euros = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' });
export default function App() {
const [label, setLabel] = useState('Pen');
const [priceExclVat, setPriceExclVat] = useState(2.5);
const [quantity, setQuantity] = useState(1);
const [vatRate, setVatRate] = useState(20); // en %
// Valores CALCULADOS: simples constantes, recalculadas en cada
// llamada al componente. Siempre están actualizados, nada que sincronizar
const totalExclVat = quantity * priceExclVat;
const vatAmount = (totalExclVat * vatRate) / 100;
// useMemo(cálculo, [dependencias]): mismo resultado, pero React solo rehace el
// cálculo si alguna de las dependencias ha cambiado desde la llamada anterior
const totalInclVat = useMemo(() => totalExclVat + vatAmount, [totalExclVat, vatAmount]);
// el historial de los totales con IVA: depende de los valores SUCESIVOS del
// total. El total anterior se conserva en el estado; si difiere del
// nuevo, el estado se ajusta DURANTE la llamada al componente (React
// reinicia entonces la llamada de inmediato, antes de mostrar nada)
const [history, setHistory] = useState<{ id: number; text: string }[]>([]);
const [oldTotal, setOldTotal] = useState(totalInclVat);
if (totalInclVat !== oldTotal) {
setOldTotal(totalInclVat);
const text = `${euros.format(oldTotal)} -> ${euros.format(totalInclVat)}`;
// cada línea tiene un número único (id), que la identifica (cf. key, ejemplo 03)
setHistory((h) => [{ id: (h[0]?.id ?? 0) + 1, text }, ...h].slice(0, 5));
}
// useEffect(efecto, [dependencias]): el efecto se ejecuta DESPUÉS de la primera
// visualización, y luego después de cada visualización en que totalInclVat haya cambiado
useEffect(() => {
document.title = `Incl. VAT: ${euros.format(totalInclVat)}`;
}, [totalInclVat]);
// cambiar el artículo restablece la cantidad a 1: se hace en el
// manejador de eventos, donde sabemos POR QUÉ cambia el estado
function changeLabel(newValue: string) {
setLabel(newValue);
setQuantity(1);
}
function reset() {
setLabel('Pen');
setPriceExclVat(2.5);
setQuantity(1);
setVatRate(20);
}
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 02 - state and computed values</h1>
<div className="row g-4">
<div className="col-md-6">
<div className="card p-3">
{/* value + onChange: el campo muestra el estado, y cada pulsación de tecla lo cambia (cf. ejemplo 05) */}
<label className="form-label" htmlFor="label">Item</label>
<input id="label" className="form-control mb-2" value={label}
onChange={(e) => changeLabel(e.target.value)} />
<label className="form-label" htmlFor="price">Unit price excl. VAT</label>
{/* valueAsNumber: el valor del campo, como número (NaN si está vacío) */}
<input id="price" type="number" step="0.1" min="0" className="form-control mb-2" value={priceExclVat}
onChange={(e) => setPriceExclVat(e.target.valueAsNumber || 0)} />
<label className="form-label" htmlFor="quantity">Quantity (back to 1 if the item changes)</label>
<input id="quantity" type="number" min="0" className="form-control mb-2" value={quantity}
onChange={(e) => setQuantity(e.target.valueAsNumber || 0)} />
<label className="form-label" htmlFor="vat">VAT rate</label>
{/* el valor de un <select> es una CADENA: Number(...) la convierte */}
<select id="vat" className="form-select mb-3" value={vatRate}
onChange={(e) => setVatRate(Number(e.target.value))}>
<option value={5.5}>5.5 %</option>
<option value={10}>10 %</option>
<option value={20}>20 %</option>
</select>
<button className="btn btn-outline-secondary" onClick={reset}>Reset</button>
</div>
</div>
<div className="col-md-6">
<div className="card p-3">
<h2 className="h5">{quantity} x {label}</h2>
<table className="table mb-0">
<tbody>
<tr><td>Total excl. VAT</td><td className="text-end">{euros.format(totalExclVat)}</td></tr>
<tr><td>VAT ({vatRate} %)</td><td className="text-end">{euros.format(vatAmount)}</td></tr>
<tr className="fw-bold"><td>Total incl. VAT</td><td className="text-end">{euros.format(totalInclVat)}</td></tr>
</tbody>
</table>
</div>
<div className="card p-3 mt-3">
<h2 className="h6">History of the total incl. VAT</h2>
<ul className="mb-0">
{history.map((line) => (
<li key={line.id}>{line.text}</li>
))}
</ul>
</div>
</div>
</div>
</div>
);
}
|
El archivo [main.tsx] de este ejemplo —y de la mayoría de los siguientes— es el mismo que el del ejemplo 01, sin sus comentarios. Solo se mostrarán los archivos [main.tsx] que difieran.
- Línea 16: los hooks utilizados, todos proporcionados por [React];
- Línea 19: un formateador de montos al estilo inglés (€1,234.50), creado una sola vez fuera del componente. El ejemplo 09 presentará la API [Intl];
- Líneas 22–25: cuatro valores de estado. Su tipo se deriva del valor inicial: [useState('Pen')] es un estado de tipo [string], y [useState(2.5)] es un estado de tipo [number];
- Líneas 29–30: dos valores calculados a partir del estado. NO son estados: son simples constantes, recalculadas cada vez que se llama al componente. Por lo tanto, siempre están actualizadas. Esta es una regla importante en [React]: almacene en el estado solo lo que no se puede calcular; todo lo demás se calcula durante la visualización;
- Línea 33: [useMemo(computation, [dependencies])] da el mismo resultado, pero [React] almacena el valor y solo lo recalcula si alguna de las dependencias ha cambiado desde la llamada anterior. Para una suma esto es innecesario; se usa para una operación costosa en cálculo (ordenar una lista larga...). Lo incluimos aquí para mostrar su sintaxis;
- líneas 39–45: el historial de los totales con IVA incluido depende de los valores sucesivos del total, algo que un valor calculado no puede expresar. Almacenamos el total anterior en el estado ([oldTotal]); si, durante la visualización, difiere del nuevo, actualizamos el estado mientras se está llamando al componente. [React] lo permite: entonces descarta el resultado actual y vuelve a llamar de inmediato al componente con el nuevo estado, antes de mostrar nada. A cada línea del historial se le asigna un número único, [id], cuyo uso se explicará en el ejemplo 03;
- Líneas 50–52: [useEffect(effect, [dependencies])]: la función [effect] se ejecuta después de la visualización: una vez al inicio y luego cada vez que cambia una de las dependencias (aquí, [totalInclVat]). Se usa para los efectos secundarios: afectar algo distinto de lo que muestra el componente (aquí, el título de la pestaña del navegador; en otros casos, un temporizador, una solicitud HTTP);
- Líneas 56–58: cambiar el artículo restablece la cantidad a 1. Esto se hace en la función que maneja el cambio del campo, donde sabemos por qué cambia el estado. Este es el método recomendado por [React]: en lugar de un efecto que "vigila" la etiqueta, la acción se realiza en el manejador de eventos;
- líneas 61–65: varios cambios de estado seguidos. [React] los agrupa: se llama al componente una sola vez, al final del manejador.
JSX:
- líneas 76–77: un campo controlado (véase el ejemplo 05): [value] muestra el estado; [onChange] se llama con cada pulsación de tecla, mediante el evento [e]; [e.target.value] es el texto del campo. En JSX, el atributo [for] de una etiqueta label se escribe [htmlFor];
- líneas 80–81: en un campo numérico, [e.target.valueAsNumber] devuelve el valor como número ([NaN] si el campo está vacío, de ahí [|| 0]);
- líneas 87–92: el valor de un [<select>] es siempre una cadena: [Number(...)] la convierte;
- línea 110: [map] genera un elemento [<li>] por cada línea del historial (véase el ejemplo 03).
Con el servidor de desarrollo en ejecución ([npm start 02-state]), modificamos el artículo, el precio, la cantidad y la tasa:

Cada vez que cambia el total con IVA incluido, se agrega una fila al historial y cambia el título de la pestaña. Cambiar el artículo restablece la cantidad a 1.
La diferencia con [Angular] y [Vue.js] es profunda. En esos frameworks, los datos son reactivos (signals, [ref]): el framework sabe qué datos utiliza una sección de la página y actualiza solo esa sección. [React] adopta un enfoque más simple: cada vez que cambia el estado, vuelve a ejecutar toda la función del componente (y las de sus hijos) y luego compara el resultado con el anterior. El código se lee entonces como una función ordinaria: los valores calculados son variables y las condiciones son el [if]. La contrapartida: hay que respetar algunas reglas (nunca modificar el estado directamente, llamar siempre a los hooks en el mismo orden) y tener en cuenta los efectos y sus dependencias.
2.3. Ejemplo 03: la sintaxis JSX
JSX es HTML escrito en el código [TypeScript], donde todo lo que está entre llaves es una expresión. Este ejemplo muestra una lista de médicos que se puede filtrar:
| // =========================================================================
// 03-jsx/src/App.tsx - la sintaxis JSX
// -------------------------------------------------------------------------
// JSX es HTML escrito DENTRO del código TypeScript. Cada etiqueta se convierte en
// una llamada a función, y todo lo que está entre llaves es una expresión
// ordinaria de TypeScript:
// - attribute={expresión} : el valor de un atributo (src, disabled...);
// - className={...} : las clases CSS, una cadena que calculamos;
// - style={{ prop: valor }} : un OBJETO de propiedades CSS (camelCase);
// - {condición && <p/>} : un elemento que solo existe si la
// condición es verdadera;
// - {c ? <A/> : <B/>} : uno O el otro;
// - {lista.map((x) => <li key={x.id}/>)} : un elemento por cada elemento de la
// lista; key da la IDENTIDAD de cada uno.
// Ninguna sintaxis especial para condiciones y bucles: es
// TypeScript simple. Todo lo que está antes del return es código ordinario.
// =========================================================================
import { useState } from 'react';
// una interfaz de TypeScript describe la forma de los objetos de la lista
interface Doctor {
id: number;
title: string;
firstName: string;
lastName: string;
specialty: 'general practitioner' | 'pediatrician' | 'cardiologist';
available: boolean;
}
const DOCTORS: Doctor[] = [
{ id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner', available: true },
{ id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician', available: false },
{ id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'cardiologist', available: true },
];
// "un bloque entre varios, según un valor": un switch, en una función
function icon(specialty: Doctor['specialty']) {
switch (specialty) {
case 'pediatrician':
return <span title="children">🧸</span>;
case 'cardiologist':
return <span title="heart">❤️</span>;
default:
return <span title="all patients">🩺</span>;
}
}
export default function App() {
const [doctors] = useState(DOCTORS);
const [filter, setFilter] = useState(''); // texto buscado
const [onlyAvailable, setOnlyAvailable] = useState(false);
const [showHelp, setShowHelp] = useState(true);
// la lista mostrada: una variable ordinaria, recalculada en cada llamada
const text = filter.trim().toLowerCase();
const displayed = doctors.filter(
(m) => (!onlyAvailable || m.available) && `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(text),
);
// "uno de los tres bloques": se calcula ANTES del return, con ifs
let content;
if (doctors.length === 0) {
content = <p className="text-muted">No doctor.</p>;
} else if (displayed.length === 0) {
content = <p className="text-warning">No doctor matches "{filter}".</p>;
} else {
content = (
<table className="table">
<thead>
<tr><th>#</th><th>Doctor</th><th>Specialty</th><th>Status</th></tr>
</thead>
<tbody>
{/* una fila por médico; key: la identidad de cada fila, para que
React sepa qué fila agregar, mover o quitar */}
{displayed.map((m, i) => (
<tr key={m.id} className={m.available ? '' : 'opacity-50'}>
<td>{i + 1}</td>
<td>{m.title} {m.firstName} {m.lastName}</td>
<td>{icon(m.specialty)} {m.specialty}</td>
<td>
{/* una cadena de clases calculada mediante una plantilla de cadena */}
<span className={`badge ${m.available ? 'text-bg-success' : 'text-bg-secondary'}`}>
{m.available ? 'available' : 'unavailable'}
</span>
</td>
</tr>
))}
</tbody>
</table>
);
}
return (
// <> ... </>: un "fragmento", para devolver varios elementos sin
// envolverlos en un elemento HTML adicional
<>
<div className="container py-4">
<h1 className="h3 mb-3">
{/* la imagen está en la carpeta public/ del ejemplo: se sirve tal cual */}
<img src="/doctor.svg" alt="logo" width={32} height={32} /> Example 03 - the JSX syntax
</h1>
<div className="d-flex flex-wrap gap-3 align-items-center mb-3">
<input className="form-control w-auto" placeholder="search..." value={filter}
onChange={(e) => setFilter(e.target.value)} />
<label className="form-check-label">
<input type="checkbox" className="form-check-input" checked={onlyAvailable}
onChange={(e) => setOnlyAvailable(e.target.checked)} /> available only
</label>
<button className="btn btn-sm btn-outline-secondary" onClick={() => setShowHelp((a) => !a)}>
{showHelp ? 'Hide help' : 'Show help'}
</button>
</div>
{/* &&: el párrafo solo EXISTE si showHelp es verdadero */}
{showHelp && (
<p className="alert alert-info">Type a name or a specialty. Unavailable doctors are greyed out.</p>
)}
{content}
{/* style: un objeto; un número solo se interpreta como píxeles */}
<p style={{ fontSize: 12 + displayed.length * 2 }}>
{displayed.length} doctor(s) displayed - the size of this text depends on it.
</p>
</div>
</>
);
}
|
- líneas 22–27: una interfaz [TypeScript] describe el formato de los objetos de la lista; [specialty] solo puede tomar tres valores;
- líneas 38–47: "un bloque entre varios, según un valor". JSX no tiene una sintaxis para esto: es una función ordinaria, con un [switch], que devuelve JSX. [Doctor['specialty']] es el tipo de la propiedad [specialty]. [🧸] es una entidad HTML (un emoji), permitida en JSX;
- líneas 50–53: el estado de la página. Solo se conserva el valor de [useState(DOCTORS)]; aquí nunca se modifica;
- líneas 56–59: la lista mostrada: una variable, recalculada cada vez que se llama al componente;
- líneas 62–68: uno de tres contenidos posibles, seleccionado mediante [if] antes del [return]. Un fragmento de JSX es un valor como cualquier otro: se puede almacenar en una variable;
- líneas 76–88: la lista: [map] convierte cada médico en una línea de [<tr>]. [i] es la posición del médico en la lista;
- línea 77: el atributo [key] identifica cada línea. Cuando la lista cambia, [React] lo usa para determinar qué línea agregar, mover o eliminar, en lugar de reconstruir toda la lista. La clave debe ser única entre los elementos de la lista y estable (la misma de una visualización a otra): un identificador, no la posición. [React] indica en la consola que la lista no tiene claves;
- línea 77: las clases CSS son una cadena que se calcula, en este caso mediante el operador [? :];
- línea 80: el JSX devuelto por la función [icon];
- línea 83: una cadena de plantilla ([
badge ${...}]) construye la lista de clases: [badge] y una clase calculada.
El [return]:
- línea 97: un fragmento, [<>...</>], permite devolver varios elementos sin envolverlos en un elemento HTML adicional (aquí solo hay uno: es solo para el ejemplo);
- línea 101: la imagen está en la carpeta [public/] del ejemplo: [Vite] la sirve tal cual, en la raíz del sitio. [width={32}]: un valor numérico, encerrado entre llaves;
- líneas 105–106: el campo de búsqueda, que es controlado; en una casilla de verificación, [checked] se lee y se escribe;
- línea 111: una función "flecha" escrita directamente en el atributo: alterna el estado;
- Líneas 117–119: [condition && <p>...</p>]: el párrafo existe solo si la condición es verdadera (si es falsa, [React] no muestra nada para [false], [null], ni para [undefined]). Cuidado con esta trampa: [{list.length && <p/>}] mostraría "0" para una lista vacía; en su lugar, escriba [list.length > 0 && ...];
- línea 121: el contenido seleccionado más arriba;
- línea 124: el atributo [style] recibe un objeto (de ahí las llaves dobles: la expresión y luego el objeto), cuyas propiedades CSS se escriben en "camelCase" ([fontSize] para [font-size]). Un número solo se interpreta como píxeles.

Escriba "gen", marque "solo disponibles" y luego escriba "zzz":

2.4. Ejemplo 04: eventos
| // =========================================================================
// 04-events/src/App.tsx - reaccionar a las acciones del usuario
// -------------------------------------------------------------------------
// onEvent={función}: la función se llama cuando el elemento emite
// este evento:
// - onClick={f} llama a f(event);
// - onClick={() => remove(t)} una función flecha, para pasar los
// propios argumentos;
// - el evento recibido es un "evento sintético" de React, que tiene la
// misma interfaz que el evento del navegador (preventDefault(),
// target, key...); event.nativeEvent da el evento original;
// - useRef: una REFERENCIA a un elemento HTML (ref={field}), para leer o
// actuar sobre el propio elemento (field.current.value, .focus()...).
// Aquí, sin estado para el campo de entrada: lo leemos nosotros mismos.
// =========================================================================
import { useRef, useState, type FormEvent, type KeyboardEvent, type MouseEvent } from 'react';
interface Task {
id: number;
label: string;
done: boolean;
}
// el estilo del área clicable: un objeto, como para el atributo style
const areaStyle = { background: '#e7f5ff', height: 80, cursor: 'crosshair' };
export default function App() {
const [tasks, setTasks] = useState<Task[]>([
{ id: 1, label: 'Install Node.js', done: true },
{ id: 2, label: 'Read the chapter on events', done: false },
]);
const [log, setLog] = useState<string[]>([]);
// una referencia al <input> de la nueva tarea (null mientras no se muestre)
const field = useRef<HTMLInputElement>(null);
// una referencia también puede conservar un valor que NO se muestra: modificarlo
// no vuelve a llamar al componente
const nextId = useRef(3);
function trace(message: string) {
setLog((j) => [`${new Date().toLocaleTimeString()} ${message}`, ...j]);
}
// onSubmit: Enter en el campo O clic en el botón. preventDefault()
// impide que el navegador envíe el formulario (y recargue la página)
function add(event: FormEvent<HTMLFormElement>) {
event.preventDefault();
const input = field.current!;
const label = input.value.trim();
if (label === '') {
return;
}
// un estado que contiene un arreglo: se REEMPLAZA por un nuevo arreglo
// (el anterior nunca se modifica: React no vería el cambio)
setTasks((t) => [...t, { id: nextId.current++, label, done: false }]);
trace(`added "${label}"`);
input.value = '';
input.focus();
}
// una tecla: event.key da su nombre
function onKeyDown(event: KeyboardEvent<HTMLInputElement>) {
if (event.key === 'Escape') {
event.currentTarget.value = '';
}
}
function toggle(task: Task, done: boolean) {
setTasks((t) => t.map((x) => (x.id === task.id ? { ...x, done } : x)));
trace(`"${task.label}": ${done ? 'done' : 'to do'}`);
}
function remove(task: Task) {
setTasks((t) => t.filter((x) => x.id !== task.id));
trace(`removed "${task.label}"`);
}
// el evento original (nativeEvent) tiene las coordenadas relativas al área
function position(event: MouseEvent<HTMLDivElement>) {
trace(`click at (${event.nativeEvent.offsetX}, ${event.nativeEvent.offsetY})`);
}
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 04 - events</h1>
<form className="d-flex gap-2 mb-3" onSubmit={add}>
<input ref={field} className="form-control" placeholder="new task (Esc to clear)" onKeyDown={onKeyDown} />
<button type="submit" className="btn btn-primary">Add</button>
</form>
<ul className="list-group mb-3">
{tasks.map((t) => (
<li key={t.id} className="list-group-item d-flex align-items-center gap-2">
{/* e.target: la casilla de verificación de ESTA fila; checked: su estado */}
<input type="checkbox" className="form-check-input" checked={t.done}
onChange={(e) => toggle(t, e.target.checked)} />
<span className={`flex-grow-1 ${t.done ? 'text-decoration-line-through text-muted' : ''}`}>{t.label}</span>
{/* una función flecha: la tarea de ESTA fila como argumento */}
<button className="btn btn-sm btn-outline-danger" onClick={() => remove(t)}>Delete</button>
</li>
))}
</ul>
<div className="p-3 mb-3 rounded" style={areaStyle} onClick={position}>Click in this area</div>
<h2 className="h6">Log</h2>
<ul className="small">
{log.map((line, i) => (
// key: el número de orden de la línea contado desde la PRIMERA agregada (que
// siempre tiene la clave 1): cada línea conserva la misma clave cuando otras
// llegan al inicio de la lista
<li key={log.length - i}>{line}</li>
))}
</ul>
</div>
);
}
|
- Línea 17: [FormEvent], [KeyboardEvent], [MouseEvent] son tipos de evento de [React] (de ahí el término [type]);
- Línea 26: el estilo del área en la que se puede hacer clic, un objeto;
- línea 35: [useRef] crea una referencia: un objeto [{ current: ... }] que [React] conserva de una visualización a otra. Asignada al atributo [ref] de un elemento (línea 88), hace referencia al propio elemento HTML, una vez mostrado: [field.current.value], [field.current.focus()]...;
- línea 38: una referencia también puede conservar cualquier valor que no se muestre. Modificarla ([nextId.current++]) no vuelve a llamar al componente, a diferencia de un estado;
- líneas 46–59: llamada por el evento [onSubmit] del formulario, que se dispara al presionar Enter en el campo O al hacer clic en el botón [submit]:
- línea 47: impide que el navegador envíe el formulario al servidor, lo que recargaría la página;
- línea 48: el elemento [<input>]; el elemento [!] confirma que existe (está mostrado);
- línea 55: un estado que contiene un arreglo: se reemplaza por un nuevo arreglo ([[...t, newTask]]: los elementos de [t], seguidos de la nueva tarea). NUNCA modificamos el estado en sí ([t.push(...)]): [React] compara los valores antiguo y nuevo; si es el mismo arreglo, concluye que nada ha cambiado y no muestra nada;
- líneas 57–58: se vacía el campo y se le devuelve el foco, directamente sobre el elemento HTML;
- líneas 62–66: [event.key] devuelve el nombre de la tecla. [currentTarget] es el elemento que tiene el manejador (en este caso, el campo);
- línea 69: modificar un elemento de un arreglo: un nuevo arreglo, donde el elemento en cuestión se reemplaza por una copia modificada ([{ ...x, done }]);
- línea 74: eliminar un elemento: un nuevo arreglo, sin ese elemento;
- líneas 79–81: el evento de [React] es un evento "sintético", que tiene la misma interfaz que el del navegador; [nativeEvent] proporciona el evento original, aquí con las coordenadas del clic relativas al área ([offsetX]).
JSX:
- línea 87: el manejador del formulario;
- línea 88: la referencia y un manejador de teclas. Este campo no es controlado (sin [value]): el navegador gestiona su valor, que se lee cuando es necesario;
- Líneas 96–97: un manejador escrito en el momento: una función flecha que llama a [toggle] con la tarea de ESTA fila;
- Línea 100: mismo principio: [onClick={remove(t)}] llamaría a [remove] de inmediato, durante la visualización;
- Línea 113: la clave de las líneas del registro.
Agregue una tarea, marque la segunda, elimine la primera y luego haga clic en el campo:

2.5. Ejemplo 05: campos controlados
Un formulario con todos los tipos de campos, vinculados al estado:
| // =========================================================================
// 05-controlled-fields/src/App.tsx - todos los tipos de campos, "controlados"
// -------------------------------------------------------------------------
// Un campo CONTROLADO muestra un valor del estado (value={...}) y notifica
// al componente de cada cambio (onChange={...}), que actualiza el
// estado. El estado es la única fuente de verdad: escribir en el campo modifica
// el estado, y modificar el estado (mediante código) modifica el campo.
// Es el enlace "bidireccional", escrito a mano. Lo que se lee
// en el evento depende del campo:
// - text input, textarea -> e.target.value (cadena)
// - input type="number" -> e.target.valueAsNumber (NaN si está vacío)
// - checkbox -> e.target.checked (booleano)
// - radio buttons -> e.target.value del botón elegido
// - select -> e.target.value
// - select multiple -> e.target.selectedOptions (varios)
// - input type="date" -> e.target.value, "yyyy-MM-dd"
// Mismo formulario que el ejemplo 18 del curso de NestJS; pero aquí, sin
// servidor: todo ocurre en el navegador.
// =========================================================================
import { useState, type FormEvent } from 'react';
const TITLES = ['Mr', 'Mme', 'Melle'];
const HOBBIES = ['sport', 'music', 'reading', 'cinema'];
const COUNTRIES = [
{ code: 'fr', label: 'France' },
{ code: 'be', label: 'Belgium' },
{ code: 'ch', label: 'Switzerland' },
];
export default function App() {
// un estado por cada campo del formulario
const [title, setTitle] = useState('Mme');
const [name, setName] = useState('');
const [age, setAge] = useState<number | null>(30);
const [presentation, setPresentation] = useState('');
const [newsletter, setNewsletter] = useState(false);
const [hobbies, setHobbies] = useState<string[]>(['reading']);
const [country, setCountry] = useState('fr');
const [languages, setLanguages] = useState<string[]>([]);
const [birthDate, setBirthDate] = useState('');
const [sent, setSent] = useState<string | null>(null);
// todos los valores, reunidos en un objeto (lo que se enviaría a un servidor)
const model = { title, name: name.trim(), age, presentation, newsletter, hobbies, country, languages, birthDate };
// varias casillas para UN arreglo: el valor se agrega o se quita
function toggleHobby(hobby: string, checked: boolean) {
setHobbies((l) => (checked ? [...l, hobby] : l.filter((x) => x !== hobby)));
}
function send(event: FormEvent<HTMLFormElement>) {
event.preventDefault(); // sin envío al servidor, sin recarga
setSent(JSON.stringify(model));
}
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 05 - controlled fields</h1>
<div className="row g-4">
<form className="col-md-7" onSubmit={send}>
<div className="mb-3">
<span className="form-label d-block">Title</span>
{/* botones de opción: el mismo estado; checked indica cuál está marcado */}
{TITLES.map((t) => (
<div key={t} className="form-check form-check-inline">
<input type="radio" className="form-check-input" name="title" id={`title-${t}`} value={t}
checked={title === t} onChange={(e) => setTitle(e.target.value)} />
<label className="form-check-label" htmlFor={`title-${t}`}>{t}</label>
</div>
))}
</div>
<div className="row g-3 mb-3">
<div className="col-8">
<label className="form-label" htmlFor="name">Name</label>
<input id="name" className="form-control" value={name} onChange={(e) => setName(e.target.value)} />
</div>
<div className="col-4">
<label className="form-label" htmlFor="age">Age</label>
{/* un campo vacío da NaN: se guarda null en el estado, '' en el campo */}
<input id="age" type="number" className="form-control" value={age ?? ''}
onChange={(e) => setAge(Number.isNaN(e.target.valueAsNumber) ? null : e.target.valueAsNumber)} />
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="presentation">About you (updated when leaving the field)</label>
{/* un campo NO controlado: defaultValue es su valor inicial, luego
navegador lo gestiona por sí solo; onBlur solo notifica al salir */}
<textarea id="presentation" rows={2} className="form-control" defaultValue={presentation}
onBlur={(e) => setPresentation(e.target.value)} />
</div>
<div className="mb-3 form-check">
{/* una sola casilla: true / false */}
<input id="newsletter" type="checkbox" className="form-check-input" checked={newsletter}
onChange={(e) => setNewsletter(e.target.checked)} />
<label htmlFor="newsletter" className="form-check-label">Receive the newsletter</label>
</div>
<div className="mb-3">
<span className="form-label d-block">Hobbies</span>
{HOBBIES.map((l) => (
<div key={l} className="form-check form-check-inline">
<input type="checkbox" className="form-check-input" id={`hobby-${l}`} checked={hobbies.includes(l)}
onChange={(e) => toggleHobby(l, e.target.checked)} />
<label className="form-check-label" htmlFor={`hobby-${l}`}>{l}</label>
</div>
))}
</div>
<div className="row g-3 mb-3">
<div className="col-6">
<label className="form-label" htmlFor="country">Country</label>
{/* value en el <select> (y no selected en las <option>) */}
<select id="country" className="form-select" value={country} onChange={(e) => setCountry(e.target.value)}>
{COUNTRIES.map((p) => (
<option key={p.code} value={p.code}>{p.label}</option>
))}
</select>
</div>
<div className="col-6">
<label className="form-label" htmlFor="languages">Spoken languages</label>
{/* multiple: value es un ARREGLO; selectedOptions, las opciones elegidas */}
<select id="languages" multiple size={3} className="form-select" value={languages}
onChange={(e) => setLanguages([...e.target.selectedOptions].map((o) => o.value))}>
<option value="fr">French</option>
<option value="en">English</option>
<option value="es">Spanish</option>
</select>
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="birthDate">Date of birth</label>
<input id="birthDate" type="date" className="form-control w-auto" value={birthDate}
onChange={(e) => setBirthDate(e.target.value)} />
</div>
<button type="submit" className="btn btn-primary">Send</button>
</form>
<div className="col-md-5">
<h2 className="h6">The model, live</h2>
{/* JSON.stringify(object, null, 2): el JSON, con sangría de 2 espacios */}
<pre className="bg-light p-2 rounded small">{JSON.stringify(model, null, 2)}</pre>
{sent !== null && (
<>
<h2 className="h6">Last sending</h2>
<pre className="bg-success-subtle p-2 rounded small text-wrap">{sent}</pre>
</>
)}
</div>
</div>
</div>
);
}
|
El principio (líneas 4–6): un campo controlado muestra un valor del estado ([value={...}]) y notifica al componente cualquier cambio ([onChange={...}]), que luego actualiza el estado. El estado es la única fuente de verdad: el campo se limita a mostrar lo que dice el estado. Si el manejador [onChange] no actualizara el estado, el campo no aceptaría la entrada del usuario.
- Líneas 33–41: un estado por campo;
- línea 45: todos los valores reunidos en un solo objeto, lo que se enviaría a un servidor. Es un valor calculado; [name.trim()] elimina los espacios iniciales y finales;
- Líneas 48–50: varias casillas de verificación para UN solo arreglo: el valor se agrega o se quita;
- líneas 52–55: enviar el formulario sin recargar la página.
JSX, campo por campo:
- líneas 65–68: botones de opción: comparten el mismo estado; [checked] indica cuál está seleccionado. [key={t}]: la clave de cada botón;
- línea 76: un campo de texto;
- líneas 81–82: un campo numérico: un campo vacío produce [NaN]; entonces almacenamos [null] en el estado y mostramos [''] ([age ?? '']: [''] si [age] es igual a [null] o [undefined]);
- líneas 89–90: un campo no controlado: [defaultValue] es su valor inicial, después del cual el navegador lo gestiona por sí solo; [onBlur] notifica al componente cuando se sale del campo. Por lo tanto, el estado se actualiza solo al salir del campo;
- línea 94: una única casilla de verificación: [checked] y [e.target.checked];
- líneas 100–103: las casillas de verificación de pasatiempos;
- línea 112: una lista: [value] en [<select>], no [selected] en [<option>];
- líneas 121–122: una lista de selección múltiple: [value] es un arreglo; [e.target.selectedOptions] proporciona las opciones seleccionadas, que se convierten en un arreglo de valores ([[...list]] convierte una colección en un arreglo);
- línea 131: una fecha, en forma de cadena [yyyy-MM-dd];
- línea 140: el modelo, en formato JSON, con sangría de 2 espacios.

Escribir [value] y [onChange] en cada campo es repetitivo: es la contrapartida de la simplicidad de [React], que no tiene equivalente a [v-model] de [Vue.js] ni a [[(ngModel)]] de [Angular]. Los ejemplos siguientes muestran cómo reducir esta repetición: un único objeto de estado (ejemplo 06), una función que genera los atributos de un campo (ejemplos 06 y 07) y una biblioteca (ejemplo 08).
| // =========================================================================
// 06-use-reducer/src/App.tsx - un formulario, un objeto, un reducer
// -------------------------------------------------------------------------
// El ejemplo 05 tenía un useState por campo. Para un formulario real,
// preferimos UN objeto que contenga todos los valores, el MODELO, y
// describimos sus cambios en una sola función, el REDUCER:
//
// reducer(estadoActual, acción) -> nuevoEstado
//
// useReducer(reducer, estadoInicial) devuelve el estado y una función
// dispatch(acción): el componente ya no modifica el estado, DESCRIBE lo que
// ocurrió ({ type: 'edit', field: 'lastName', value: 'Dupont' }) y el
// reducer deduce de ello el nuevo estado. Toda la lógica está en un solo lugar,
// y es una función PURA (misma entrada, misma salida, sin efecto
// secundario), fácil de probar.
//
// El estado también conserva, para cada campo, si ha sido "tocado" (abandonado al
// menos una vez); de ahí deducimos si está "modificado" (su valor difiere del
// valor inicial) y si está deshabilitado.
// =========================================================================
import { useReducer, type ChangeEvent } from 'react';
// la forma de los datos del formulario
interface Profile {
title: string;
firstName: string;
lastName: string;
age: number;
newsletter: boolean;
email: string;
country: string;
birthDate: string;
presentation: string;
}
const INITIAL: Profile = {
title: 'Mme',
firstName: 'Marie',
lastName: 'PELISSIER',
age: 30,
newsletter: false,
email: '',
country: 'fr',
birthDate: '',
presentation: '',
};
type Field = keyof Profile; // 'title' | 'firstName' | ...: el nombre de un campo
interface State {
values: Profile;
touched: Partial<Record<Field, boolean>>; // los campos ya abandonados
}
// las acciones posibles: una "unión discriminada" por la propiedad type
type Action =
| { type: 'edit'; field: Field; value: Profile[Field] }
| { type: 'leave'; field: Field }
| { type: 'uppercase' }
| { type: 'reset' };
// el reducer: NUNCA modifica el estado recibido, devuelve uno nuevo
function reducer(state: State, action: Action): State {
switch (action.type) {
case 'edit':
return { ...state, values: { ...state.values, [action.field]: action.value } };
case 'leave':
return { ...state, touched: { ...state.touched, [action.field]: true } };
case 'uppercase': {
const { firstName, lastName } = state.values;
return { ...state, values: { ...state.values, firstName: firstName.toUpperCase(), lastName: lastName.toUpperCase() } };
}
case 'reset':
return { values: { ...INITIAL }, touched: {} };
}
}
const TITLES = ['Mr', 'Mme', 'Melle'];
const TRACKED_FIELDS: Field[] = ['firstName', 'lastName', 'age', 'email'];
export default function App() {
const [state, dispatch] = useReducer(reducer, { values: { ...INITIAL }, touched: {} });
const v = state.values;
// valores DEDUCIDOS del estado
const modified = (c: Field) => v[c] !== INITIAL[c];
const disabled = (c: Field) => c === 'email' && !v.newsletter; // el correo electrónico requiere el boletín informativo
const formModified = (Object.keys(INITIAL) as Field[]).some(modified);
// los atributos comunes a un campo de texto: una función que los construye
// (id, value, onChange, onBlur, disabled), para "expandirlos" en el elemento: {...bind('lastName')}
function bind(field: 'firstName' | 'lastName' | 'email' | 'birthDate' | 'presentation' | 'country') {
return {
id: field,
value: v[field],
disabled: disabled(field),
onChange: (e: ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) =>
dispatch({ type: 'edit', field, value: e.target.value }),
onBlur: () => dispatch({ type: 'leave', field }),
};
}
return (
<div className="container py-4">
<h1 className="h3 mb-3">Example 06 - a form, an object, a reducer</h1>
<div className="row g-4">
<form className="col-md-7" onSubmit={(e) => e.preventDefault()}>
<div className="mb-3">
<span className="form-label d-block">Title</span>
{TITLES.map((t) => (
<div key={t} className="form-check form-check-inline">
<input type="radio" className="form-check-input" id={`title-${t}`} name="title" value={t}
checked={v.title === t} onChange={() => dispatch({ type: 'edit', field: 'title', value: t })} />
<label className="form-check-label" htmlFor={`title-${t}`}>{t}</label>
</div>
))}
</div>
<div className="row g-3 mb-3">
<div className="col-5">
<label className="form-label" htmlFor="firstName">First name</label>
{/* {...objeto}: cada propiedad del objeto se convierte en un atributo */}
<input className="form-control" {...bind('firstName')} />
</div>
<div className="col-5">
<label className="form-label" htmlFor="lastName">Last name</label>
<input className="form-control" {...bind('lastName')} />
</div>
<div className="col-2">
<label className="form-label" htmlFor="age">Age</label>
<input id="age" type="number" className="form-control" value={v.age}
onChange={(e) => dispatch({ type: 'edit', field: 'age', value: e.target.valueAsNumber || 0 })}
onBlur={() => dispatch({ type: 'leave', field: 'age' })} />
</div>
</div>
<div className="row g-3 mb-3 align-items-end">
<div className="col-5">
<div className="form-check">
<input id="newsletter" type="checkbox" className="form-check-input" checked={v.newsletter}
onChange={(e) => dispatch({ type: 'edit', field: 'newsletter', value: e.target.checked })} />
<label htmlFor="newsletter" className="form-check-label">Receive the newsletter</label>
</div>
</div>
<div className="col-7">
<label className="form-label" htmlFor="email">E-mail (if newsletter)</label>
<input type="email" className="form-control" {...bind('email')} />
</div>
</div>
<div className="row g-3 mb-3">
<div className="col-6">
<label className="form-label" htmlFor="country">Country</label>
<select className="form-select" {...bind('country')}>
<option value="fr">France</option>
<option value="be">Belgium</option>
<option value="ch">Switzerland</option>
</select>
</div>
<div className="col-6">
<label className="form-label" htmlFor="birthDate">Date of birth</label>
<input type="date" className="form-control" {...bind('birthDate')} />
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="presentation">About you</label>
<textarea rows={2} className="form-control" {...bind('presentation')} />
</div>
<div className="d-flex gap-2">
<button type="button" className="btn btn-outline-primary" onClick={() => dispatch({ type: 'uppercase' })}>
Name in uppercase
</button>
<button type="button" className="btn btn-outline-secondary" onClick={() => dispatch({ type: 'reset' })}>
Reset
</button>
</div>
</form>
<div className="col-md-5">
<h2 className="h6">The model, live</h2>
<pre className="bg-light p-2 rounded small">{JSON.stringify(v, null, 2)}</pre>
<h2 className="h6">The state of the fields</h2>
<table className="table table-sm small">
<thead><tr><th>field</th><th>touched</th><th>modified</th><th>disabled</th></tr></thead>
<tbody>
{TRACKED_FIELDS.map((c) => (
<tr key={c}>
<td>{c}</td>
<td>{String(state.touched[c] ?? false)}</td>
<td>{String(modified(c))}</td>
<td>{String(disabled(c))}</td>
</tr>
))}
</tbody>
</table>
<p className="small mb-0">form modified: <strong>{String(formModified)}</strong></p>
</div>
</div>
</div>
);
}
|
- líneas 25–35: la estructura de datos del formulario; [INITIAL] (líneas 37–47), sus valores iniciales;
- Línea 49: [keyof Profile] es el tipo de los nombres de propiedad de [Profile]: ['title' | 'firstName' | ...];
- Líneas 51–54: el estado completo: los valores y los campos que ya han sido "visitados" (de los que se salió al menos una vez). [Partial<Record<Field, boolean>>]: un objeto cuyas claves son nombres de campos, todas ellas opcionales;
- líneas 57–61: las acciones posibles, en forma de "unión discriminada": cada acción tiene una propiedad [type] que especifica de qué acción se trata, y sus propios datos;
- líneas 64–77: el reducer: una función que toma el estado actual y una acción, y devuelve el NUEVO estado. Nunca modifica el estado recibido (crea una copia modificada, [{ ...state, ... }]) y no hace nada más: es una función pura, fácil de entender y de probar. [[action.field]: action.value]: una propiedad cuyo nombre se calcula;
- línea 83: [useReducer(reducer, initialState)] devuelve el estado y una función [dispatch(action)]: el componente ya no modifica el estado; describe lo que ha ocurrido ([dispatch({ type: 'leave', field: 'lastName' })]), y [React] llama al reducer para deducir el nuevo estado;
- líneas 87–89: valores derivados del estado: un campo está "modificado" si su valor difiere del valor inicial; el correo electrónico está deshabilitado mientras no se marque la casilla "newsletter";
- líneas 93–102: una función que genera los atributos comunes de un campo: [id], [value], [disabled], [onChange], [onBlur]. Estos se "aplican" al elemento mediante la sintaxis [{...object}] (línea 123): cada propiedad del objeto se convierte en un atributo. Basta entonces una sola línea para vincular un campo al formulario.
En JSX, los campos específicos (botones de opción, edad, casilla de verificación) llaman directamente a [dispatch] ; los botones "Name in uppercase" y "Reset" disparan las acciones correspondientes. A la derecha, el modelo en vivo y el estado de los campos.
Escriba un nombre, escriba un apellido, marque la casilla newsletter, escriba una dirección de correo electrónico y luego haga clic en "Name in uppercase":

[useState] es adecuado para datos independientes; [useReducer] es para un estado compuesto, donde los cambios siguen reglas: toda la lógica está en un solo lugar, fuera del componente. Es el mismo concepto que los "stores" de [Redux] o [Vuex], pero a nivel de componente.
| // =========================================================================
// 07-validation/src/App.tsx - validar un formulario en el navegador
// -------------------------------------------------------------------------
// React no tiene sistema de validación: es código ordinario. Una
// función PURA, validate(account), devuelve los errores de los campos; se
// llama en cada visualización, así que los errores siempre están actualizados.
// No se muestran de inmediato (un formulario vacío cubierto de rojo es
// desagradable): solo para un campo ya abandonado ("touched"). Al enviar,
// se marcan todos los campos como tocados y solo se actúa si el formulario
// es válido.
//
// Mismas reglas que el servidor RdvMedecins (formulario "Crear una cuenta").
// ADVERTENCIA: esta validación es solo una COMODIDAD para el usuario (una
// respuesta inmediata, sin ida y vuelta al servidor). No protege
// nada: cualquiera puede enviar al servidor una solicitud construida
// a mano (curl...). Por lo tanto, el servidor SIEMPRE revalida todo (cf. ejemplo 25).
// =========================================================================
import { useState, type FormEvent } from 'react';
interface Account {
title: string;
firstName: string;
lastName: string;
login: string;
password: string;
confirmation: string;
}
type Field = keyof Account;
// como máximo un mensaje de error por campo
type Errors = Partial<Record<Field, string>>;
const TITLES = ['Mr', 'Mme', 'Melle'];
const LOGIN_FORMAT = /^[a-z0-9._-]{1,30}$/;
const PASSWORD_MIN = 6;
// las reglas: una función pura, que solo depende de sus argumentos
function validate(c: Account): Errors {
const errors: Errors = {};
if (!TITLES.includes(c.title)) errors.title = 'Choose a title from the list.';
if (c.firstName.trim() === '') errors.firstName = 'The first name is required.';
else if (c.firstName.length > 20) errors.firstName = 'The first name must not exceed 20 characters.';
if (c.lastName.trim() === '') errors.lastName = 'The last name is required.';
else if (c.lastName.length > 20) errors.lastName = 'The last name must not exceed 20 characters.';
if (c.login === '') errors.login = 'The login is required.';
else if (!LOGIN_FORMAT.test(c.login)) errors.login = 'Unaccented lower-case letters, digits, dot, hyphen, underscore.';
if (c.password === '') errors.password = 'The password is required.';
else if (c.password.length < PASSWORD_MIN) errors.password = `At least ${PASSWORD_MIN} characters.`;
// una regla que compara DOS campos
if (c.confirmation !== c.password) errors.confirmation = 'The confirmation does not match the password.';
return errors;
}
const EMPTY: Account = { title: 'Mr', firstName: '', lastName: '', login: '', password: '', confirmation: '' };
const ALL: Record<Field, boolean> = { title: true, firstName: true, lastName: true, login: true, password: true, confirmation: true };
export default function App() {
const [account, setAccount] = useState<Account>(EMPTY);
const [touched, setTouched] = useState<Partial<Record<Field, boolean>>>({});
const [submitAttempted, setSubmitAttempted] = useState(false);
const [success, setSuccess] = useState(false);
// los errores: recalculados en cada visualización, nunca almacenados en el estado
const errors = validate(account);
const errorCount = Object.keys(errors).length;
// la clase Bootstrap de un campo: roja (is-invalid) o verde (is-valid),
// solo una vez que ha sido tocado
function cssClass(field: Field, base = 'form-control'): string {
if (!touched[field]) return base;
return `${base} ${errors[field] ? 'is-invalid' : 'is-valid'}`;
}
// los atributos comunes a todos los campos
function bind(field: Field) {
return {
id: field,
value: account[field],
onChange: (e: { target: { value: string } }) => {
setAccount((c) => ({ ...c, [field]: e.target.value }));
setSuccess(false);
},
onBlur: () => setTouched((t) => ({ ...t, [field]: true })),
};
}
function send(event: FormEvent<HTMLFormElement>) {
event.preventDefault();
setSubmitAttempted(true);
setTouched(ALL); // todos los errores aparecen
// aquí, la cuenta se enviaría al servidor (cf. ejemplo 25)
setSuccess(errorCount === 0);
}
return (
<div className="container py-4" style={{ maxWidth: 640 }}>
<h1 className="h3 mb-3">Example 07 - the validation of a form</h1>
{/* noValidate: la validación propia del navegador está deshabilitada, para
mostrar NUESTROS mensajes, con NUESTRO estilo */}
<form className="card p-4" noValidate onSubmit={send}>
<div className="mb-3">
<label className="form-label" htmlFor="title">Title</label>
<select className={cssClass('title', 'form-select')} {...bind('title')}>
{TITLES.map((t) => <option key={t}>{t}</option>)}
</select>
<div className="invalid-feedback">{errors.title}</div>
</div>
<div className="row g-3 mb-3">
<div className="col-sm-6">
<label className="form-label" htmlFor="firstName">First name</label>
{/* is-invalid enmarca el campo en rojo Y muestra el
.invalid-feedback que lo sigue: ahí se escribe el error del campo */}
<input className={cssClass('firstName')} {...bind('firstName')} />
<div className="invalid-feedback">{errors.firstName}</div>
</div>
<div className="col-sm-6">
<label className="form-label" htmlFor="lastName">Last name</label>
<input className={cssClass('lastName')} {...bind('lastName')} />
<div className="invalid-feedback">{errors.lastName}</div>
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="login">Login</label>
<input className={cssClass('login')} autoComplete="username" {...bind('login')} />
<div className="invalid-feedback">{errors.login}</div>
</div>
<div className="row g-3 mb-4">
<div className="col-sm-6">
<label className="form-label" htmlFor="password">Password</label>
<input type="password" className={cssClass('password')} autoComplete="new-password" {...bind('password')} />
<div className="invalid-feedback">{errors.password}</div>
</div>
<div className="col-sm-6">
<label className="form-label" htmlFor="confirmation">Confirmation</label>
<input type="password" className={cssClass('confirmation')} autoComplete="new-password" {...bind('confirmation')} />
<div className="invalid-feedback">{errors.confirmation}</div>
</div>
</div>
<button type="submit" className="btn btn-primary">Create the account</button>
{submitAttempted && errorCount > 0 && (
<div className="alert alert-danger mt-3 mb-0">The form contains {errorCount} error(s).</div>
)}
{success && <div className="alert alert-success mt-3 mb-0">Valid form: it could be sent to the server.</div>}
</form>
</div>
);
}
|
[React] no tiene un sistema de validación: es simplemente código normal.
- Líneas 30–32: como máximo un mensaje de error por campo;
- líneas 39–53: las reglas: una función pura que devuelve los errores de los campos; son las mismas reglas que las del servidor [RdvMedecins] para crear una cuenta. La última regla compara dos campos;
- Línea 65: los errores se recalculan cada vez que se muestra la página y nunca se almacenan en caché; por lo tanto, siempre están actualizados;
- líneas 70–73: la clase de [Bootstrap] para un campo —[is-invalid] (recuadro rojo) o [is-valid] (recuadro verde)—solo después de que se haya seleccionado el campo: un formulario vacío cubierto de rojo no sería agradable;
- líneas 76–86: como en el ejemplo 06, los atributos comunes de los campos; salir de un campo lo marca como seleccionado;
- líneas 88–94: enviar el formulario marca los campos como completados (aparecen sus errores), y el envío tiene éxito solo si el formulario es válido.
JSX:
- línea 101: la validación propia del navegador está deshabilitada para mostrar NUESTROS mensajes con NUESTRO estilo;
- líneas 114–115: la clase [is-invalid] enmarca el campo en rojo Y muestra el elemento [.invalid-feedback] siguiente, donde se escribe el error del campo.
Escriba un nombre, escriba un apellido, escriba un inicio de sesión no válido:

Haga clic en "Create the account":

Una vez corregido todo:

ADVERTENCIA: esta validación es solo para la comodidad del usuario (una respuesta inmediata, sin ida y vuelta al servidor). No ofrece ninguna protección: cualquiera puede enviar al servidor una solicitud elaborada manualmente ([curl]...). Por lo tanto, el servidor SIEMPRE vuelve a validar todo (véase el ejemplo 25).
El formulario del ejemplo 07, escrito con [React Hook Form], la biblioteca de formularios más utilizada con [React]:
| // =========================================================================
// 08-react-hook-form/src/App.tsx - una biblioteca de formularios
// -------------------------------------------------------------------------
// El formulario del ejemplo 07, escrito con React Hook Form, la biblioteca de
// formularios más utilizada con React. Se encuentra en la mayoría de las
// aplicaciones existentes.
// - useForm<T>() devuelve herramientas para un formulario de tipo T;
// - register('lastName', reglas) vincula un campo HTML con el campo "lastName" del
// formulario: devuelve los atributos a expandir en el elemento (name,
// ref, onChange, onBlur). Los campos NO son controlados: es la
// biblioteca la que lee su valor en la página, sin volver a llamar al
// componente en cada pulsación de tecla;
// - las reglas: required, maxLength, minLength, pattern, validate (una regla
// "casera"), cada una con su mensaje;
// - formState.errors: los errores de cada campo;
// - handleSubmit(acción): valida todo; solo llama a la acción si el
// formulario es válido.
// =========================================================================
import { useState } from 'react';
import { useForm } from 'react-hook-form';
interface Account {
title: string;
firstName: string;
lastName: string;
login: string;
password: string;
confirmation: string;
}
const TITLES = ['Mr', 'Mme', 'Melle'];
export default function App() {
const {
register,
handleSubmit,
getValues,
formState: { errors, isSubmitted },
} = useForm<Account>({
// los valores iniciales
defaultValues: { title: 'Mr', firstName: '', lastName: '', login: '', password: '', confirmation: '' },
// cuándo validar: al abandonar un campo, y luego en cada pulsación de tecla
mode: 'onTouched',
});
const [sent, setSent] = useState('');
// un campo se marca con error si tiene uno (errors.lastName existe)
const cssClass = (field: keyof Account) => `form-control${errors[field] ? ' is-invalid' : ''}`;
// llamada por handleSubmit, SOLO si el formulario es válido;
// recibe los valores, tipados
function create(account: Account) {
setSent(JSON.stringify(account));
}
return (
<div className="container py-4" style={{ maxWidth: 640 }}>
<h1 className="h3 mb-3">Example 08 - React Hook Form</h1>
<form className="card p-4" noValidate onSubmit={handleSubmit(create, () => setSent(''))}>
<div className="mb-3">
<label className="form-label" htmlFor="title">Title</label>
<select id="title" className="form-select" {...register('title', { required: true })}>
{TITLES.map((t) => <option key={t}>{t}</option>)}
</select>
</div>
<div className="row g-3 mb-3">
<div className="col-sm-6">
<label className="form-label" htmlFor="firstName">First name</label>
<input id="firstName" className={cssClass('firstName')}
{...register('firstName', {
required: 'The first name is required.',
maxLength: { value: 20, message: '20 characters at most.' },
})} />
{/* errors.firstName?.message: el mensaje de la regla que falla */}
<div className="invalid-feedback">{errors.firstName?.message}</div>
</div>
<div className="col-sm-6">
<label className="form-label" htmlFor="lastName">Last name</label>
<input id="lastName" className={cssClass('lastName')}
{...register('lastName', {
required: 'The last name is required.',
maxLength: { value: 20, message: '20 characters at most.' },
})} />
<div className="invalid-feedback">{errors.lastName?.message}</div>
</div>
</div>
<div className="mb-3">
<label className="form-label" htmlFor="login">Login</label>
<input id="login" className={cssClass('login')}
{...register('login', {
required: 'The login is required.',
pattern: { value: /^[a-z0-9._-]{1,30}$/, message: 'Unaccented lower-case letters, digits, dot, hyphen, underscore.' },
})} />
<div className="invalid-feedback">{errors.login?.message}</div>
</div>
<div className="row g-3 mb-4">
<div className="col-sm-6">
<label className="form-label" htmlFor="password">Password</label>
<input id="password" type="password" className={cssClass('password')}
{...register('password', {
required: 'The password is required.',
minLength: { value: 6, message: 'At least 6 characters.' },
// deps: cuando cambia la contraseña, revalidar TAMBIÉN la confirmación
deps: ['confirmation'],
})} />
<div className="invalid-feedback">{errors.password?.message}</div>
</div>
<div className="col-sm-6">
<label className="form-label" htmlFor="confirmation">Confirmation</label>
{/* validate: una regla "casera"; getValues lee OTRO campo */}
<input id="confirmation" type="password" className={cssClass('confirmation')}
{...register('confirmation', {
validate: (value) => value === getValues('password') || 'The confirmation does not match the password.',
})} />
<div className="invalid-feedback">{errors.confirmation?.message}</div>
</div>
</div>
<button type="submit" className="btn btn-primary">Create the account</button>
{isSubmitted && (
<div className={`alert mt-3 mb-0 ${sent ? 'alert-success' : 'alert-danger'}`}>
{sent ? <>Valid form: <code>{sent}</code></> : 'Invalid form.'}
</div>
)}
</form>
</div>
);
}
|
- línea 21: el hook principal de la biblioteca;
- líneas 35–40: [useForm<Account>(options)] devuelve los componentes de un formulario de tipo [Account], que se desestructuran: [register], [handleSubmit], [getValues] y [formState], el estado del formulario (que incluye [errors], los errores de los campos, e [isSubmitted], que es verdadero después del primer envío);
- línea 42: los valores iniciales;
- línea 44: cuándo validar: al salir de un campo y luego después de cada pulsación de tecla;
- línea 49: un campo se marca como con error si contiene uno;
- líneas 53–55: la acción de envío, llamada por [handleSubmit] solo si el formulario es válido; recibe los valores escritos;
- línea 60: [handleSubmit(onValid, onInvalid)] crea el manejador de envío: valida todos los campos y luego llama a una función u otra;
- líneas 71–74: [register('firstName', rules)] vincula el campo HTML con el campo [firstName] del formulario, mediante sus reglas: [required], [maxLength], [minLength], [pattern] y [validate] (una regla "personalizada"), cada una con su propio mensaje. [register] devuelve los atributos que se deben aplicar al elemento ([name], [ref], [onChange], [onBlur]). Los campos NO son controlados: la biblioteca lee sus valores de la página mediante la referencia; por lo tanto, el componente no se vuelve a llamar con cada pulsación de tecla, lo cual es importante en formularios grandes;
- línea 76: el mensaje de una regla de validación que falló ([?.]: [undefined] si el campo no tiene errores);
- línea 105: cuando cambia la contraseña, volver a validar también la confirmación;
- línea 114: una regla personalizada que compara dos campos: [getValues('password')] lee el valor de otro campo. Devuelve [true] (válido) o el mensaje de error.

En [React], cada necesidad tiene varias bibliotecas que compiten entre sí. Para formularios, también encontramos [Formik], [TanStack Form] y, para describir las reglas, [Zod] o [Yup] ("esquemas" de validación que se pueden compartir con un servidor [Node.js] ). Para el caso de estudio, en el que toda la validación la realiza el servidor, no usaremos ninguna biblioteca: bastarán los campos controlados y un hook personalizado.
[Angular] tiene sus propios "pipes" para dar formato a un valor en una plantilla. [React] no tiene un mecanismo propio: en JSX, llamamos a funciones almacenadas en un módulo. Para fechas, números y montos, el navegador proporciona la API [Intl], que conoce las convenciones de cada idioma.
| // =========================================================================
// 09-formatting/src/formatting.ts - funciones de formato "caseras"
// -------------------------------------------------------------------------
// React no tiene un mecanismo propio de formato (Angular tiene sus
// "pipes", Vue.js sus funciones): en JSX, llamamos a
// FUNCIONES ordinarias, almacenadas en un módulo y que se pueden probar por separado:
// {timeRange(slot)} -> "8:00 - 8:20"
// {timeRange(slot, 'start')} -> "8:00"
// Para fechas, números, montos, el navegador proporciona la API
// Intl, que conoce las convenciones de cada idioma.
// =========================================================================
export interface Slot {
startHour: number;
startMinute: number;
endHour: number;
endMinute: number;
}
// "8:05" en lugar de "8:5"
function time(h: number, m: number): string {
return `${h}:${String(m).padStart(2, '0')}`;
}
export function timeRange(c: Slot, part: 'all' | 'start' | 'end' = 'all'): string {
switch (part) {
case 'start':
return time(c.startHour, c.startMinute);
case 'end':
return time(c.endHour, c.endMinute);
default:
return `${time(c.startHour, c.startMinute)} - ${time(c.endHour, c.endMinute)}`;
}
}
// "marie pelissier" -> "Marie Pelissier"
export function capitalize(text: string): string {
return text.replace(/\p{L}+/gu, (word) => word[0].toUpperCase() + word.slice(1).toLowerCase());
}
// "Marie PELISSIER" -> "MP"
export function initials(fullName: string): string {
return fullName
.split(/\s+/)
.filter((word) => word !== '')
.map((word) => word[0].toUpperCase())
.join('');
}
// "2026-10-05" (el formato de la API de RdvMedecins) -> una Date, a medianoche UTC
export function toDate(day: string): Date {
return new Date(`${day}T00:00:00Z`);
}
|
- líneas 13–18: un intervalo de tiempo, tal como lo envía el servidor [RdvMedecins] (horas y minutos de inicio y de fin);
- líneas 21–23: [padStart(2, '0')] rellena la cadena por la izquierda: "5" se convierte en "05";
- líneas 25–34: "8:00 – 8:20", o solo el inicio o el fin, según el parámetro [part], que es opcional (valor predeterminado ['all']);
- líneas 37–39: [\p{L}+] designa una secuencia de letras, incluidos los caracteres acentuados (opción [u]): la primera letra se pone en mayúscula;
- líneas 51–53: una fecha con el formato de la API (["2026-10-05"]) se convierte en un objeto [Date] a medianoche UTC.
2.9.2. La página
| // =========================================================================
// 09-formatting/src/App.tsx - formatear valores en JSX
// -------------------------------------------------------------------------
// Cada fila de la tabla muestra un fragmento de código y lo que muestra.
// Los formateadores de Intl se crean una sola vez, fuera del componente:
// construirlos cuesta más que usarlos.
// =========================================================================
import { useState } from 'react';
import { timeRange, initials, capitalize, toDate, type Slot } from './formatting';
// fechas: dateStyle / timeStyle, o el detalle de las partes a mostrar
const shortDate = new Intl.DateTimeFormat('en-US', { dateStyle: 'medium' });
const fullDate = new Intl.DateTimeFormat('en-US', { dateStyle: 'full' });
const timeOnly = new Intl.DateTimeFormat('en-US', { timeStyle: 'medium' });
const longDay = new Intl.DateTimeFormat('en-US', { weekday: 'long', day: 'numeric', month: 'long', year: 'numeric', timeZone: 'UTC' });
const frenchDay = new Intl.DateTimeFormat('fr-FR', { dateStyle: 'long', timeZone: 'UTC' });
// números y montos
const euros = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' });
const integer = new Intl.NumberFormat('en-US', { maximumFractionDigits: 0 });
const percent = new Intl.NumberFormat('en-US', { style: 'percent', minimumFractionDigits: 1 });
const day = '2026-10-05'; // una fecha en el formato de la API de RdvMedecins
const price = 1234.5;
const rate = 0.055;
const name = 'marie pelissier';
const doctor = { title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER' };
const languages = ['TypeScript', 'HTML', 'CSS', 'JavaScript', 'SQL'];
const slots: Slot[] = [
{ startHour: 8, startMinute: 0, endHour: 8, endMinute: 20 },
{ startHour: 8, startMinute: 20, endHour: 8, endMinute: 40 },
{ startHour: 14, startMinute: 5, endHour: 14, endMinute: 25 },
];
export default function App() {
const [now, setNow] = useState(() => new Date());
// [código mostrado, valor]: una fila de la tabla
const rows: [string, string][] = [
['shortDate.format(now)', shortDate.format(now)],
['fullDate.format(now)', fullDate.format(now)],
['timeOnly.format(now)', timeOnly.format(now)],
['longDay.format(toDate(day))', longDay.format(toDate(day))],
['frenchDay.format(toDate(day))', frenchDay.format(toDate(day))],
['now.toLocaleDateString()', now.toLocaleDateString()],
['euros.format(price)', euros.format(price)],
['integer.format(price)', integer.format(price)],
['percent.format(rate)', percent.format(rate)],
['name.toUpperCase()', name.toUpperCase()],
['capitalize(name)', capitalize(name)],
["'RDV'.toLowerCase()", 'RDV'.toLowerCase()],
["languages.slice(0, 3).join(', ')", languages.slice(0, 3).join(', ')],
['JSON.stringify(doctor)', JSON.stringify(doctor)],
// dos funciones seguidas: el resultado de la primera pasa a la segunda
['initials(capitalize(name))', initials(capitalize(name))],
];
return (
<div className="container py-4" style={{ maxWidth: 820 }}>
<h1 className="h3 mb-3">Example 09 - the formatting of values</h1>
<table className="table table-sm align-middle">
<thead><tr><th>In the code</th><th>Displayed</th></tr></thead>
<tbody>
{rows.map(([code, value]) => (
<tr key={code}><td><code>{`{${code}}`}</code></td><td>{value}</td></tr>
))}
</tbody>
</table>
<h2 className="h6">Object.entries: going through the properties of an object</h2>
<ul>
{Object.entries(doctor).map(([key, value]) => (
<li key={key}>{key} = {value}</li>
))}
</ul>
<h2 className="h6">A home-made function: timeRange</h2>
<ul>
{slots.map((c) => (
<li key={timeRange(c)}>{timeRange(c)} (start: {timeRange(c, 'start')})</li>
))}
</ul>
<button className="btn btn-sm btn-outline-primary" onClick={() => setNow(new Date())}>Refresh the time</button>
</div>
);
}
|
- líneas 13–17: formateadores de fechas, [Intl.DateTimeFormat(language, options)]: [dateStyle] y [timeStyle] proporcionan formatos predefinidos ([full], [long], [medium], [short]); también se puede especificar qué partes mostrar ([weekday], [day], [month], [year]). [timeZone: 'UTC']: la fecha [2026-10-05T00:00:00Z] debe seguir siendo el 5 de octubre, sin importar la zona horaria del navegador;
- líneas 19–21: formateadores de números: un monto en euros, un número sin decimales, un porcentaje;
- líneas 39–56: filas de la tabla: el código y su valor. La última encadena dos funciones;
- línea 65: el código encerrado entre llaves;
- líneas 72–74: [Object.entries(object)] devuelve los pares [key, value] de un objeto, que se recorren con [map];
- líneas 79–81: la función personalizada [timeRange].

Los generadores [Intl] se crean una sola vez, fuera del componente: crearlos cuesta más que usarlos. El idioma está fijado en el código ([en-US], y [fr-FR] para la línea en francés); el ejemplo 21 mostrará cómo seguir el idioma elegido por el usuario.