Dart: qué es, características del lenguaje Flutter y programación

¿Qué es Dart?

Dart es un lenguaje de programación con sintaxis similar a C, desarrollado por Google bajo la dirección de Lars Bak (creador de Eclipse). El primer lanzamiento fue en 2011, pero Dart ganó verdadera popularidad en 2018 con el lanzamiento de Flutter 1.0. El lenguaje está diseñado para crear interfaces de usuario: tiene soporte integrado para streams, futures y patrones reactivos.

La filosofía de Dart es «equilibrio entre rendimiento y productividad». El lenguaje admite dos estrategias de compilación: JIT (Just-In-Time) para desarrollo con recarga en caliente y AOT (Ahead-Of-Time) para builds de producción con rendimiento nativo. El compilador JIT inyecta código modificado en una aplicación en ejecución en milisegundos, sin requerir recompilación del APK — esta es la ventaja clave de Dart sobre otros lenguajes en el desarrollo móvil.

Una característica clave de Dart es sound null safety, introducida en Dart 2.12 (2021). El sistema de tipos garantiza que una variable no puede ser null sin declaración explícita (int?). Esto elimina NullPointerException en tiempo de compilación. Según Google, la adopción de null safety redujo las tasas de fallos en aplicaciones Flutter en un 30% en entornos de producción.

Ecosistema de Dart

El ecosistema de Dart incluye tres áreas principales: Flutter (aplicaciones móviles y de escritorio), AngularDart (aplicaciones web) y Dart Server (soluciones de servidor). Flutter es la plataforma dominante: según Statista (2025), Flutter se utiliza en el 46% de los proyectos móviles multiplataforma, superando a React Native (38%) y Xamarin (8%).

Sintaxis de Dart: tipos, funciones y clases

La sintaxis de Dart se asemeja a Java y JavaScript, pero tiene sus propias construcciones únicas. Todo en Dart es un objeto — incluso int, double y bool heredan de Object. La tipificación es opcional: una variable declarada como var infiere el tipo automáticamente, pero se recomienda especificar los tipos explícitamente para la legibilidad y el rendimiento.

Tipos básicos y declaraciones

Dart admite int, double, String, bool, List, Set, Map, Record, Symbol y Runes. Tipo nullable — cualquier tipo con el sufijo ? (int?, String?). El operador ?? (null-aware) devuelve el valor de la derecha si el de la izquierda es null. La notación en cascada (..) permite llamar a varios métodos en el mismo objeto sin repetir la referencia.

// Tipos básicos y declaraciones en Dart
void main() {
  // Tipificación explícita
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — la variable puede ser null
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Operador null-aware

  // Colecciones con genéricos
  List<String> items = ['Dart', 'Flutter', 'Mobile'];
  Map<String, dynamic> config = {
    'version': '3.0',
    'mode': 'debug',
  };

  // Notación en cascada
  final list = <String>[]
    ..add('one')
    ..add('two')
    ..sort();
}

// Record — tipo inmutable anónimo
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

El tipo dynamic desactiva la comprobación de tipos — úselo solo al trabajar con JSON o datos dinámicos. Record es un nuevo tipo en Dart 3.0 que permite agrupar valores sin crear una clase separada. El operador null-aware ?? es la forma estándar de trabajar con valores nullable, reemplazando largas comprobaciones if-else.

Clases y mixins

Las clases en Dart — herencia única (extends), múltiple mediante mixins (mixin). Dart no admite interfaces como concepto separado — cualquier clase puede ser implementada (implements). Un mixin es una clase sin constructor cuyos métodos y campos pueden añadirse a cualquier clase usando la palabra clave with.

// Clases, herencia y mixins en Dart
abstract class Animal {
  void sound(); // método abstracto
}

mixin Swimmer {
  void swim() => print('Swimming...');
}

mixin Flyer {
  void fly() => print('Flying...');
}

class Duck extends Animal with Swimmer, Flyer {
  @override
  void sound() => print('Quack!');
}

void main() {
  final duck = Duck();
  duck.sound(); // Quack!
  duck.swim();  // Swimming...
  duck.fly();   // Flying...
}

// Constructor con nombre
class Config {
  final String env;

  Config.development() : env = 'dev';
  Config.production()  : env = 'prod';
}

La clase Duck hereda de Animal y usa dos mixins — Swimmer y Flyer. Esto demuestra herencia múltiple sin problemas de diamante: los mixins se resuelven linealmente (super chain). Los constructores con nombre (Config.development) son una alternativa a los métodos de fábrica estáticos para crear objetos con parámetros predefinidos.

Asincronía en Dart: Future, Stream y async/await

La asincronía en Dart se implementa mediante Future (valor único), Stream (secuencia de valores) y async/await. Dart utiliza un modelo de un solo hilo con un bucle de eventos, similar a JavaScript, pero con una diferencia importante: los cálculos largos no bloquean la UI porque el código Dart se ejecuta en un Isolate — un hilo separado sin memoria compartida.

Future representa una operación asíncrona que se completará después de un tiempo. Un Future puede estar en estado pendiente, completado con valor o completado con error. La cadena .then().catchError() es una alternativa a async/await, pero se recomienda usar await para la legibilidad.

// Carga asíncrona de datos con Future y Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future para una sola solicitud
  Future<Map<String, dynamic>> fetchUser(int id) async {
    final response = await http.get(
      Uri.parse('$baseUrl/users/$id'),
    );

    if (response.statusCode == 200) {
      return jsonDecode(response.body);
    } else {
      throw Exception('Failed to load user: ${response.statusCode}');
    }
  }

  // Stream para una secuencia de datos
  Stream<int> countStream(int max) async* {
    for (var i = 1; i <= max; i++) {
      await Future.delayed(Duration(seconds: 1));
      yield i;
    }
  }
}

void main() async {
  final api = ApiService('https://api.example.com');

  // Uso de await
  final user = await api.fetchUser(1);
  print('User: ${user['name']}');

  // Procesamiento de Stream con await for
  await for (final count in api.countStream(5)) {
    print('Count: $count');
  }
}

La clase ApiService demuestra dos tipos de asincronía: Future para una solicitud HTTP (respuesta única) y Stream para un contador secuencial (generador con async* y yield). Stream es efectivo para trabajar con sensores, geolocalización, Firebase Realtime Database — en cualquier lugar donde los datos lleguen continuamente. Isolate usa memoria separada — los datos se transmiten mediante SendPort/ReceivePort.

Dart y Flutter: arquitectura de la aplicación

Dart y Flutter forman una pila única: Flutter es el framework UI, Dart es el lenguaje de descripción de UI. En Flutter, todo es un widget — desde un botón hasta una aplicación completa. Los widgets pueden ser stateful (con estado mutable) y stateless (inmutables). Dart describe UI declarativa: build() devuelve un árbol de widgets que Flutter renderiza usando Skia (o Impeller en iOS).

Estructura de una aplicación Flutter

Una aplicación Flutter en Dart consiste en main() → runApp(MyApp()) → MaterialApp. MaterialApp incluye enrutamiento (routes), tema (theme) y localización. Cada pantalla es un Scaffold que contiene AppBar, Body (generalmente Column/ListView) y BottomNavigationBar. Navegación mediante Navigator.push/pop o rutas nombradas.

// Aplicación Flutter simple en Dart
import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Dart Demo',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: HomeScreen(),
    );
  }
}

class HomeScreen extends StatefulWidget {
  @override
  _HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  int _counter = 0;

  void _increment() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Dart + Flutter')),
      body: Center(
        child: Text('Counter: $_counter'),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _increment,
        child: Icon(Icons.add),
      ),
    );
  }
}

El widget HomeScreen es un StatefulWidget con estado interno _counter. Llamar a setState() notifica a Flutter que debe reconstruir la UI — el código Dart vuelve a ejecutar build(), creando un nuevo árbol de widgets. Flutter compara (diff) eficientemente el árbol antiguo y el nuevo, actualizando solo las partes cambiadas de la pantalla. Hot Reload reemplaza build() sin restablecer el estado de _counter.

Compilación de Dart: JIT vs AOT

La compilación de Dart es híbrida: JIT para desarrollo y AOT para producción. En modo depuración, la Dart VM ejecuta un compilador JIT que interpreta bytecode con capacidad de intercambio en caliente de código. En modo release, dart compile exe o flutter build crea un binario AOT nativo para una arquitectura específica (arm64, x86_64, armv7).

La compilación JIT de Dart en modo depuración proporciona recarga en caliente en ~1 segundo — los desarrolladores ven cambios en la UI sin perder el estado de la aplicación. La compilación AOT ofrece un rendimiento cercano a las aplicaciones nativas Swift/Kotlin. Según Google, Flutter con Dart AOT alcanza animaciones de 60 FPS incluso en dispositivos de gama media.

Herramientas de desarrollo de Dart

Las herramientas de desarrollo de Dart incluyen el Dart SDK (compilador dart, dartanalyzer, dartfmt, pub), Flutter SDK y plugins de IDE. El Dart SDK se instala junto con el Flutter SDK en la carpeta flutter/bin/cache/dart-sdk. Pub es el gestor de paquetes que lee pubspec.yaml y descarga dependencias de pub.dev.

Herramientas clave

dart analyze — analizador estático que verifica tipos, importaciones no utilizadas y errores potenciales. dart format — formateador que da formato automáticamente al código con un estilo consistente. dart doc — generador de documentación a partir de comentarios ///. Flutter DevTools — perfilador con inspector de árbol de widgets, registros, memoria y red. Dart VM Service — depuración de una aplicación en ejecución mediante WebSocket.

# pubspec.yaml — configuración del proyecto Dart
name: my_flutter_app
description: A new Flutter project.
version: 1.0.0

environment:
  sdk: '>=3.0.0 <4.0.0'

dependencies:
  flutter:
    sdk: flutter
  http: ^1.2.0
  provider: ^6.1.0
  shared_preferences: ^2.2.0
  json_annotation: ^4.8.0

dev_dependencies:
  flutter_test:
    sdk: flutter
  build_runner: ^2.4.0
  json_serializable: ^6.7.0
  flutter_lints: ^3.0.0

El archivo pubspec.yaml describe las dependencias del proyecto Dart. El campo environment:sdk especifica la versión de Dart — la estable actual es 3.x. Dependencies son las librerías principales, dev_dependencies para pruebas y generación de código. json_annotation + json_serializable generan código de serialización JSON mediante build_runner. flutter_lints es un conjunto de reglas para el analizador.