5. Capítulo 4 - Introducción a [React]
5.1. Fuentes
Este capítulo se basa en la documentación oficial de [React]: react.dev.
5.2. De AngularJS 1.x a [React]
El documento original (2014) utilizaba AngularJS 1.x: un framework de JavaScript (todavía sin TypeScript) organizado en torno a $scope, controladores, directivas (ng-repeat, ng-if…) y un mecanismo de detección de cambios basado en el “ciclo de digestión” ($digest) y en la observación de variables ($watch).
[React] (creado por Meta, 2013) no es un framework completo como AngularJS 1.x o [Angular]: es una biblioteca dedicada a una única tarea: construir interfaces a partir de componentes. Por sí sola, no proporciona ni un cliente HTTP, ni un enrutador, ni un mecanismo de inyección de dependencias; por eso el cliente [RdvMedecins] de este capítulo se apoya, para estos fines, en la API nativa del navegador (fetch(), véase más abajo) y en un mecanismo propio de [React], el Context, en lugar de módulos dedicados como [HttpClient] o el enrutador de [Angular]. Este capítulo presenta estos conceptos uno por uno, con ejemplos breves independientes del caso de estudio; el capítulo siguiente los mostrará en acción en el cliente [RdvMedecins] completo, en [React] 19.
5.3. El concepto de aplicación [React]: la “aplicación de página única”
Una aplicación [React] es, como una aplicación [Angular], una aplicación de página única (SPA): el servidor entrega al navegador una sola página (HTML), que contiene un único archivo (JavaScript) con toda la lógica de la aplicación. Una vez cargada esta página, nunca vuelve a haber una recarga completa de página: cada interacción del usuario (cambio de vistas, envío de un formulario, etc.) la maneja el código JavaScript ya presente en el navegador, que actualiza la pantalla y se comunica con el servidor en segundo plano mediante solicitudes HTTP asíncronas (casi siempre con JSON). Este ya era el principio del documento original con AngularJS 1.x, así como de la variante [Angular] de este curso; no ha cambiado: solo difiere, de una variante a otra, la biblioteca que gestiona la pantalla.
5.4. Componentes: funciones y [JSX]
Como en [Angular], un componente es la unidad básica de una aplicación [React]: genera lo que se debe mostrar en pantalla a partir de su estado actual y de las propiedades que recibe. La diferencia está en la forma: un componente [Angular] es una clase decorada, asociada a una plantilla HTML separada (o en línea); un componente [React] es simplemente una función de JavaScript (o TypeScript) que devuelve [JSX], una sintaxis que se parece a HTML, pero que en realidad el compilador transforma en llamadas ordinarias a funciones de JavaScript.
A continuación se muestra un componente muy pequeño, independiente del caso de estudio, equivalente a [CounterComponent] presentado en la variante [Angular] de este curso:
Comentemos este código:
- línea 3: import { useState } from 'react'; — [useState] es un hook de [React]: una función especial (reconocible por su prefijo "use") que permite a una función de componente mantener un estado que persiste de un renderizado al siguiente; un papel comparable al de un signal en [Angular], o al de $scope/el controlador de AngularJS;
- línea 5: export function Counter() { — un componente de [React] es una función normal, exportada: no hay decorador ni selector personalizado (HTML) que declarar (a diferencia de [@Component]({ selector: … }) en [Angular]); se usa directamente como una etiqueta con su propio nombre, <Counter />, dentro del [JSX] de un componente padre;
- línea 6: const [value, setValue] = useState(0); — [useState](0) crea un valor de estado inicializado en 0 y devuelve un par: el valor actual (value) y una función para reemplazarlo (setValue). La desestructuración del arreglo ([value, setValue]) es simplemente una convención de nomenclatura: nada impide nombrar estos dos elementos de otra manera;
- líneas 8–10: setValue((v) => v + 1); — llamar a setValue no modifica `value` en su lugar (los valores de estado de [React] son inmutables): indica a [React] que vuelva a dibujar el componente con el nuevo valor calculado a partir del anterior, exactamente como lo hace mySignal.update(v => …) en [Angular];
- líneas 13–16: <p>Value: {value}</p> — el [JSX] que devuelve la función ES la plantilla: las llaves { } insertan una expresión de JavaScript (aquí, el valor actual), con el mismo papel que las dobles llaves {{ value() }} en la plantilla de [Angular], pero sin los paréntesis de llamada: `value` es el dato en sí, no un signal que deba interpretarse al llamarlo.
La etiqueta <> … </> (un “fragmento”) agrupa varios elementos sin agregar a su alrededor un nodo HTML superfluo; es un detalle técnico de [JSX], que exige que una función de componente devuelva un único elemento raíz.
5.5. El estado local: [useState] y las props
En AngularJS 1.x, [Angular] detectaba que un dato había cambiado mediante un ciclo de verificación sistemático ($digest), que en la variante [Angular] de este curso se reemplazó por signals (signal(), computed()). [React] adopta un tercer enfoque, que parece más simple: un componente vuelve a ejecutar por completo su función (y por lo tanto recalcula todo su [JSX]) cada vez que cambia uno de sus valores [useState]; [React] compara entonces el resultado con el renderizado anterior y modifica únicamente lo que realmente cambió en el DOM real del navegador (una técnica llamada reconciliación, o “DOM virtual”). A diferencia de los signals, un estado [useState] no “sabe” por sí mismo qué depende de él: el mecanismo de re-renderizado de todo el componente se encarga de ello, lo cual es más simple de razonar pero, en teoría, algo más costoso en aplicaciones muy grandes, una compensación deliberada en [React].
Función | Papel |
crea un estado local y devuelve el par [value, setValue]; setValue vuelve a dibujar el componente con el nuevo valor | |
reemplaza el valor del estado por un valor calculado previamente | |
calcula el nuevo valor a partir del anterior (véase increment() más arriba) | |
recalcula un valor derivado solo cuando cambia uno de los elementos de [deps] ; el equivalente conceptual de computed() en [Angular] |
Dos mecanismos complementan a [useState] para que un componente se comunique con su padre; los encontraremos constantemente en el cliente [RdvMedecins] (capítulo siguiente), exactamente donde estaban input()/output() en [Angular]:
- props: un componente [React] recibe sus entradas como simples parámetros de función (un objeto desestructurado, { doctors, onSearch }); el equivalente directo de input.required<Doctor[]>() en [Angular] y, conceptualmente, de un atributo de directiva de AngularJS 1.x;
- props de callback: una función que proporciona el padre (onSearch: (criteria) => void), que se pasa como prop y que luego el hijo llama en el momento oportuno; el equivalente directo de output<...>() (y de su método .emit(value)) en [Angular], y de los eventos personalizados ($emit) de AngularJS 1.x.
5.6. Sin módulos: cada archivo ya es autónomo
Una aplicación AngularJS 1.x se organizaba en módulos (angular.module(...)). [Angular] adoptó primero esta idea en una forma más rígida (el NgModule), antes de proponer los componentes standalone como modo predeterminado; una simplificación que la variante [Angular] de este curso ya ha adoptado. [React] nunca necesitó este concepto: un archivo .tsx exporta un componente con la palabra clave export del propio lenguaje JavaScript, y otro archivo lo usa con un simple import; los módulos estándar de ECMAScript, sin ninguna capa adicional propia de la biblioteca de interfaces:
Este es el estilo que se utiliza en todo el cliente [RdvMedecins] (capítulo siguiente): no hay archivos *.module.ts ni decoradores con imports: [...] que mantener al día; una simplificación adicional respecto de AngularJS 1.x, de [Angular] con NgModule, e incluso de los componentes standalone de [Angular] (que, sin embargo, siguen enumerando sus dependencias en imports: [...] del decorador [@Component]).
5.7. Compartir lógica: hooks personalizados y [Context]
Como en [NestJS] (capítulo 2), el cliente [RdvMedecins] necesita lógica compartida entre varios componentes: comunicarse con el servidor, identificar al usuario que inició sesión y cambiar el idioma. [Angular] responde a esta necesidad con servicios inyectables ([@Injectable]({ providedIn: 'root' }) + inject(...)), el sucesor directo de .service()/.factory() de AngularJS 1.x. [React] no tiene un mecanismo integrado de inyección de dependencias; el uso moderno combina dos herramientas ya comentadas más arriba:
- un hook personalizado, una función cuyo nombre comienza con `use` y que puede a su vez llamar a otros hooks ([useState], [useContext]…), encapsula lógica reutilizable, igual que un método de servicio en [Angular];
- el Context ([React.createContext]) comparte un valor (estado + funciones) con todo un subárbol de componentes sin tener que pasarlo manualmente, prop por prop, a través de cada nivel intermedio; el papel que antes cumplía providedIn: 'root' en [Angular]: una única instancia, disponible dondequiera que se necesite.
Un breve ejemplo, independiente del caso de estudio, equivalente en concepto a [MyService] presentado en la variante [Angular] de este curso:
Comentemos este código:
- línea 8: const MyContext = createContext<MyContextValue | null>(null); — crea el Context propiamente dicho; `null` es el valor predeterminado, que se usa solo si no hay un `<MyProvider>` más arriba en el árbol: un error de programación que se detecta en la línea 17;
- líneas 10–13: <MyContext.Provider value={value}>{children}</MyContext.Provider> — el componente Provider pone el valor a disposición de todos sus descendientes ({children}); es el que se coloca, una sola vez, cerca de la raíz de la aplicación (véase main.tsx del cliente [RdvMedecins], en el capítulo siguiente); el equivalente del “registro” implícito que realiza providedIn: 'root' en [Angular];
- líneas 15–21: export function useMyContext(): MyContextValue { — el hook personalizado que da acceso al valor del Context; es lo que llaman los componentes (const my = useMyContext();), exactamente como habrían llamado a inject(MyService) en [Angular].
5.8. Comunicación con el servidor: [fetch]
[HttpClient] ([Angular]) era el sucesor directo del servicio $http de AngularJS 1.x que utilizaba el documento original. Dado que [React] es solo una biblioteca de interfaces, no proporciona ningún cliente HTTP: el cliente [RdvMedecins] usa directamente [fetch], la API estándar del navegador (disponible sin ninguna dependencia adicional):
Una diferencia importante con $http y [HttpClient]: [fetch] devuelve directamente una Promise (el mecanismo asíncrono estándar de JavaScript), no un Observable: ni biblioteca RxJS, ni .subscribe({ next, error }), ni .pipe(map(...)). Se puede usar con .then(...) o, para mayor legibilidad, con async/await (como se mostró más arriba, que suspende la ejecución de la función hasta que la promesa se resuelve, sin bloquear el resto de la aplicación). Un error de red o una respuesta de error se maneja entonces con un simple bloque try/catch, en lugar de con la rama de error de una suscripción de RxJS.
El hook useAppointmentService() del cliente [RdvMedecins] (capítulo siguiente) encapsula sistemáticamente esta llamada a [fetch] seguida de .json(), por una razón específica que se explicará en ese punto (la envoltura [ServerResponse]<T> común a todas las respuestas del servidor).
5.9. Renderizado condicional y listas: [JSX] puro
AngularJS 1.x utilizaba directivas estructurales (ng-if, ng-repeat) para mostrar un elemento de forma condicional o repetir un bloque de plantilla por cada elemento de una lista. La variante [Angular] de este curso usa la sintaxis integrada [@if]/[@for]. [React] no tiene una sintaxis de plantilla separada que aprender: el [JSX] que devuelve un componente ES JavaScript, y el control de flujo se expresa con operadores ordinarios de JavaScript:
Comentemos este código:
- líneas 1–5: loggedInUser ? (...) : (...) — el operador ternario de JavaScript reemplaza a [@if]/[@else] ([Angular]) y a ng-if (AngularJS 1.x): la condición determina cuál de las dos expresiones [JSX] se devuelve. Para una condición sin alternativa, basta con el operador &&: {condition && <p>...</p>} no muestra absolutamente nada si la condición es falsa (este es el estilo que se usa, por ejemplo, en el banner ADMIN/USER del componente App del cliente [RdvMedecins], que se analiza en el capítulo siguiente);
- línea 8: itemList.map((item) => (...)) — .map() (un método estándar de arreglos de JavaScript) reemplaza a [@for] ([Angular]) y a ng-repeat (AngularJS 1.x): transforma cada elemento del arreglo en un elemento [JSX];
- línea 9: key={item.id} (obligatorio en una lista [JSX]) — le indica a [React] cómo reconocer un elemento que ya se mostró cuando vuelve a dibujar la lista; cumple exactamente el mismo papel que track item.id después de [@for] en [Angular].
5.10. Resumen: equivalencias [Angular] -> [React]
[Angular] (versión anterior de este curso) | [React] (2026) |
Componentes funcionales | |
[useState](), props, props de callback, [useMemo]() | |
[useEffect]() | |
[JSX] incrustado en el componente (.tsx) | |
Operador ternario / &&, .map() | |
Hooks personalizados + [Context] | |
[fetch] (Promises nativas) | |
Sin enrutador (misma conclusión, llevada un paso más allá) | |
[Vite] |
Estos conceptos bastan para abordar el cliente [RdvMedecins] en el capítulo siguiente: no obstante, cada nuevo uso se volverá a explicar allí, a medida que avance el código, en el punto exacto en que aparece.