StatelessWidget en Flutter: cuándo usarlo y cómo funciona

Nos ayudas mucho si nos sigues en Google Seguir en

Usa StatelessWidget cuando una parte de la interfaz de Flutter se pueda describir a partir de los datos que recibe, sin guardar estado mutable propio. Es adecuado para una pantalla informativa, una tarjeta de producto o un botón personalizado. Si esa parte debe recordar cambios —por ejemplo, si un contador ha aumentado—, el estado tiene que vivir en un StatefulWidget o en otro mecanismo de gestión de estado, y el widget sin estado puede limitarse a mostrarlo.

El nombre puede llevar a confusión: «sin estado» no quiere decir que el widget se dibuje una sola vez ni que su aspecto nunca cambie. Flutter puede volver a ejecutar su método build cuando cambian las condiciones de la interfaz. La distinción importante es si el propio widget conserva estado mutable, no si su representación visual permanece siempre igual.

Qué representa un StatelessWidget

Un widget en Flutter es una descripción de una parte de la interfaz. Un StatelessWidget es una clase que proporciona esa descripción mediante build(BuildContext context). El método devuelve otros widgets, que pueden formar una composición de filas, textos, imágenes, botones y contenedores.

La clase del widget es inmutable: sus propiedades no se modifican después de crear la instancia. Por eso suelen declararse como final y se asignan en el constructor. Si los datos cambian, el código que crea la interfaz produce otra instancia con los valores nuevos; Flutter compara esa descripción con la anterior y actualiza la interfaz cuando corresponde.

class Saludo extends StatelessWidget {
  const Saludo({super.key, required this.nombre});

  final String nombre;

  @override
  Widget build(BuildContext context) {
    return Text('Hola, $nombre');
  }
}

En este ejemplo, Saludo no decide ni guarda el nombre. Lo recibe de quien lo utiliza. Si el padre construye Saludo(nombre: 'Lucía') y después lo vuelve a construir con otro nombre, la interfaz puede reflejar el valor nuevo sin que Saludo mantenga una variable interna mutable.

Por qué puede reconstruirse aunque no tenga estado

El método build se puede ejecutar más de una vez. Por ejemplo, un widget padre puede reconstruirse tras un cambio de estado y volver a crear sus hijos. También puede reconstruirse una parte de la interfaz cuando cambian datos heredados del árbol, como un tema o una localización a la que el widget accede mediante el BuildContext.

En cada ejecución, build debe describir cómo tiene que verse esa parte de la interfaz en ese momento. Por eso no es el lugar adecuado para realizar tareas con efectos secundarios, como enviar una petición de red, escribir en un archivo o iniciar repetidamente un proceso. Esas acciones pertenecen a un flujo de control apropiado para la aplicación, no a la mera descripción visual.

Flutter separa el widget —la configuración inmutable— de los objetos internos que mantienen la estructura y el dibujo en pantalla. Que se vuelva a ejecutar build no implica necesariamente que cada elemento visible se destruya y se cree desde cero: el marco de trabajo puede reutilizar elementos compatibles y actualizar lo que haya cambiado. Por tanto, «sin estado» describe la responsabilidad de la clase, no una garantía de ausencia de reconstrucciones.

Cuándo elegirlo y cuándo hace falta estado

Datos recibidos desde fuera

Un widget es buen candidato a StatelessWidget si sus valores llegan por el constructor o se consultan en el contexto y su trabajo consiste en representarlos. Una etiqueta que muestra el nombre de una categoría, un icono con un color recibido o una tarjeta que presenta un producto encajan en este patrón.

Interacción que modifica la interfaz

Un botón también puede estar dentro de un StatelessWidget. Lo que importa es dónde vive la consecuencia de tocarlo. Si el botón llama a una función recibida como parámetro y el padre es quien actualiza los datos, el botón no necesita guardar el estado. Si, en cambio, el widget debe recordar por sí mismo si un panel está abierto o cuántas veces se ha pulsado, necesita un lugar donde conservar ese valor.

Un criterio práctico es preguntarse: ¿qué componente es responsable de que este dato siga existiendo entre reconstrucciones? Si la respuesta es el componente actual, probablemente necesita estado. Si otro componente controla el dato y se lo pasa, el actual puede seguir siendo sin estado.

Un ejemplo: un contador con la responsabilidad bien separada

Supongamos una pantalla con un contador y un botón para incrementarlo. La pantalla, que conoce y modifica el número, puede ser un StatefulWidget. Un componente de presentación puede recibir el valor y una función para solicitar el cambio:

class ContadorVista extends StatelessWidget {
  const ContadorVista({
    super.key,
    required this.valor,
    required this.alIncrementar,
  });

  final int valor;
  final VoidCallback alIncrementar;

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Text('Pulsaciones: $valor'),
        ElevatedButton(
          onPressed: alIncrementar,
          child: const Text('Sumar'),
        ),
      ],
    );
  }
}

ContadorVista muestra el número que recibe y comunica la interacción mediante alIncrementar. No incrementa ni almacena el valor por su cuenta. El padre actualiza su estado y vuelve a proporcionar los datos. Esta separación facilita reutilizar la vista y entender qué parte controla el comportamiento.

Si el componente tuviera que gestionar por sí mismo el número, declarar una variable normal dentro de build no serviría: se volvería a inicializar cada vez que el método se ejecutase. En ese caso se necesita estado persistente, por ejemplo con StatefulWidget y su objeto State, o con una solución de estado compartido adecuada al alcance de la aplicación.

El papel de const y de las claves

Es habitual ver constructores con const en widgets sin estado. Esto permite crear instancias constantes cuando todos sus argumentos también lo permiten, como en const Text('Listo'). La constancia puede ayudar a Flutter a reconocer que una configuración no ha cambiado y evitar trabajo innecesario en algunos casos. No convierte el widget en una pieza que jamás se reconstruye ni es un requisito para que la clase funcione.

Las claves, como Key, cumplen otra función: ayudan a identificar widgets cuando el árbol cambia de orden o cuando hay elementos similares en una lista. No añaden estado a un StatelessWidget ni sustituyen a una decisión correcta sobre quién conserva los datos. Se incorporan cuando la identidad de los elementos importa, no como adorno en todos los widgets.

Errores habituales al aplicar este patrón

  • Guardar el dato en una variable local de build. Esa variable no persiste entre ejecuciones. El estado debe vivir en un objeto diseñado para conservarlo.
  • Confundir una propiedad final con un valor globalmente inmutable. La referencia guardada no se reasigna, pero si apunta a un objeto mutable, ese objeto todavía podría cambiar. Para mantener una descripción predecible, es preferible pasar valores que no se muten de forma inesperada.
  • Convertir cualquier componente interactivo en stateful. Un componente puede recibir datos y callbacks sin gestionar directamente el estado que representan.
  • Suponer que StatelessWidget mejora siempre el rendimiento. La elección debe responder a quién es responsable del estado y a cómo se organiza la interfaz; la palabra «stateless» por sí sola no garantiza una aplicación más rápida.

En resumen práctico, elige StatelessWidget para una vista que representa entradas, propiedades o datos heredados, y reserva el estado para el componente que realmente debe conservar y cambiar esos datos. Esta división hace más explícito el flujo de información y permite construir interfaces de Flutter con responsabilidades más fáciles de seguir. Para seguir aprendiendo sobre el ecosistema, puedes consultar otros contenidos de Flutter.

Publicaciones Similares

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *