Dart: o que é, características da linguagem Flutter e programação

O que é Dart?

Dart é uma linguagem de programação com sintaxe semelhante a C, desenvolvida pelo Google sob a liderança de Lars Bak (criador do Eclipse). O primeiro lançamento foi em 2011, mas Dart ganhou popularidade real em 2018 com o lançamento do Flutter 1.0. A linguagem é projetada para criar interfaces de usuário: possui suporte nativo a streams, futures e padrões reativos.

A filosofia do Dart é «equilíbrio entre desempenho e produtividade». A linguagem suporta duas estratégias de compilação: JIT (Just-In-Time) para desenvolvimento com recarga a quente e AOT (Ahead-Of-Time) para builds de produção com desempenho nativo. O compilador JIT injeta código modificado em uma aplicação em execução em milissegundos, sem exigir recompilação do APK — esta é a principal vantagem do Dart sobre outras linguagens no desenvolvimento móvel.

Um recurso chave do Dart é sound null safety, introduzido no Dart 2.12 (2021). O sistema de tipos garante que uma variável não pode ser null sem declaração explícita (int?). Isso elimina NullPointerException em tempo de compilação. Segundo o Google, a adoção do null safety reduziu as taxas de falhas em aplicações Flutter em 30% em ambientes de produção.

Ecossistema Dart

O ecossistema Dart inclui três áreas principais: Flutter (aplicações móveis e desktop), AngularDart (aplicações web) e Dart Server (soluções de servidor). Flutter é a plataforma dominante: de acordo com a Statista (2025), Flutter é usado em 46% dos projetos móveis multiplataforma, à frente de React Native (38%) e Xamarin (8%).

Sintaxe do Dart: tipos, funções e classes

A sintaxe do Dart lembra Java e JavaScript, mas possui construções únicas próprias. Tudo no Dart é um objeto — até int, double e bool herdam de Object. A tipagem é opcional: uma variável declarada como var infere o tipo automaticamente, mas é recomendável especificar os tipos explicitamente para legibilidade e desempenho.

Tipos básicos e declarações

Dart suporta int, double, String, bool, List, Set, Map, Record, Symbol e Runes. Tipo nullable — qualquer tipo com o sufixo ? (int?, String?). O operador ?? (null-aware) retorna o valor à direita se o da esquerda for null. A notação cascata (..) permite chamar vários métodos no mesmo objeto sem repetir a referência.

// Tipos básicos e declarações em Dart
void main() {
  // Tipagem explícita
  int age = 25;
  double price = 19.99;
  String name = 'Dart';
  bool isValid = true;

  // Null safety — variável pode ser null
  int? nullableAge = null;
  int result = nullableAge ?? 0; // Operador null-aware

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

  // Notação cascata
  final list = <String>[]
    ..add('one')
    ..add('two')
    ..sort();
}

// Record — tipo imutável anônimo
(String, int) user = ('Alice', 30);
print(user.$1); // 'Alice'

O tipo dynamic desativa a verificação de tipos — use-o apenas ao trabalhar com JSON ou dados dinâmicos. Record é um novo tipo no Dart 3.0 que permite agrupar valores sem criar uma classe separada. O operador null-aware ?? é a forma padrão de trabalhar com valores nullable, substituindo longas verificações if-else.

Classes e mixins

Classes no Dart — herança única (extends), múltipla através de mixins (mixin). Dart não suporta interfaces como um conceito separado — qualquer classe pode ser implementada (implements). Um mixin é uma classe sem construtor cujos métodos e campos podem ser adicionados a qualquer classe usando a palavra-chave with.

// Classes, herança e mixins em Dart
abstract class Animal {
  void sound(); // método abstrato
}

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...
}

// Construtor nomeado
class Config {
  final String env;

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

A classe Duck herda de Animal e usa dois mixins — Swimmer e Flyer. Isso demonstra herança múltipla sem problemas de diamante: os mixins são resolvidos linearmente (super chain). Construtores nomeados (Config.development) são uma alternativa a métodos de fábrica estáticos para criar objetos com parâmetros predefinidos.

Assincronia no Dart: Future, Stream e async/await

Assincronia no Dart é implementada através de Future (valor único), Stream (sequência de valores) e async/await. Dart usa um modelo de thread única com loop de eventos, semelhante ao JavaScript, mas com uma diferença importante: cálculos longos não bloqueiam a UI porque o código Dart é executado em um Isolate — uma thread separada sem memória compartilhada.

Future representa uma operação assíncrona que será concluída após algum tempo. Um Future pode estar em estado pendente, concluído com valor ou concluído com erro. A cadeia .then().catchError() é uma alternativa ao async/await, mas recomenda-se usar await para legibilidade.

// Carregamento assíncrono de dados com Future e Stream
import 'dart:convert';
import 'package:http/http.dart' as http;

class ApiService {
  final String baseUrl;

  ApiService(this.baseUrl);

  // Future para uma única requisição
  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 uma sequência de dados
  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');

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

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

A classe ApiService demonstra dois tipos de assincronia: Future para uma requisição HTTP (resposta única) e Stream para um contador sequencial (gerador com async* e yield). Stream é eficaz para trabalhar com sensores, geolocalização, Firebase Realtime Database — em qualquer lugar onde os dados chegam continuamente. Isolate usa memória separada — os dados são transmitidos via SendPort/ReceivePort.

Dart e Flutter: arquitetura da aplicação

Dart e Flutter formam uma pilha única: Flutter é o framework UI, Dart é a linguagem de descrição de UI. No Flutter, tudo é um widget — de um botão a uma aplicação inteira. Widgets podem ser stateful (com estado mutável) e stateless (imutáveis). Dart descreve UI declarativa: build() retorna uma árvore de widgets que o Flutter renderiza usando Skia (ou Impeller no iOS).

Estrutura de uma aplicação Flutter

Uma aplicação Flutter em Dart consiste em main() → runApp(MyApp()) → MaterialApp. MaterialApp inclui roteamento (routes), tema (theme) e localização. Cada tela é um Scaffold contendo AppBar, Body (geralmente Column/ListView) e BottomNavigationBar. Navegação via Navigator.push/pop ou rotas nomeadas.

// Aplicação Flutter simples em 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),
      ),
    );
  }
}

O widget HomeScreen é um StatefulWidget com estado interno _counter. Chamar setState() notifica o Flutter para reconstruir a UI — o código Dart reexecuta build(), criando uma nova árvore de widgets. O Flutter compara (diff) eficientemente a árvore antiga e a nova, atualizando apenas as partes alteradas da tela. Hot Reload substitui build() sem redefinir o estado _counter.

Compilação do Dart: JIT vs AOT

A compilação do Dart é híbrida: JIT para desenvolvimento e AOT para produção. No modo de depuração, a Dart VM executa um compilador JIT que interpreta bytecode com capacidade de troca a quente de código. No modo release, dart compile exe ou flutter build cria um binário AOT nativo para uma arquitetura específica (arm64, x86_64, armv7).

A compilação JIT do Dart no modo de depuração fornece recarga a quente em ~1 segundo — os desenvolvedores veem alterações na UI sem perder o estado da aplicação. A compilação AOT oferece desempenho próximo ao de aplicações nativas Swift/Kotlin. Segundo o Google, Flutter com Dart AOT atinge animações de 60 FPS mesmo em dispositivos de gama média.

Ferramentas do desenvolvedor Dart

Ferramentas do desenvolvedor Dart incluem o Dart SDK (compilador dart, dartanalyzer, dartfmt, pub), Flutter SDK e plugins de IDE. O Dart SDK é instalado junto com o Flutter SDK na pasta flutter/bin/cache/dart-sdk. Pub é o gerenciador de pacotes que lê pubspec.yaml e baixa dependências do pub.dev.

Ferramentas principais

dart analyze — analisador estático que verifica tipos, importações não utilizadas e erros potenciais. dart format — formatador que formata automaticamente o código em um estilo consistente. dart doc — gerador de documentação a partir de comentários ///. Flutter DevTools — perfilador com inspetor de árvore de widgets, logs, memória e rede. Dart VM Service — depuração de uma aplicação em execução via WebSocket.

# pubspec.yaml — configuração do projeto 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

O arquivo pubspec.yaml descreve as dependências do projeto Dart. O campo environment:sdk especifica a versão do Dart — a estável atual é 3.x. Dependencies são as bibliotecas principais, dev_dependencies são para teste e geração de código. json_annotation + json_serializable geram código de serialização JSON via build_runner. flutter_lints é um conjunto de regras para o analisador.