Skip to content

4. Capítulo 3 - Introducción a Flutter

4.1. Fuentes

Documentación oficial: https://docs.flutter.dev, en particular las páginas “What is Flutter?”, “Introduction to widgets” y “State management”. [Dart] (lenguaje): https://dart.dev/language

4.2. Lo que Flutter no es

Este es el punto de partida más importante de este capítulo, ya que difiere de manera significativa de las tres versiones anteriores de este curso. [Angular], [React], y [Vue.js] producen todos [JavaScript]/[TypeScript] COMPILADO, que es ejecutado por el motor de [JavaScript] ya presente en un navegador; este motor se encarga de todo el trabajo de visualización, a través del [DOM] y de [CSS]. Una herramienta como [Cordova]/[Capacitor] (no utilizada en este curso) sí permite empaquetar un cliente web de este tipo en un contenedor móvil, pero el cliente sigue ejecutándose en un navegador incrustado (un [WebView]), nunca de forma nativa.

[Flutter] no tiene nada que ver con todo esto. El código [Dart] de este documento se compila, tanto para móvil como para escritorio, en código máquina NATIVO (compilación [AOT], [Ahead-Of-Time], la misma familia de compilación que un programa en C++ o Rust), directamente ejecutable por el sistema operativo de destino; NO requiere ningún intérprete de [JavaScript] ni [WebView] de ningún tipo. [Flutter] incluye su propio motor de renderizado gráfico ([Impeller], que reemplazó a [Skia] como motor predeterminado en dispositivos móviles): la aplicación dibuja ella misma cada uno de sus píxeles, cuadro por cuadro, en lugar de delegar la visualización en los widgets nativos del sistema operativo (a diferencia de [React Native], que no se utiliza en este curso y que, en cambio, controla los componentes de interfaz reales de [Android]/[iOS]). Esta decisión arquitectónica es la que permite a [Flutter] mostrar una interfaz idéntica en los tres entornos a los que apunta este documento: no hay componentes nativos del sistema operativo cuyo aspecto pueda variar de una plataforma a otra.

En el destino [web], en cambio, obviamente no hay compilación a código máquina nativo: [flutter build web] compila el código [Dart] a [JavaScript] (o a [WebAssembly], un destino más reciente), que el navegador ejecuta, pero este [JavaScript] generado NO manipula el [DOM] ni el [HTML] como lo hace [Vue.js]: también dibuja directamente sobre un único elemento [<canvas>] (o mediante elementos [HTML] generados automáticamente, según el modo de renderizado elegido), reproduciendo así el mismo aspecto de [Flutter] que en móvil y escritorio, en lugar de depender de elementos [HTML] con estilos [CSS].

4.3. El modelo de desarrollo de Flutter: todo es un widget

[Angular], [React] y [Vue.js]: los tres distinguen la LÓGICA de un componente ([TypeScript]) de su PRESENTACIÓN (una plantilla [HTML], que puede estar separada o integrada según el framework; véase el capítulo 4 del documento de [Vue.js] de este curso, “Componentes: archivos [.vue] y [Composition API]”). [Flutter] elimina por completo esta distinción: TODO, dentro de una interfaz [Flutter], es un [Widget]: un botón, un texto, un margen, una alineación y un color de fondo son, cada uno, un widget, y una interfaz completa no es más que un ÁRBOL de widgets anidados unos dentro de otros, descrito mediante código [Dart] ordinario (el método [build(BuildContext context)]) en lugar de un lenguaje de plantillas separado; en este aspecto, [Flutter] lleva todavía más lejos la decisión que ya tomó [React] ([JSX], de [JavaScript], que describe la interfaz): mientras que [JSX] sigue siendo un lenguaje de marcado MEZCLADO con [JavaScript], [build(...)] simplemente devuelve una EXPRESIÓN de [Dart], llamadas anidadas a constructores ([Scaffold(appBar: ..., body: Column(children: [...]))]), sin ninguna sintaxis adicional que aprender.

4.4. StatelessWidget y StatefulWidget: mientras que Vue.js no exige ninguna distinción

[Vue.js] (al igual que [React] y [Angular] antes en este curso) no hace ninguna distinción estructural entre un componente que tiene un estado mutable y uno que no lo tiene: [ref(...)] puede llamarse o no dentro de cualquier [<script setup>], sin cambiar nada en la declaración del componente en sí. [Flutter] IMPONE esta distinción desde la declaración de la clase: un [StatelessWidget] (nada cambia nunca después de su construcción; véanse [ScheduleView] y [LoginPage] en el capítulo 4) vuelve a ejecutar su método [build(...)] ÚNICAMENTE cuando cambian sus parámetros; un [StatefulWidget] se acompaña de una clase [State<T>] independiente (véanse [_LoginFormState], [_AppRootState]..., capítulo 4), que contiene el estado mutable y el método [setState(() { ... })], la llamada EXPLÍCITA que desencadena un nuevo renderizado, mientras que [reactive(...)] en el lado de [Vue.js] detecta automáticamente cada escritura de propiedad. Esta separación en dos clases (Widget/State) es el resultado directo de una decisión de diseño deliberada de [Flutter]: un objeto [Widget] es INMUTABLE (se reconstruye en cada renderizado, como un simple objeto de configuración), mientras que su [State] asociado SOBREVIVE de un renderizado al siguiente.

4.5. Compartir estado entre widgets: provider, el equivalente de provide/inject

[Vue.js] comparte estado entre componentes distantes mediante el par [provide]/[inject]; [React] utiliza un [Context]; [Angular] utiliza un servicio singleton inyectable. [Flutter] no incorpora ninguno de estos mecanismos en el propio framework: para este fin sirve el paquete de terceros [provider] (véase [pubspec.yaml], capítulo 4), prácticamente indispensable en el ecosistema [Flutter]. Su principio: una clase [ChangeNotifier] (una clase [Dart] estándar, que puede notificar un cambio a sus oyentes mediante [notifyListeners()]) se pone a disposición de todo un subárbol de widgets mediante un [ChangeNotifierProvider] colocado en su raíz (véase [MultiProvider] en [lib/main.dart], que equivale a las llamadas [app.provide(key, value)] del lado de [Vue.js]); cualquier widget descendiente lo vuelve a leer entonces mediante [context.watch<MyService>()] (se suscribe a los cambios futuros; el equivalente de [useXxx()] del lado de [Vue.js]) o [context.read<MyService>()] (lectura puntual, sin resuscripción; una distinción que [Vue.js] no necesita hacer).

Diferencia clave con [reactive(...)]: un [ChangeNotifier] no detecta automáticamente NADA. [reactive(...)] envuelve un objeto en un proxy de [JavaScript] que intercepta cada LECTURA y cada ESCRITURA de propiedades; un [ChangeNotifier] [Dart] es una clase normal, y corresponde al desarrollador llamar explícitamente a [notifyListeners()] después de cada modificación que deba desencadenar un nuevo renderizado; esto exige más disciplina manual, a cambio de un mecanismo que no depende de proxies “mágicos” para ser entendido.

4.6. Sin un lenguaje de plantillas aparte: renderizado condicional y listas

[v-if]/[v-else] y [v-for] ([Vue.js]), como [@if]/[@for] del lado de [Angular], o los operadores ternarios && y [.map(...)] del lado de [React], se convierten, en [Flutter], de nuevo en expresiones ORDINARIAS de [Dart], directamente dentro de [build(...)]: un [if]/[else] clásico de [Dart] para una condición, y [.map((element) => Widget(...)).toList()] para una lista; el mismo concepto que [.map(...)] del lado de [React], ya que [Flutter], al igual que [React], no reconoce un “lenguaje de plantillas” separado y distinto del propio lenguaje de programación. La sintaxis [if (condition) ...[ WidgetA, WidgetB ]] (“if collection”, utilizada por ejemplo en [lib/app.dart], capítulo 4) lleva esta lógica un paso más allá que [React]: una CONDICIÓN insertada directamente dentro de una lista literal de widgets, sin operador ternario ni función intermedia.

4.7. Dart: un primo cercano de TypeScript, no de JavaScript

[Dart] nunca estuvo pensado como una alternativa a [TypeScript] para la web (a diferencia de este último, que fue diseñado específicamente como un superconjunto de [JavaScript]): es un lenguaje independiente, de tipado ESTÁTICO desde el origen (sin modo “[any]” implícito), compilado, nunca interpretado tal cual. Para un desarrollador que viene de [TypeScript] (como las tres variantes anteriores de este curso), lo esencial se traduce casi directamente: clases, interfaces ([Dart] utiliza [abstract class] o simples clases implementadas, en lugar de una palabra clave [interface] independiente), genéricos ([ServerResponse<T>], véase el capítulo 4), [async]/[await] sobre [Future<T>] (el equivalente EXACTO de [Promise<T>] en [TypeScript]) y una verificación de nulabilidad integrada en el sistema de tipos ([String?] en lugar de una cadena siempre presente; el equivalente del modo [strict] de [TypeScript], pero impuesto por el propio lenguaje y no por una opción del compilador).

Una diferencia notable, que aparece en todos los archivos del capítulo siguiente que decodifican JSON ([core/models/appointment_models.dart]): [TypeScript] elimina sus tipos en tiempo de compilación: una [interface] se verifica solo en tiempo de compilación y un objeto JSON decodificado se utiliza luego TAL CUAL en tiempo de ejecución ([JSON.parse(...) as ServerResponse<T>], una simple promesa hecha al compilador). [Dart], en cambio, tiene sus tipos determinados en tiempo de ejecución: [jsonDecode(...)] siempre devuelve tipos dinámicos ([Map<String, dynamic>]), que deben convertirse explícitamente en instancias de clases mediante un constructor [fromJson(...)] escrito a mano; es más extenso al principio, pero una clave ausente o de un tipo inesperado provoca entonces una excepción inmediata y clara, en lugar de propagarse silenciosamente.

4.8. Un primer ejemplo mínimo

Esta es la aplicación [Flutter] más pequeña que muestra algo en la pantalla; compárela con [lib/main.dart]/[lib/app.dart] del capítulo 4, que tienen muchas más funcionalidades pero están construidos con EXACTAMENTE los mismos bloques ([runApp(...)], [MaterialApp] y un widget raíz).

import 'package:flutter/material.dart';

void main() {
  runApp(
    const MaterialApp(
      home: Scaffold(
        body: Center(child: Text('Hello, RdvMedecins!')),
      ),
    ),
  );
}

Revisemos este código:

  • Línea 1: [import 'package:flutter/material.dart';] : equivalente a [import { ... } from 'vue']: [material.dart] incluye todos los widgets de “Material Design” ([Google]) utilizados en este documento: botones, campos de texto, barras de aplicación, etc. [Flutter] también ofrece un conjunto de widgets [Cupertino] (con el estilo de [iOS]), que no se utilizan en este curso, para quienes prefieran este estilo en dispositivos móviles ([Apple]).
  • Línea 3: [void main() {] : el punto de entrada de un programa [Dart], EXACTAMENTE como el de un programa [C]/[Java]. [Flutter] no tiene un equivalente del [HTML] de una página web, en el que se incrustaría un script [main.ts]: la aplicación se inicia AQUÍ directamente.
  • Línea 4: [runApp(...)] : inicia el motor de renderizado [Flutter] y le proporciona el widget raíz que debe mostrar; el equivalente de [createApp(App).mount('#app')] del lado de [Vue.js] ([src/main.ts]), en una sola llamada en lugar de dos.
  • líneas 5–9: [MaterialApp(home: Scaffold(body: Center(...)))] : un ÁRBOL de widgets anidados, cada uno con una responsabilidad específica: [MaterialApp] configura el tema y la navegación; [Scaffold] proporciona la estructura estándar de la pantalla (área para una barra de aplicación, área de contenido, etc.); [Center] centra su hijo; [Text] muestra una cadena de texto. Ninguno de estos cuatro widgets es un caso especial del lenguaje: son simplemente CLASES de [Dart], como las que este curso escribirá por sí mismo en el capítulo siguiente.

4.9. Resumen: Angular -> React -> Vue.js -> Flutter

Consulte también el archivo [README.md] incluido con el código de este capítulo para ver la versión completa.

  • Componentes de [Angular] / archivos [.vue] / [.tsx] archivos → [Widgets] [Dart] ([StatelessWidget]/[StatefulWidget])
  • [signal()]/[ref()]/[useState()] → campos mutables + [setState(...)] (estado local), [ChangeNotifier] (estado compartido)
  • [input()]/[output()], [defineProps]/[defineEmits], propiedades de función → parámetros del constructor (entradas), funciones pasadas como parámetros (salidas)
  • servicios inyectables/composables + [provide]/[inject]/[Context] → clases de servicio + paquete [provider]
  • plantilla independiente de [Angular], [<template>], [Vue.js], [JSX], [React] → método [build(BuildContext)] (Dart puro)
  • [HttpClient]/[fetch] → paquete [http]
  • [localStorage] → [shared_preferences]
  • Sin enrutador (aplicación de una sola pantalla, en las 5 variantes de este curso)