Dart sound null safety: prévia técnica 2
Anunciando o suporte null-safe para o framework Flutter
O Dart tem um papel especial no Flutter: ele alimenta recursos para desenvolvedores, como o hot reload, e possibilita apps multiplataforma para mobile, desktop e web por meio da tecnologia flexível de compilação do Dart. Nos esforçamos para tornar a linguagem Dart a mais produtiva para desenvolvedores de apps Flutter; por exemplo, adicionamos construções de linguagem UI-as-code para otimizar a sintaxe do Dart para programar árvores de widgets do Flutter.
Em junho, oferecemos uma primeira prévia técnica de null safety para o Dart. Hoje é outro marco importante, pelo qual esperávamos há um tempo: anunciamos uma segunda prévia técnica do sound null safety, incluindo suporte ao framework Flutter.
O null safety é um grande novo recurso de produtividade que ajuda você a evitar exceções de null, uma classe de bugs que costuma ser difícil de notar. Como um bônus extra, esse recurso também possibilita uma série de melhorias de desempenho. Estamos realmente ansiosos pelo seu feedback.
Por que null safety?
O Dart é uma linguagem com tipagem segura. Isso significa que, quando você obtém uma variável de algum tipo, o compilador pode garantir que ela é desse tipo. Mas a segurança de tipos, por si só, não garante que a variável não seja nula.
Erros de null são muito comuns. Uma busca no GitHub leva a milhares de issues causadas por valores nulos inesperados em código Dart, e a milhares de commits tentando corrigir esses problemas. Veja se você consegue identificar os problemas de nulabilidade no app Flutter a seguir, imaginando que
Config e WeatherService são serviços de backend usados pelo app:
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
// Get data from services. Note: in a real application,
// these would be async calls, but we're using sync calls
// for simplicity.
final localizedAppName = Config.getAppName();
final temperatures = WeatherService.getTemperatures();
return MaterialApp(
home: Scaffold(
appBar: AppBar(title: Text(localizedAppName)),
body: Padding(
padding: const EdgeInsets.all(8.0),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('Temperature next 3 days:'),
for (final t in temperatures)
Text(t.round().toString()),
],
),
),
),
);
}
}
class Config {
static String getAppName() { ... }
}
class WeatherService {
static List<double> getTemperatures() { ...}
}
Esse app certamente vai falhar se getAppName() retornar null; nesse caso, passaremos um null para o widget
Text usado no título de AppBar.
Mas há casos mais sutis a considerar: getTemperatures() também pode retornar null. Nesse caso, o laço for vai falhar. Ou getTemperatures() pode retornar uma lista, como esperado, mas essa lista pode conter valores null, caso em que chamaremos round() em null, e o app vai falhar.
O recurso de null safety faz esses problemas desaparecerem ao validar seu código enquanto você digita:
Com o null safety, você pode raciocinar sobre o seu código com mais confiança. Chega de erros incômodos de acesso a null em apps publicados. Em vez disso, você recebe erros estáticos enquanto programa.
Princípios do null safety
O suporte a null safety no Dart se baseia nos três princípios de design a seguir:
-
Não anulável por padrão. A menos que você diga explicitamente ao Dart que uma variável pode ser nula, ela será considerada não anulável. Escolhemos esse padrão porque descobrimos que não nulo era, de longe, a escolha mais comum em APIs.
-
Adoção incremental. Existe muito código Dart por aí. Será possível migrar para o null safety no momento que você escolher e, depois, de forma incremental, parte por parte. Será possível ter código com e sem null safety no mesmo projeto. Também forneceremos ferramentas para ajudar na migração.
-
Totalmente sound. O null safety do Dart é sound. Isso significa que podemos confiar no sistema de tipos: se ele determina que algo não é nulo, então isso nunca pode ser nulo. Isso habilita otimizações do compilador. Depois que você migrar todo o seu projeto e suas dependências para o null safety, você colhe os benefícios completos da solidez — não apenas menos bugs, mas também binários menores e execução mais rápida.
Vamos revisar esses princípios de design com mais detalhes.
1. Não anulável por padrão
A sintaxe básica é simples o bastante. Aqui estão algumas variáveis não anuláveis, declaradas de formas diferentes. Lembre-se: não anulável é o padrão, então essas declarações parecem as de hoje, mas o significado delas muda.
// In null-safe Dart, none of these can ever be null.
var widget = Text('Hello');
final status = GetStatus();
String m = '';
O Dart vai garantir que você nunca atribua null a nenhuma das variáveis acima. Se você tentar fazer widget = null
mil linhas depois, receberá um erro de análise estática e linhas vermelhas onduladas, e seu programa se recusará a compilar.
Variáveis anuláveis
Se você quiser que sua variável seja anulável, pode usar ?, assim:
// These are all nullable variables.
Text? t = Text('Hello'); // Can be null later.
final Status? s = getStatus(); // Maybe the function returns null.
String? n; // Is null at first. Can be null at any later time, too.
Você também pode usar a sintaxe ? em parâmetros e valores de retorno de funções:
// In function parameters.
void initialize(int? count) {
// It's possible that count is null.
}
// In function return values.
static List<double?>? getTemperatures() {
// Can return null instead of a List, and the list can contain nulls.
}
Mas, mais uma vez, o sonho é que você raramente precise usar ?. A maioria dos seus tipos será não anulável.
Sendo produtivo com o null safety
Null safety não é só sobre segurança. Também queremos que você seja produtivo ao usar o recurso, o que significa que ele precisa ser fácil de usar. Por exemplo, veja este código, que usa if para verificar um valor nulo:
void honk(int? loudness) {
if (loudness == null) {
// No loudness specified, notify the developer
// with maximum loudness.
_playSound('error.wav', volume: 11);
return;
}
// Loudness is non-null, let's just clamp it to acceptable levels.
_playSound('honk.wav', volume: loudness.clamp(0, 11));
}
Repare que as ferramentas do Dart conseguem detectar que, quando passamos daquele if, a
loudness
variável não pode ser nula. E então o Dart nos deixa chamar o método clamp() sem dar voltas. Essa conveniência é possibilitada por algo chamado análise de fluxo: o analisador do Dart percorre seu código como se o estivesse executando, descobrindo automaticamente informações adicionais sobre ele.
Aqui está outro exemplo, que mostra um caso em que o Dart consegue ter certeza de que uma variável não é nula, porque sempre atribuímos a ela um valor não nulo:
class StatusLine extends StatelessWidget {
final Status status;
StatusLine({this.status: Status.failed});
@override
Widget build(BuildContext context) {
// This local variable is non-nullable, but not initialized.
String statusText;
if (status == Status.ok) {
statusText = 'Update succeeded';
} else {
statusText = 'Update failed';
}
// By this point, Dart knows statusText isn't null, as we've
// assigned a value in both the if- and else-statements. Thus
// we can pass it to the Text widget -- which doesn't accept
// nullable Strings -- without getting an error.
return Text(statusText);
}
}
Se você remover qualquer uma das atribuições acima (por exemplo, apagando a linha statusText = 'Update failed';), o Dart não consegue garantir que
statusText será não nulo: você verá um erro estático e seu código não vai compilar. Você pode testar isso no DartPad.
2. Adoção incremental
Como o null safety é uma mudança tão fundamental no nosso sistema de tipos, seria extremamente disruptivo exigir uma adoção forçada. Queremos que você decida quando é o momento certo, por isso o null safety é um recurso opt-in: você poderá usar as versões mais recentes do Dart e do Flutter sem ser obrigado a ativar o null safety antes de estar pronto para isso. Você pode até depender de pacotes que já ativaram o null safety a partir de um app ou pacote que ainda não o fez.
Depois que você decidir adotar, recomendamos fortemente migrar o código na ordem, começando pelas folhas do grafo de dependências. Por exemplo, se C depende de B, que depende de A, migre primeiro A para null safety, depois B e então C. Essa ordem vale se A, B e C forem bibliotecas, pacotes ou apps.
Por que a ordem é importante? Embora você consiga avançar na migração do código antes que suas dependências migrem, corre o risco de precisar de uma segunda passagem de migração caso suas dependências mudem suas APIs durante a própria migração. Quando chegarmos à release beta, forneceremos ferramentas para ajudar você a descobrir quais dependências já migraram. Se você é autor de pacote, para evitar o risco de quebrar suas APIs, espere até que todas as suas dependências tenham migrado antes de publicar uma versão com null safety.
Quando suas dependências estiverem prontas, você pode usar nossa ferramenta de migração. Ela funciona analisando todo o seu código existente. A ferramenta é interativa, então você pode revisar as propriedades de nulabilidade que ela inferiu. Se você discordar de alguma conclusão da ferramenta, pode adicionar dicas de nulabilidade para mudar a inferência. Algumas dicas de migração podem fazer uma enorme diferença na qualidade da migração.
3. Totalmente sólido
Depois que você migrar totalmente, o null safety do Dart é sólido. Isso significa que o Dart tem 100% de certeza de que, nos exemplos acima, as variáveis de retorno, listas e elementos não podem ser nulos. Quando o Dart analisa seu código e determina que uma variável é não anulável, essa variável é sempre não anulável: se você inspecionar seu código em execução no debugger, verá que a não nulabilidade é mantida em tempo de execução. Por outro lado, algumas outras implementações não são sólidas e, em muitos casos, ainda precisam fazer verificações de nulo em tempo de execução. O Dart compartilha null safety sólido com o Swift, mas não com muitas outras linguagens de programação.
A solidez do null safety do Dart traz outra consequência bem-vinda: significa que seus programas podem ser menores e mais rápidos. Como o Dart tem certeza de que variáveis não anuláveis nunca são nulas, ele pode otimizar. Por exemplo, o compilador AOT (ahead-of-time) do Dart consegue gerar código nativo menor e mais rápido, porque não precisa adicionar verificações de nulo quando sabe que uma variável não é nula.
Observe que, para obter um null safety sólido, você precisará migrar todo o projeto e todas as dependências para null safety. Se parte do app ou das dependências não tiver sido migrada, você terá um null safety parcial, que mantém a maioria das verificações, mas não é totalmente otimizado e não garante que o app seja totalmente seguro.
O roadmap do null safety
Quando o null safety pode estar pronto para uso em produção? Este é o cronograma atual:
-
Experimentação do Flutter com a prévia técnica 2: é agora. Como migramos com sucesso o framework principal do Flutter para null safety, você pode testar o null safety para aprender o novo recurso da linguagem e experimentar com um pequeno exemplo de Flutter. Se você é autor de pacote, também pode fazer uma migração de teste, caso tenha um conjunto pequeno de dependências que já tenha sido migrado por nós. Você precisa passar uma flag de experimento, não deve usá-la em produção e não deve publicar pacotes migrados.
-
Migração antecipada de pacotes com beta: mais adiante este ano, concluiremos o ajuste de desempenho e teremos cobertura de testes suficiente para ter confiança de que o recurso funciona como esperado e que a compatibilidade com versões anteriores está sólida. Nesse momento, publicaremos uma versão beta do recurso, e você não precisará mais passar a flag de experimento. Esperamos ver os autores de pacotes começarem a migrar seus pacotes para null safety, o que nos dará mais uma rodada de validação antes do lançamento estável.
-
Uso em produção com estável: em seguida, trataremos o feedback do beta, corrigiremos os problemas restantes e então publicaremos a versão estável. É difícil definir um prazo concreto, mas estamos pensando no início do ano que vem. Quando o recurso estiver estável, esperamos ver muita adoção do null safety, com apps com null safety publicados nas lojas e muitos pacotes com null safety publicados no pub.dev em versões estáveis.
Experimente agora
Você já pode começar a experimentar o null safety hoje! Para começar rapidamente, confira esta versão especial do DartPad com null safety.
Se você quiser testar o null safety no VS Code, no Android Studio ou no terminal, confira o app de exemplo de null safety do Flutter. Esse app contém instruções de execução e duas versões de um pequeno app de clima: uma que não usa null safety e tem alguns erros de nulo esporádicos, e outra que usa null safety para garantir que esses problemas sejam tratados. Se você preferir experimentar com um app Flutter novo, pode executar
flutter create e depois seguir as instruções de experimento
para ativar o null safety. Observe que você precisará de um SDK do Flutter do canal dev (versão 1.24.0–3.0.pre
ou posterior), pois as versões stable e beta atuais do Flutter não oferecem suporte a null safety.
Para saber mais sobre o design do recurso, leia nossa nova documentação Entendendo o null safety. Se preferir um vídeo curto, confira o vídeo sobre null safety do evento Flutter Day, realizado há alguns meses.
Temos muito orgulho de trazer o null safety sólido para o Dart. O null safety sólido é um recurso distintivo do Dart que ajuda você a escrever código menos propenso a erros e a obter um desempenho melhor. Esperamos que você experimente o recurso na prévia técnica e nos dê feedback pelo nosso rastreador de issues. Feliz programação!
