Saltar al contenido

Nivel inicial · 15 a 20 horas de práctica · Actualizada el

React desde cero

Fundamentos de React 19 paso a paso: componentes, estado, efectos, formularios, rutas y pruebas, hasta construir una aplicación de tareas completa con Vite.

Al terminar podrás

  • Crear un proyecto React moderno con Vite y entender su estructura.
  • Escribir componentes con JSX, props y estado.
  • Manejar eventos, formularios controlados, listas y renderizado condicional.
  • Usar efectos sólo cuando corresponde y consumir una API con manejo de errores.
  • Agregar rutas, estilos, pruebas automatizadas y publicar el resultado.

Conocimientos previos

  • HTML y CSS básicos.
  • JavaScript moderno: variables, funciones flecha, objetos, arreglos, módulos e import/export.
  • Uso básico de la terminal.

01 Qué es React y cómo piensa

React es una biblioteca de JavaScript para construir interfaces de usuario. La mantienen Meta y una amplia comunidad de código abierto, y su versión mayor vigente es React 19.

Su idea central es describir la interfaz como una función del estado: en lugar de modificar el documento paso a paso, se declara cómo debe verse la pantalla para cada situación y React se encarga de actualizar sólo lo que cambió.

La interfaz se divide en componentes: piezas independientes y reutilizables (un botón, una tarjeta, un formulario) que se combinan para formar páginas completas.

Conceptos clave

  • Componente: una función que devuelve lo que debe mostrarse.
  • Props: datos que un componente recibe de su componente padre.
  • Estado: datos que un componente recuerda entre una actualización y la siguiente.
  • Renderizado: el proceso por el cual React calcula qué mostrar a partir de props y estado.

02 Preparar el entorno

Instala una versión LTS vigente de Node.js desde nodejs.org; incluye npm, el gestor de paquetes. Verifica la instalación en la terminal:

node --version
npm --version

Crea el proyecto con Vite, la herramienta de compilación recomendada para aplicaciones React sin framework:

npm create vite@latest mis-tareas -- --template react
cd mis-tareas
npm install
npm run dev

El servidor de desarrollo queda disponible en http://localhost:5173 y recarga la página cada vez que guardas un archivo.

Create React App, la herramienta que se usaba antes, fue declarada obsoleta por el equipo de React en febrero de 2025. Si encuentras material que la utiliza, los conceptos siguen siendo válidos, pero conviene crear los proyectos nuevos con Vite o con un framework como Next.js.

Estructura del proyecto

  • index.html: página base donde se monta la aplicación.
  • src/main.jsx: punto de entrada; monta el componente raíz.
  • src/App.jsx: componente principal.
  • public/: archivos estáticos que se copian sin procesar.
  • package.json: dependencias y scripts (dev, build, preview).

Como editor se recomienda Visual Studio Code con las extensiones ESLint y Prettier.

03 JSX: la sintaxis de los componentes

JSX permite escribir la estructura de la interfaz con una sintaxis parecida a HTML dentro de JavaScript. Vite lo transforma en llamadas de JavaScript comunes al compilar.

export default function Saludo() {
  const nombre = 'Ana'
  const hora = new Date().getHours()

  return (
    <section className="saludo">
      <h1>Hola, {nombre}</h1>
      <p>{hora < 12 ? 'Buen día' : 'Buenas tardes'}</p>
      <label htmlFor="correo">Correo</label>
      <input id="correo" type="email" />
    </section>
  )
}

Reglas que conviene memorizar

  • Un componente devuelve un único elemento raíz; si no se quiere agregar un contenedor, se usa un fragmento <>...</>.
  • Todas las etiquetas se cierran, incluso las vacías: <img />, <input />.
  • Los atributos usan camelCase: className en lugar de class, htmlFor en lugar de for, onClick en lugar de onclick.
  • Entre llaves {} se puede escribir cualquier expresión de JavaScript: variables, cálculos, llamadas a funciones u operadores ternarios.
  • React escapa automáticamente el texto que se inserta, lo que previene inyecciones de código.

04 Componentes y props

Un componente es una función cuyo nombre comienza con mayúscula. Recibe un único objeto, las props, que suele desestructurarse en la firma.

function Tarjeta({ titulo, children }) {
  return (
    <article className="tarjeta">
      <h2>{titulo}</h2>
      {children}
    </article>
  )
}

export default function App() {
  return (
    <main>
      <Tarjeta titulo="Primera tarea">
        <p>Repasar JSX y props.</p>
      </Tarjeta>
      <Tarjeta titulo="Segunda tarea">
        <p>Practicar con useState.</p>
      </Tarjeta>
    </main>
  )
}

Las props son de sólo lectura: un componente nunca debe modificar las props que recibe. La prop especial children contiene lo que se escribe entre la etiqueta de apertura y la de cierre, lo que permite componer componentes como si fueran bloques.

Los componentes de clase todavía funcionan, pero el código nuevo se escribe con componentes de función y hooks, como en el resto de esta guía.

05 Estado con useState

El estado es la memoria de un componente. Se declara con el hook useState, que devuelve el valor actual y una función para reemplazarlo. Cada vez que el estado cambia, React vuelve a renderizar el componente.

import { useState } from 'react'

export default function Contador() {
  const [cuenta, setCuenta] = useState(0)

  return (
    <button type="button" onClick={() => setCuenta((anterior) => anterior + 1)}>
      Pulsado {cuenta} veces
    </button>
  )
}

Buenas prácticas

  • Cuando el nuevo valor depende del anterior, usa la forma con función: setCuenta((anterior) => anterior + 1).
  • El estado se reemplaza, no se modifica. Para objetos y arreglos se crea una copia: setTareas([...tareas, nueva]) o setUsuario({ ...usuario, nombre: 'Ana' }).
  • Los hooks se llaman siempre en el nivel superior del componente, nunca dentro de condiciones, bucles ni funciones anidadas.
  • No guardes en el estado lo que puede calcularse a partir de otros datos; calcúlalo durante el renderizado.

06 Eventos y formularios controlados

Los manejadores de eventos se pasan como funciones, no como llamadas: onClick={guardar}, no onClick={guardar()}.

En un formulario controlado, el valor de cada campo vive en el estado y se actualiza en cada cambio. Así es fácil validar y limpiar los datos.

import { useState } from 'react'

export default function NuevaTarea({ onAgregar }) {
  const [texto, setTexto] = useState('')
  const [error, setError] = useState('')

  function enviar(evento) {
    evento.preventDefault()
    const limpio = texto.trim()
    if (limpio.length < 3) {
      setError('La tarea debe tener al menos 3 caracteres.')
      return
    }
    onAgregar(limpio)
    setTexto('')
    setError('')
  }

  return (
    <form onSubmit={enviar} noValidate>
      <label htmlFor="tarea">Nueva tarea</label>
      <input
        id="tarea"
        value={texto}
        onChange={(e) => setTexto(e.target.value)}
        aria-invalid={Boolean(error)}
        aria-describedby={error ? 'tarea-error' : undefined}
      />
      {error && <p id="tarea-error">{error}</p>}
      <button type="submit">Agregar</button>
    </form>
  )
}

Asociar cada campo con su label y el error con aria-describedby hace que el formulario sea accesible para quienes usan lectores de pantalla.

07 Renderizado condicional y listas

Para mostrar contenido según una condición se usan las herramientas de JavaScript: if antes del return, el operador ternario o el operador &&.

Para listas se recorre el arreglo con map. Cada elemento necesita una key estable y única entre sus hermanos, que permita a React identificarlo entre renderizados.

function ListaTareas({ tareas, onAlternar }) {
  if (tareas.length === 0) {
    return <p>No hay tareas pendientes.</p>
  }

  return (
    <ul>
      {tareas.map((tarea) => (
        <li key={tarea.id}>
          <label>
            <input type="checkbox" checked={tarea.hecha} onChange={() => onAlternar(tarea.id)} />
            {tarea.texto}
          </label>
        </li>
      ))}
    </ul>
  )
}

No uses el índice del arreglo como key si la lista puede reordenarse o perder elementos: provoca errores difíciles de detectar. Para generar identificadores únicos puede usarse crypto.randomUUID().

08 Efectos: sincronizar con sistemas externos

useEffect sirve para sincronizar un componente con algo que está fuera de React: una API, un temporizador, una suscripción o una API del navegador. No es necesario para calcular datos ni para responder a eventos del usuario; esos casos se resuelven en el renderizado o en el manejador del evento.

El siguiente ejemplo carga datos de una API, muestra los estados de carga y error, y cancela la petición si el componente se desmonta o cambia el identificador:

import { useEffect, useState } from 'react'

export default function Usuario({ id }) {
  const [usuario, setUsuario] = useState(null)
  const [error, setError] = useState(null)

  useEffect(() => {
    const controlador = new AbortController()
    setUsuario(null)
    setError(null)

    fetch(`https://jsonplaceholder.typicode.com/users/${id}`, { signal: controlador.signal })
      .then((respuesta) => {
        if (!respuesta.ok) throw new Error(`Error ${respuesta.status}`)
        return respuesta.json()
      })
      .then(setUsuario)
      .catch((e) => {
        if (e.name !== 'AbortError') setError(e.message)
      })

    return () => controlador.abort()
  }, [id])

  if (error) return <p role="alert">No se pudo cargar: {error}</p>
  if (!usuario) return <p>Cargando...</p>
  return <h2>{usuario.name}</h2>
}

Puntos importantes

  • El arreglo de dependencias ([id]) indica cuándo debe volver a ejecutarse el efecto; debe incluir todos los valores que el efecto utiliza.
  • La función que devuelve el efecto es la limpieza: se ejecuta antes de la siguiente ejecución y al desmontar el componente.
  • En desarrollo, el modo estricto ejecuta los efectos dos veces a propósito para revelar limpiezas faltantes.
  • En aplicaciones grandes conviene delegar la obtención de datos en un framework o en una biblioteca especializada, que agregan caché y reintentos.

09 Compartir estado entre componentes

Cuando dos componentes necesitan los mismos datos, el estado se eleva a su ancestro común más cercano y se pasa hacia abajo mediante props, junto con las funciones que lo modifican.

Si los datos deben llegar a muchos niveles de profundidad (el tema de colores o el usuario autenticado, por ejemplo), se usa un contexto:

import { createContext, useContext, useState } from 'react'

const TemaContexto = createContext('claro')

export function ProveedorTema({ children }) {
  const [tema, setTema] = useState('claro')
  return <TemaContexto value={{ tema, setTema }}>{children}</TemaContexto>
}

export function useTema() {
  return useContext(TemaContexto)
}

En React 19 el contexto se usa directamente como proveedor (<TemaContexto value={...}>); en versiones anteriores se escribía <TemaContexto.Provider>.

Cuando la lógica de actualización crece, useReducer permite concentrar todas las transiciones de estado en una sola función, más fácil de probar.

10 Estilos y accesibilidad

React no impone una forma de escribir estilos. Las opciones más habituales son:

  • Hojas de estilo CSS comunes importadas desde el componente.
  • Módulos CSS (Boton.module.css), que limitan las clases al componente.
  • Tailwind CSS, un conjunto de clases utilitarias que se aplican directamente en el JSX.

Con Tailwind CSS 4 y Vite, la integración se reduce a instalar el complemento y agregar una línea al CSS:

npm install tailwindcss @tailwindcss/vite
@import "tailwindcss";

El complemento tailwindcss() se agrega a la lista de plugins en vite.config.js.

Sea cual sea el método, la accesibilidad se construye desde el JSX: usa elementos semánticos (button, nav, main, label), textos alternativos en imágenes, contraste suficiente y navegación completa con teclado.

11 Rutas y navegación

Para aplicaciones con varias pantallas sin framework se utiliza React Router:

npm install react-router
import { BrowserRouter, Link, Route, Routes, useParams } from 'react-router'

function Detalle() {
  const { id } = useParams()
  return <h1>Tarea {id}</h1>
}

export default function App() {
  return (
    <BrowserRouter>
      <nav>
        <Link to="/">Inicio</Link> <Link to="/tareas/1">Primera tarea</Link>
      </nav>
      <Routes>
        <Route path="/" element={<h1>Inicio</h1>} />
        <Route path="/tareas/:id" element={<Detalle />} />
        <Route path="*" element={<h1>Página no encontrada</h1>} />
      </Routes>
    </BrowserRouter>
  )
}

Para navegar desde código (después de guardar un formulario, por ejemplo) se usa el hook useNavigate. Si el proyecto necesita renderizado en el servidor, generación estática o buen posicionamiento en buscadores, conviene un framework como Next.js, que incluye su propio sistema de rutas.

12 Pruebas y calidad

Las pruebas automatizadas permiten modificar el código con confianza. En proyectos con Vite, la combinación habitual es Vitest con React Testing Library:

npm install -D vitest jsdom @testing-library/react @testing-library/user-event
import { render, screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { expect, test } from 'vitest'
import Contador from './Contador'

test('incrementa la cuenta al pulsar', async () => {
  render(<Contador />)
  const boton = screen.getByRole('button')
  await userEvent.click(boton)
  expect(boton.textContent).toBe('Pulsado 1 veces')
})

Para ejecutar las pruebas en un entorno de navegador simulado, agrega test: { environment: 'jsdom' } en vite.config.js. Las pruebas buscan elementos por su rol y su texto, igual que lo haría una persona, lo que además verifica la accesibilidad.

Activa también ESLint con el complemento de reglas de hooks (eslint-plugin-react-hooks), que detecta dependencias faltantes en los efectos y hooks llamados fuera de lugar. La plantilla de Vite ya lo incluye.

13 Proyecto práctico: lista de tareas

Para integrar lo aprendido, construye una aplicación de tareas con estas funciones:

  1. Agregar tareas con validación (componente NuevaTarea).
  2. Marcar tareas como hechas y eliminarlas.
  3. Filtrar entre todas, pendientes y hechas.
  4. Conservar las tareas al recargar la página con localStorage.
  5. Mostrar un contador de tareas pendientes calculado durante el renderizado.

Un hook propio encapsula la persistencia y se reutiliza en cualquier componente:

import { useEffect, useState } from 'react'

export function useAlmacenado(clave, valorInicial) {
  const [valor, setValor] = useState(() => {
    try {
      const guardado = localStorage.getItem(clave)
      return guardado ? JSON.parse(guardado) : valorInicial
    } catch {
      return valorInicial
    }
  })

  useEffect(() => {
    try {
      localStorage.setItem(clave, JSON.stringify(valor))
    } catch {
      // Almacenamiento no disponible (modo privado o cuota agotada).
    }
  }, [clave, valor])

  return [valor, setValor]
}
const [tareas, setTareas] = useAlmacenado('tareas', [])
const pendientes = tareas.filter((t) => !t.hecha).length

function agregar(texto) {
  setTareas((actuales) => [...actuales, { id: crypto.randomUUID(), texto, hecha: false }])
}

function alternar(id) {
  setTareas((actuales) => actuales.map((t) => (t.id === id ? { ...t, hecha: !t.hecha } : t)))
}

Publicar el resultado

Genera la versión de producción con npm run build: el resultado queda en la carpeta dist/ y puede publicarse gratis en servicios de alojamiento estático como Vercel o GitHub Pages.

14 Próximos pasos

  • TypeScript, para detectar errores de tipos antes de ejecutar el código (plantilla react-ts de Vite).
  • Next.js, para renderizado en el servidor, generación estática y rutas basadas en archivos.
  • Obtención de datos con caché, por ejemplo con TanStack Query.
  • Aplicaciones que funcionan sin conexión, tema de otra guía de esta sección.
  • Lectura completa de la documentación oficial en react.dev, que incluye ejercicios interactivos.

Fuentes y lecturas recomendadas

  1. Aprende React (documentación oficial) (abre en una pestaña nueva) — React
  2. Crear una aplicación de React (abre en una pestaña nueva) — React
  3. Quizás no necesites un efecto (abre en una pestaña nueva) — React
  4. Fin de Create React App (anuncio oficial, febrero de 2025) (abre en una pestaña nueva) — React
  5. Guía de inicio de Vite (abre en una pestaña nueva) — Vite
  6. Documentación de React Router (abre en una pestaña nueva) — Remix Software
  7. React Testing Library (abre en una pestaña nueva) — Testing Library
  8. Guía de JavaScript (abre en una pestaña nueva) — MDN Web Docs