Home / Frontend / De clases a funciones en React Native: guía de migración con Hooks
De clases a funciones en React Native: guía de migración con Hooks

De clases a funciones en React Native: guía de migración con Hooks

19 November 2026 · 25 min de lectura ··

Por qué las clases dejaron de ser el camino principal

Durante años, quien empezaba con React Native se topaba con una pregunta casi obligatoria: ¿escribo mis pantallas como clases o como funciones? La respuesta de entonces tenía matices. Las clases ofrecían estado y métodos de ciclo de vida, mientras que las funciones se reservaban para piezas puramente visuales, sin memoria propia. Esa división ya no existe. Desde la llegada de los Hooks, una función puede guardar estado, reaccionar a cambios, suscribirse a eventos del sistema y limpiar después de sí misma. Lo que antes exigía una clase hoy se resuelve con unas pocas líneas.

En este tutorial vas a recorrer el camino completo con un enfoque práctico. Primero verás cómo luce un componente de clase clásico, porque seguirás encontrándolos en proyectos heredados. Después lo convertirás a una función, entenderás cómo se traducen el estado y el ciclo de vida, construirás un botón propio con Pressable y revisarás el único escenario en el que las clases siguen siendo imprescindibles: los error boundaries. Cerraremos con una lista de errores frecuentes y recomendaciones de rendimiento.

El objetivo no es memorizar una receta, sino entender el modelo mental. Una clase vive en torno a una instancia con this, mientras que una función se ejecuta de nuevo en cada renderizado y conserva su memoria a través de Hooks. Cuando interiorizas esa diferencia, migrar código deja de ser un ejercicio mecánico y se convierte en una oportunidad de simplificar.

Si además trabajas con React en la web y quieres reforzar los conceptos de fondo, te vendrá bien repasar ejemplos prácticos y conceptos esenciales en React 19, porque todo lo que aquí se explica sobre Hooks comparte base con esa versión de la biblioteca.

Versiones y entorno de trabajo

Antes de escribir código conviene fijar el terreno. En noviembre de 2026, la línea estable de React Native se sitúa en la serie 0.8x, con una versión 0.89 ya en candidatos de lanzamiento. Las versiones recientes asumen la Nueva Arquitectura como comportamiento por defecto, y la biblioteca React que las acompaña es la 19.2. Por su parte, Expo mantiene la regla de que cada SDK apunta a una única versión de React Native: el SDK 57 es el estable más reciente según su documentación y trabaja con React Native 0.86 y React 19.2, con Node.js 22.13 o superior como requisito mínimo.

Lo importante para este tutorial es que todo lo que verás funciona igual en cualquiera de esas versiones. Los Hooks llevan disponibles desde React 16.8, así que no dependes de una novedad reciente. Lo que sí cambia con el tiempo son las herramientas de arranque y algunos componentes: TouchableOpacity sigue existiendo, pero la recomendación actual es usar Pressable para nuevos desarrollos.

Para crear un proyecto de práctica, la vía recomendada es Expo, que hoy es el punto de partida sugerido por el propio equipo de React Native. Necesitas Node.js instalado y ejecutas:

npx create-expo-app@latest laboratorio-componentes
cd laboratorio-componentes
npx expo start

El comando genera una plantilla con TypeScript, enrutamiento basado en archivos y una estructura lista para trabajar. Si prefieres un proyecto sin plantilla, puedes escoger una plantilla mínima, pero para seguir este tutorial no es necesario. Lo que haremos es crear una carpeta de componentes y trabajar en ella:

laboratorio-componentes/
├── app/
│   └── index.tsx
├── components/
│   ├── ContadorClase.tsx
│   ├── ContadorFuncion.tsx
│   ├── Boton.tsx
│   └── LimiteDeError.tsx
├── package.json
└── tsconfig.json

Con esa estructura tendrás una pareja de archivos para comparar la versión de clase y la funcional, un botón reutilizable y un componente de captura de errores. El código de los ejemplos está en TypeScript, aunque todo se traduce a JavaScript simplemente quitando las anotaciones de tipos.

Cómo funciona un componente de clase

Para valorar lo que ganas al migrar, primero hay que leer bien lo que dejas atrás. Un componente de clase es una clase de JavaScript que extiende Component y define un método render que devuelve la interfaz. El estado se declara en el constructor o como propiedad de clase, y se modifica únicamente con this.setState. Las props llegan mediante this.props.

Este es un ejemplo de contador de pasos para una app de actividad física, escrito de la forma tradicional:

import React, { Component } from 'react';
import { View, Text, Button, StyleSheet } from 'react-native';

type Props = { meta: number };
type State = { pasos: number };

export class ContadorClase extends Component<Props, State> {
  state: State = { pasos: 0 };

  sumar = () => {
    this.setState((previo) => ({ pasos: previo.pasos + 100 }));
  };

  reiniciar = () => {
    this.setState({ pasos: 0 });
  };

  render() {
    const { meta } = this.props;
    const { pasos } = this.state;
    return (
      <View style={estilos.caja}>
        <Text style={estilos.titulo}>Pasos: {pasos} / {meta}</Text>
        <Button title="Sumar 100" onPress={this.sumar} />
        <Button title="Reiniciar" onPress={this.reiniciar} />
      </View>
    );
  }
}

const estilos = StyleSheet.create({
  caja: { padding: 16, gap: 8 },
  titulo: { fontSize: 20, fontWeight: '600' },
});

Fíjate en varios detalles que explican por qué las clases generaban fricción. Los métodos de manejo de eventos se escriben como funciones flecha para no perder el valor de this; si se declaran como métodos normales y se pasan como callback sin enlazarlos, this queda indefinido en tiempo de ejecución. El estado vive en un único objeto, de modo que valores que no tienen relación entre sí terminan compartiendo estructura. Y la lógica reutilizable, como suscribirse a un evento y desuscribirse al final, se reparte entre varios métodos de ciclo de vida que se ven alejados en el archivo aunque pertenezcan a la misma idea.

Hay otra consecuencia menos obvia: compartir comportamiento entre clases obligaba a recurrir a componentes de orden superior o a render props, patrones que anidaban envoltorios y hacían difícil seguir el flujo de datos. Los Hooks resolvieron exactamente ese problema.

El mismo componente escrito como función

Ahora el equivalente funcional. La función recibe las props como argumento, declara su estado con useState y devuelve la interfaz directamente, sin render, sin this y sin constructor:

import React, { useState } from 'react';
import { View, Text, Button, StyleSheet } from 'react-native';

type Props = { meta: number };

export function ContadorFuncion({ meta }: Props) {
  const [pasos, setPasos] = useState(0);

  const sumar = () => setPasos((previo) => previo + 100);
  const reiniciar = () => setPasos(0);

  return (
    <View style={estilos.caja}>
      <Text style={estilos.titulo}>Pasos: {pasos} / {meta}</Text>
      <Button title="Sumar 100" onPress={sumar} />
      <Button title="Reiniciar" onPress={reiniciar} />
    </View>
  );
}

const estilos = StyleSheet.create({
  caja: { padding: 16, gap: 8 },
  titulo: { fontSize: 20, fontWeight: '600' },
});

La comparación es elocuente. Se eliminaron la herencia, la declaración de tipo de estado, el desestructurado desde this y los métodos como propiedades. El resultado es más corto, más fácil de probar y más cercano a una función pura: dadas unas props y un estado, produce una descripción de interfaz.

Este cambio también tiene un efecto en el modo de pensar. En una clase, this.state es un objeto mutable al que se accede en el momento en que se necesita. En una función, cada renderizado captura sus propios valores de estado y props: lo que ves dentro de un manejador es una instantánea del renderizado en que se creó. Más adelante veremos por qué esto importa al escribir efectos y temporizadores.

Estado con useState en la práctica

useState recibe un valor inicial y devuelve una pareja: el valor actual y una función para actualizarlo. A diferencia del setState de las clases, la actualización reemplaza el valor completo en lugar de fusionarlo con el anterior. Esto tiene consecuencias cuando el estado es un objeto.

Si en una clase actualizabas un solo campo con this.setState y el resto de campos se conservaban, en una función con un objeto único tienes que copiar a mano el resto. Por eso lo habitual es dividir el estado en varias llamadas a useState, una por cada dato independiente:

import React, { useState } from 'react';
import { View, TextInput, Text, Switch } from 'react-native';

export function FormularioPerfil() {
  const [nombre, setNombre] = useState('');
  const [correo, setCorreo] = useState('');
  const [avisos, setAvisos] = useState(true);

  return (
    <View style={{ padding: 16, gap: 12 }}>
      <TextInput placeholder="Nombre" value={nombre} onChangeText={setNombre} />
      <TextInput
        placeholder="Correo"
        value={correo}
        onChangeText={setCorreo}
        keyboardType="email-address"
        autoCapitalize="none"
      />
      <Switch value={avisos} onValueChange={setAvisos} />
      <Text>Hola, {nombre || 'visitante'}</Text>
    </View>
  );
}

Cuando varios valores cambian siempre juntos o dependen unos de otros, useReducer suele ser una mejor opción que encadenar llamadas. Un reductor concentra las transiciones en un único lugar y deja claro qué acciones son posibles:

import React, { useReducer } from 'react';
import { View, Text, Pressable } from 'react-native';

type Estado = { cantidad: number; envio: boolean };
type Accion = { tipo: 'mas' } | { tipo: 'menos' } | { tipo: 'envio' };

function reductor(estado: Estado, accion: Accion): Estado {
  switch (accion.tipo) {
    case 'mas':
      return { ...estado, cantidad: estado.cantidad + 1 };
    case 'menos':
      return { ...estado, cantidad: Math.max(1, estado.cantidad - 1) };
    case 'envio':
      return { ...estado, envio: !estado.envio };
  }
}

export function Pedido() {
  const [estado, enviar] = useReducer(reductor, { cantidad: 1, envio: false });
  return (
    <View>
      <Text>Cantidad: {estado.cantidad}</Text>
      <Pressable onPress={() => enviar({ tipo: 'mas' })}>
        <Text>Añadir</Text>
      </Pressable>
    </View>
  );
}

Una regla que conviene grabar es usar la forma funcional de actualización cuando el nuevo valor depende del anterior, como en setPasos((previo) => previo + 100). Así evitas leer un valor desfasado si se encadenan varias actualizaciones en el mismo ciclo. En las clases ocurría exactamente lo mismo con setState y su versión con función.

Ciclo de vida con useEffect

Los métodos componentDidMount, componentDidUpdate y componentWillUnmount se sustituyen por un único Hook: useEffect. Recibe una función que se ejecuta después de renderizar y, opcionalmente, devuelve otra función de limpieza. Un segundo argumento, la lista de dependencias, controla cuándo se vuelve a ejecutar.

La equivalencia práctica es la siguiente:

  • Lista de dependencias vacía: el efecto se ejecuta una vez tras el primer renderizado y la limpieza al desmontar, igual que montar y desmontar en una clase.
  • Lista con valores: el efecto se vuelve a ejecutar cada vez que alguno de ellos cambia, algo parecido a componentDidUpdate con una comparación previa.
  • Sin lista: se ejecuta tras cada renderizado, algo que rara vez se desea.

Veamos un caso real: un componente que escucha el estado de conexión del dispositivo. En una clase tendrías que suscribirte en un método y cancelar la suscripción en otro; con un efecto, ambas mitades viven juntas:

import React, { useEffect, useState } from 'react';
import { Text, AppState, AppStateStatus } from 'react-native';

export function IndicadorSegundoPlano() {
  const [estado, setEstado] = useState<AppStateStatus>(AppState.currentState);

  useEffect(() => {
    const suscripcion = AppState.addEventListener('change', setEstado);
    return () => suscripcion.remove();
  }, []);

  return <Text>La app está: {estado}</Text>;
}

La limpieza es fundamental en móvil. Si dejas un temporizador, un oyente de teclado o una suscripción abiertos cuando la pantalla se desmonta, acumulas fugas de memoria y actualizaciones de estado sobre componentes que ya no existen. Si tu pantalla gestiona el teclado, por ejemplo, el patrón es exactamente este; puedes ver variantes completas en cómo manejar el teclado en React Native.

Carga de datos con cancelación

Otro uso muy común es pedir datos cuando cambia un identificador. El patrón moderno combina AbortController con la limpieza del efecto para ignorar respuestas de peticiones obsoletas:

import React, { useEffect, useState } from 'react';
import { ActivityIndicator, Text, View } from 'react-native';

type Producto = { id: number; nombre: string; precio: number };

export function FichaProducto({ id }: { id: number }) {
  const [producto, setProducto] = useState<Producto | null>(null);
  const [fallo, setFallo] = useState(false);

  useEffect(() => {
    const control = new AbortController();
    setProducto(null);
    setFallo(false);

    fetch(`https://api.ejemplo.dev/productos/${id}`, { signal: control.signal })
      .then((respuesta) => respuesta.json())
      .then(setProducto)
      .catch((error) => {
        if (error.name !== 'AbortError') setFallo(true);
      });

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

  if (fallo) return <Text>No se pudo cargar el producto.</Text>;
  if (!producto) return <ActivityIndicator />;

  return (
    <View>
      <Text>{producto.nombre}</Text>
      <Text>{producto.precio} EUR</Text>
    </View>
  );
}

En proyectos grandes, sin embargo, suele ser preferible delegar la obtención de datos en una biblioteca dedicada que gestione caché, reintentos y estados de carga, en lugar de repetir este código en cada pantalla. Aun así, entender cómo funciona el efecto por debajo te permite depurar cualquier abstracción que construyas sobre él.

La trampa de las dependencias

El error más repetido al empezar con efectos es mentir en la lista de dependencias. Si dentro del efecto usas una variable de estado y no la declaras, el efecto verá siempre el valor del renderizado en que se creó. Un intervalo es el ejemplo clásico:

import React, { useEffect, useState } from 'react';
import { Text } from 'react-native';

export function Cronometro() {
  const [segundos, setSegundos] = useState(0);

  useEffect(() => {
    const id = setInterval(() => {
      setSegundos((previo) => previo + 1);
    }, 1000);
    return () => clearInterval(id);
  }, []);

  return <Text>Transcurridos: {segundos} s</Text>;
}

Aquí la lista vacía es correcta porque la actualización usa la forma funcional y no lee segundos directamente. Si hubieras escrito setSegundos(segundos + 1) con la lista vacía, el contador se quedaría atascado en 1. El plugin de ESLint para Hooks avisa de estos casos y conviene mantenerlo activo siempre.

Migración paso a paso de una clase a una función

Convertir un componente existente no requiere reescribirlo desde cero si sigues un orden. Estos pasos funcionan bien para la mayoría de casos:

  1. Cambia la declaración de la clase por una función con el mismo nombre y recibe las props como parámetro.
  2. Elimina el método render y conserva únicamente su contenido como valor devuelto.
  3. Convierte cada propiedad del estado en una llamada a useState, o agrupa las relacionadas con useReducer.
  4. Transforma los métodos en funciones locales y quita todas las referencias a this.
  5. Traduce componentDidMount y componentWillUnmount a un efecto con lista vacía y función de limpieza.
  6. Traduce componentDidUpdate a un efecto con dependencias explícitas.
  7. Ejecuta el linter y las pruebas, y revisa visualmente la pantalla en un dispositivo o simulador.

Veámoslo con un ejemplo más completo. Esta clase muestra la hora de la última sincronización y actualiza un título cuando cambia una prop:

class PanelSync extends Component<{ usuario: string }, { ultima: string }> {
  state = { ultima: 'nunca' };
  temporizador?: ReturnType<typeof setInterval>;

  componentDidMount() {
    this.temporizador = setInterval(() => {
      this.setState({ ultima: new Date().toLocaleTimeString() });
    }, 5000);
  }

  componentDidUpdate(previas: { usuario: string }) {
    if (previas.usuario !== this.props.usuario) {
      console.log('Cambió el usuario');
    }
  }

  componentWillUnmount() {
    if (this.temporizador) clearInterval(this.temporizador);
  }

  render() {
    return <Text>{this.props.usuario}: {this.state.ultima}</Text>;
  }
}

Y su traducción funcional, donde cada preocupación queda en su propio efecto:

function PanelSync({ usuario }: { usuario: string }) {
  const [ultima, setUltima] = useState('nunca');

  useEffect(() => {
    const id = setInterval(() => {
      setUltima(new Date().toLocaleTimeString());
    }, 5000);
    return () => clearInterval(id);
  }, []);

  useEffect(() => {
    console.log('Cambió el usuario');
  }, [usuario]);

  return <Text>{usuario}: {ultima}</Text>;
}

Observa que la lógica del temporizador, antes repartida en tres métodos y una propiedad, ahora está contenida en un único bloque. Y el aviso por cambio de usuario es un efecto aparte con su propia dependencia. Esta separación por tema, y no por momento del ciclo de vida, es la mayor ventaja organizativa del modelo con Hooks.

Extraer lógica en Hooks propios

Cuando una misma combinación de estado y efectos se repite en varias pantallas, puedes empaquetarla en un Hook propio. Es una función cuyo nombre empieza por use y que llama a otros Hooks. Este, por ejemplo, encapsula un contador con límites:

import { useState, useCallback } from 'react';

export function useContadorLimitado(minimo: number, maximo: number) {
  const [valor, setValor] = useState(minimo);

  const subir = useCallback(
    () => setValor((v) => Math.min(maximo, v + 1)),
    [maximo]
  );
  const bajar = useCallback(
    () => setValor((v) => Math.max(minimo, v - 1)),
    [minimo]
  );

  return { valor, subir, bajar };
}

Cualquier componente puede usarlo sin saber cómo se mantiene el estado. Este es el verdadero reemplazo de los componentes de orden superior: composición de lógica sin añadir niveles al árbol de componentes.

Un botón propio con Pressable

El componente Button que viene con React Native es práctico para pruebas, pero su aspecto depende de la plataforma y casi no admite personalización. En una aplicación real lo normal es construir tu propio botón. Antes se hacía combinando TouchableOpacity y Text; hoy la pieza recomendada es Pressable, que expone el estado de pulsación y permite controlar áreas táctiles, retroalimentación y accesibilidad con precisión.

Este botón admite variantes, estado deshabilitado, indicador de carga y un efecto visual al pulsar:

import React from 'react';
import {
  Pressable,
  Text,
  ActivityIndicator,
  StyleSheet,
  StyleProp,
  ViewStyle,
} from 'react-native';

type Variante = 'principal' | 'secundario' | 'peligro';

type BotonProps = {
  etiqueta: string;
  alPulsar: () => void;
  variante?: Variante;
  deshabilitado?: boolean;
  cargando?: boolean;
  estilo?: StyleProp<ViewStyle>;
};

const colores: Record<Variante, string> = {
  principal: '#2563eb',
  secundario: '#475569',
  peligro: '#dc2626',
};

export function Boton({
  etiqueta,
  alPulsar,
  variante = 'principal',
  deshabilitado = false,
  cargando = false,
  estilo,
}: BotonProps) {
  const inactivo = deshabilitado || cargando;

  return (
    <Pressable
      onPress={alPulsar}
      disabled={inactivo}
      accessibilityRole="button"
      accessibilityState={{ disabled: inactivo, busy: cargando }}
      hitSlop={8}
      android_ripple={{ color: '#ffffff33' }}
      style={({ pressed }) => [
        estilos.base,
        { backgroundColor: colores[variante] },
        pressed && estilos.pulsado,
        inactivo && estilos.inactivo,
        estilo,
      ]}
    >
      {cargando ? (
        <ActivityIndicator color="#ffffff" />
      ) : (
        <Text style={estilos.texto}>{etiqueta}</Text>
      )}
    </Pressable>
  );
}

const estilos = StyleSheet.create({
  base: {
    minHeight: 48,
    paddingHorizontal: 20,
    borderRadius: 10,
    alignItems: 'center',
    justifyContent: 'center',
  },
  pulsado: { opacity: 0.8, transform: [{ scale: 0.98 }] },
  inactivo: { opacity: 0.5 },
  texto: { color: '#ffffff', fontSize: 16, fontWeight: '600' },
});

Hay varias decisiones de diseño que merece la pena comentar. La propiedad style acepta una función que recibe el estado de pulsación, algo que TouchableOpacity no ofrecía con tanta flexibilidad. El hitSlop amplía el área táctil sin alterar el diseño visual, lo que ayuda en pantallas pequeñas y cumple las recomendaciones de tamaño mínimo de los objetivos táctiles. El efecto android_ripple aporta la ondulación nativa de Material en Android. Y las propiedades de accesibilidad permiten que los lectores de pantalla anuncien el rol y el estado correctos.

Usarlo en una pantalla es directo:

import React, { useState } from 'react';
import { View } from 'react-native';
import { Boton } from '../components/Boton';

export default function Pantalla() {
  const [enviando, setEnviando] = useState(false);

  const guardar = async () => {
    setEnviando(true);
    await new Promise((resolver) => setTimeout(resolver, 1500));
    setEnviando(false);
  };

  return (
    <View style={{ flex: 1, justifyContent: 'center', padding: 24, gap: 12 }}>
      <Boton etiqueta="Guardar cambios" alPulsar={guardar} cargando={enviando} />
      <Boton etiqueta="Cancelar" alPulsar={() => {}} variante="secundario" />
    </View>
  );
}

Si esta pantalla incluye formularios, no olvides cómo reacciona el teclado al aparecer, porque puede tapar el botón principal; es un tema que se trata con detalle en la guía sobre manejo del teclado enlazada antes.

Cuándo una clase seguía siendo la opción para el botón

Nunca. Un botón no necesita ciclo de vida complejo ni capturar errores de renderizado, así que no hay ninguna razón actual para escribirlo como clase. Es un buen indicador de hacia dónde apunta el ecosistema: componentes pequeños, sin herencia y con composición de props.

Props, children y tipado con TypeScript

Una de las ventajas de las funciones es que tipar sus props es sencillo. Defines un tipo o una interfaz y lo aplicas al parámetro desestructurado. Para componentes que envuelven contenido, recibes children con el tipo ReactNode:

import React, { ReactNode } from 'react';
import { View, Text, StyleSheet } from 'react-native';

type TarjetaProps = {
  titulo: string;
  children: ReactNode;
};

export function Tarjeta({ titulo, children }: TarjetaProps) {
  return (
    <View style={estilos.tarjeta}>
      <Text style={estilos.titulo}>{titulo}</Text>
      {children}
    </View>
  );
}

const estilos = StyleSheet.create({
  tarjeta: {
    padding: 16,
    borderRadius: 12,
    backgroundColor: '#f1f5f9',
    gap: 8,
  },
  titulo: { fontSize: 18, fontWeight: '700' },
});

Un detalle moderno: en React 19 se puede pasar ref directamente como una prop normal en componentes de función, de modo que en muchos casos ya no necesitas forwardRef. Si mantienes código antiguo que lo usa, sigue funcionando, pero en componentes nuevos la forma directa es más simple. Y los valores por defecto se expresan con la sintaxis de parámetros por defecto de JavaScript, en lugar de la antigua propiedad estática defaultProps, que en componentes de función quedó en desuso.

Error boundaries: la razón vigente de las clases

Hemos llegado al único territorio donde las clases no tienen sustituto directo en el núcleo de React. Un error boundary es un componente que captura excepciones lanzadas durante el renderizado de sus descendientes, en métodos de ciclo de vida y en constructores, y muestra una interfaz alternativa en lugar de dejar que toda la aplicación se cierre. Para lograrlo necesita los métodos estáticos getDerivedStateFromError y, opcionalmente, componentDidCatch, que todavía no tienen equivalente como Hook.

Este es un límite de error reutilizable con interfaz de recuperación y un botón para reintentar:

import React, { Component, ErrorInfo, ReactNode } from 'react';
import { View, Text } from 'react-native';
import { Boton } from './Boton';

type Props = {
  children: ReactNode;
  alCapturar?: (error: Error, info: ErrorInfo) => void;
};
type Estado = { error: Error | null };

export class LimiteDeError extends Component<Props, Estado> {
  state: Estado = { error: null };

  static getDerivedStateFromError(error: Error): Estado {
    return { error };
  }

  componentDidCatch(error: Error, info: ErrorInfo) {
    this.props.alCapturar?.(error, info);
  }

  reintentar = () => this.setState({ error: null });

  render() {
    if (this.state.error) {
      return (
        <View style={{ padding: 24, gap: 12 }}>
          <Text style={{ fontSize: 18, fontWeight: '700' }}>
            Algo salió mal en esta sección
          </Text>
          <Text>{this.state.error.message}</Text>
          <Boton etiqueta="Reintentar" alPulsar={this.reintentar} />
        </View>
      );
    }
    return this.props.children;
  }
}

Para usarlo, envuelves la parte del árbol que quieres proteger. Lo ideal es colocar varios límites de granularidad distinta: uno global para que la aplicación nunca quede en blanco y otros alrededor de secciones independientes, como un widget de recomendaciones, para que un fallo local no arrastre la pantalla entera:

import React from 'react';
import { View, Text } from 'react-native';
import { LimiteDeError } from '../components/LimiteDeError';
import { FichaProducto } from '../components/FichaProducto';

export default function Detalle() {
  return (
    <LimiteDeError alCapturar={(e) => console.warn('Error capturado', e.message)}>
      <View style={{ flex: 1 }}>
        <Text>Detalle</Text>
        <FichaProducto id={42} />
      </View>
    </LimiteDeError>
  );
}

Hay límites importantes que debes conocer. Un error boundary no captura errores dentro de manejadores de eventos como onPress, ni en código asíncrono como promesas o temporizadores, ni los lanzados en el propio límite. Para esos casos usas try y catch, o conviertes el error en estado y lo relanzas durante el renderizado. En producción, además, enviarías el error capturado a un servicio de monitorización desde componentDidCatch.

Si no quieres mantener tu propia clase, existen bibliotecas que ofrecen un componente ya preparado con una API funcional por encima, de manera que tú no escribes la clase, aunque por debajo siga existiendo. Sea cual sea tu elección, esta excepción es una de las pocas razones sólidas para encontrarte con extends Component en un proyecto nuevo.

Rendimiento: memo, useCallback y useMemo

Con funciones, cada renderizado crea de nuevo las funciones locales y los objetos. Normalmente eso es barato, pero en listas largas o componentes pesados puede provocar renderizados innecesarios en los hijos. Tres herramientas ayudan:

  • React.memo envuelve un componente y evita que se renderice de nuevo si sus props no cambiaron en superficie.
  • useCallback conserva la identidad de una función entre renderizados mientras no cambien sus dependencias.
  • useMemo conserva el resultado de un cálculo costoso.

Un caso típico es una lista con elementos que reciben un manejador:

import React, { memo, useCallback, useState } from 'react';
import { FlatList, Pressable, Text } from 'react-native';

type Tarea = { id: string; titulo: string };

const Fila = memo(function Fila({
  tarea,
  alElegir,
}: {
  tarea: Tarea;
  alElegir: (id: string) => void;
}) {
  return (
    <Pressable onPress={() => alElegir(tarea.id)} style={{ padding: 12 }}>
      <Text>{tarea.titulo}</Text>
    </Pressable>
  );
});

export function ListaTareas({ tareas }: { tareas: Tarea[] }) {
  const [elegida, setElegida] = useState<string | null>(null);
  const alElegir = useCallback((id: string) => setElegida(id), []);

  return (
    <FlatList
      data={tareas}
      keyExtractor={(t) => t.id}
      extraData={elegida}
      renderItem={({ item }) => <Fila tarea={item} alElegir={alElegir} />}
    />
  );
}

Conviene no abusar. Memorizar todo por costumbre añade complejidad y su propio coste de comparación. Mide primero con las herramientas de perfilado y aplica estas técnicas donde exista un problema real. Además, el compilador de React, que automatiza buena parte de esa memorización, está disponible en las plantillas modernas de Expo y reduce la necesidad de escribir useCallback y useMemo a mano en muchos proyectos.

Errores comunes al pasar a funciones

Estos son los tropiezos que más se repiten, junto con su solución:

  • Llamar a Hooks dentro de condiciones, bucles o funciones anidadas. Los Hooks deben invocarse siempre en el mismo orden en el nivel superior de la función; si necesitas lógica condicional, colócala dentro del Hook, no alrededor.
  • Olvidar la función de limpieza en efectos que crean suscripciones, temporizadores o escuchas de eventos, con la consiguiente fuga de memoria.
  • Omitir dependencias del efecto para silenciar una advertencia. La solución correcta casi nunca es borrar la dependencia, sino reestructurar el efecto o usar la forma funcional de actualización.
  • Mutar el estado directamente, por ejemplo añadiendo con push a un arreglo guardado en estado. React no detecta el cambio; crea siempre una copia nueva con propagación o concat.
  • Esperar que el estado se actualice de inmediato después de llamar a su función. La actualización es asíncrona en el sentido de que el valor nuevo solo se ve en el siguiente renderizado.
  • Definir componentes dentro de otros componentes. Cada renderizado crea un tipo nuevo y React desmonta y vuelve a montar el subárbol, perdiendo su estado. Declara siempre los componentes a nivel de módulo.
  • Usar índices como clave en listas dinámicas, lo que provoca estados cruzados entre filas cuando se reordenan o eliminan elementos.
  • Declarar async directamente en la función del efecto. El efecto debe devolver nada o una función de limpieza, no una promesa; define una función asíncrona interna y llámala.

Un ejemplo de este último punto, con la forma incorrecta y la correcta:

// Incorrecto: el efecto devuelve una promesa
useEffect(async () => {
  const datos = await cargar();
  setDatos(datos);
}, []);

// Correcto: función asíncrona interna
useEffect(() => {
  let activo = true;
  async function iniciar() {
    const datos = await cargar();
    if (activo) setDatos(datos);
  }
  iniciar();
  return () => {
    activo = false;
  };
}, []);

La bandera activo evita actualizar el estado si el componente se desmontó mientras la petición estaba en curso. Es una variante sencilla del mismo principio que usa AbortController.

Pruebas y herramientas de apoyo

Probar componentes funcionales es más sencillo porque no hay instancias ni métodos internos que inspeccionar: se renderiza, se interactúa y se comprueba el resultado visible. La biblioteca de pruebas para React Native encaja bien con ese enfoque y permite buscar por texto, rol o etiqueta de accesibilidad, que son justo los atributos que ya definiste en tu botón:

import React from 'react';
import { render, screen, fireEvent } from '@testing-library/react-native';
import { Boton } from '../components/Boton';

test('ejecuta la acción al pulsar', () => {
  const alPulsar = jest.fn();
  render(<Boton etiqueta="Guardar" alPulsar={alPulsar} />);

  fireEvent.press(screen.getByRole('button', { name: 'Guardar' }));

  expect(alPulsar).toHaveBeenCalledTimes(1);
});

test('no ejecuta la acción si está deshabilitado', () => {
  const alPulsar = jest.fn();
  render(<Boton etiqueta="Guardar" alPulsar={alPulsar} deshabilitado />);

  fireEvent.press(screen.getByText('Guardar'));

  expect(alPulsar).not.toHaveBeenCalled();
});

Para ejecutar las pruebas y revisar el estilo del código, añade scripts a tu proyecto y lánzalos con regularidad:

npx jest
npx eslint components --ext .ts,.tsx
npx tsc --noEmit

Mantén activas las reglas de ESLint para Hooks, porque detectan de forma automática los dos fallos más caros: llamadas condicionales y dependencias incompletas. Durante una migración gradual, convierte componente por componente y deja las pruebas pasar en cada paso; no hace falta migrar todo el proyecto de una vez, ya que clases y funciones conviven sin problemas en el mismo árbol.

Estrategia para bases de código grandes

Si heredas una aplicación con decenas de clases, evita una conversión masiva en una sola entrega. Prioriza los componentes que vas a tocar de todos modos por una nueva funcionalidad o un error, empieza por los más pequeños y las hojas del árbol, y deja los contenedores complejos para el final. Un componente de clase que depende de un componente de orden superior puede requerir antes reemplazar ese envoltorio por un Hook propio. Anota los límites de error como excepciones permitidas, para que nadie intente convertirlos por error.

Una buena práctica de equipo es acordar una regla sencilla: todo código nuevo se escribe con funciones y Hooks, y el código antiguo se migra de forma oportunista. Así la deuda disminuye con cada cambio sin detener el desarrollo de producto.

Comparativa final: clases frente a funciones

Resumiendo las diferencias prácticas que has visto:

  • Sintaxis: la clase necesita herencia, constructor opcional, render y this; la función es una expresión directa que devuelve la interfaz.
  • Estado: la clase usa un solo objeto y setState que fusiona; la función usa uno o varios useState o useReducer que reemplazan.
  • Ciclo de vida: la clase reparte la lógica por momentos del ciclo; la función la agrupa por tema con useEffect.
  • Reutilización: la clase depende de componentes de orden superior y render props; la función usa Hooks propios.
  • Pruebas: la función es más fácil de probar porque no tiene instancia que inspeccionar.
  • Futuro: las nuevas funciones de React, como la optimización automática del compilador y las mejoras recientes de la biblioteca, están pensadas para funciones. Las clases siguen soportadas, pero sin evolución.
  • Excepción: los límites de error siguen exigiendo una clase.

Con este cuadro tienes los argumentos para defender la decisión ante el equipo: no se trata de una moda, sino de un modelo que reduce código, agrupa lógica relacionada y se alinea con la dirección del ecosistema.

Conclusiones

Los componentes funcionales con Hooks son hoy la forma estándar de construir interfaces en React Native, y lo son con razón. Permiten expresar estado, efectos y reutilización de lógica con menos código, sin la ceremonia de this y sin patrones de envoltura que oscurecían el flujo. Aprender a leer una clase sigue siendo útil porque encontrarás muchas en código heredado, pero escribir una nueva debería ser la excepción.

La traducción del ciclo de vida es el paso que más cuesta al principio. Recuerda que useEffect no es una copia de tres métodos, sino una forma de sincronizar tu componente con algo externo: declara qué dependencias usa, limpia lo que crea y separa cada preocupación en su propio efecto. Con esa idea, la migración se vuelve ordenada y predecible.

En el plano de la interfaz, construir tu propio botón con Pressable te da control sobre el aspecto, la retroalimentación táctil y la accesibilidad, y te deja una pieza que reutilizarás en toda la aplicación. Y para la robustez, los error boundaries son la excepción que justifica conservar una clase en tu base de código: colócalos en puntos estratégicos para que un fallo local no tire la aplicación completa.

Por último, mantén las versiones al día. El ecosistema avanza con rapidez, con Expo adoptando cada nueva versión estable de React Native y con la Nueva Arquitectura ya como comportamiento por defecto. Comprueba siempre la documentación oficial antes de actualizar, activa el linter de Hooks y migra de manera gradual. Si aplicas esas prácticas, tu código será más corto, más fácil de probar y estará preparado para lo que venga.