03 Conteúdo - Dart

Prévia do material em texto

Introdução ao Dart
Dart é uma linguagem de programação de uso geral criada pelo Google e lançada em 2011.. O Dart é otimizado para o desenvolvimento do cliente, priorizando o desenvolvimento (hot reload com estado em menos de um segundo) e experiências de produção de alta qualidade em uma ampla variedade de destinos de compilação (web, dispositivos móveis e desktop). Dart é uma linguagem de programação de uso geral de código aberto com uma sintaxe comparável à de C.
É uma linguagem orientada a objetos no estilo C que suporta conceitos de programação como interfaces e classes. Seu objetivo é fornecer a linguagem de programação mais produtiva para desenvolvimento multiplataforma, bem como uma plataforma de tempo de execução versátil para estruturas de aplicativos.
Dart também é a espinha dorsal do Flutter. O Dart não apenas potencializa os aplicativos Flutter com sua linguagem e tempos de execução, mas também ajuda os desenvolvedores na formatação, análise e teste de código. Estruturas de dados como arrays, genéricos e tipagem opcional podem ser replicadas com coleções Dart.
Os tipos de dados a seguir são compatíveis com a linguagem Dart:
· Numbers: Usado para representar literais numéricos inteiros e duplos.
· Strings: Uma string é uma coleção de caracteres. Aspas simples ou duplas são usadas para especificar valores de string.
· Booleans: A palavra-chave bool no Dart é usada para representar valores booleanos, como true e false. Também é usado para representar uma coleção de objetos em listas e mapas.
· Tomada de Decisão e Loops: Antes que as instruções sejam executadas, um bloco de tomada de decisão examina uma condição. As instruções If , If..else e switch são todas suportadas no Dart. Os loops são usados ​​para executar repetidamente uma seção de código até que uma determinada condição seja atendida. Dart suporta loops como for , for..in , while e do..while . Eles podem ser definidos como um método, semelhante à nossa função void, e operam como objetos de primeira classe, o que significa que podem ser salvos em variáveis, fornecidos como argumentos e retornados como um valor de retorno de função normal.
Dart: a linguagem
A linguagem de programação Dart é de tipo seguro: ela emprega verificação de tipo estático para garantir que o valor de uma variável sempre corresponda ao tipo estático da variável. Isso é conhecido como “digitação de som”. O sistema de tipagem do Dart também é versátil, permitindo o uso de um tipo dinâmico misturado com verificações de tempo de execução, o que pode ser benéfico para experimentação ou para código que requer muito comportamento dinâmico.
Se você executar um programa Dart sem segurança nula, a chamada to.length gerará um erro NoSuchMethodError. A classe Null não tem um getter de “comprimento”, e o valor nulo é uma instância dela. Falhas no tempo de execução são uma dor. Isso é particularmente verdadeiro em uma linguagem como o Dart, que deve ser executado no dispositivo do usuário. Normalmente, você pode reiniciar um aplicativo de servidor antes que alguém veja que ele falhou. Os usuários, por outro lado, não ficam satisfeitos quando um aplicativo Flutter trava em seu telefone. 
O Dart tem uma boa segurança nula, o que significa que os valores não podem ser nulos, a menos que você diga. Com isso, o Dart protege os usuários de exceções nulas na execução. A não nulidade é preservada em tempo de execução se você visualizar seu código em execução no depurador.
SDK do Dart
O SDK do Dart inclui todas as bibliotecas e ferramentas de linha de comando necessárias para criar projetos Web de linha de comando, servidor e não Flutter do Dart. O SDK do Dart está localizado no subdiretório bin/cache/dart-sdk do SDK do Flutter. Ele será baixado na primeira vez que você executar o comando flutter - portanto, se você já tiver o Flutter instalado, talvez não seja necessário baixar o SDK do Dart separadamente. Se qualquer uma das seguintes afirmações for verdadeira, considere baixar o SDK do Dart:
· Flutter não é algo que você utiliza.
· Você está usando uma versão do Flutter anterior à 1.21.
· Você deseja economizar espaço em disco ou tempo de download, mas não precisa do Flutter para seu aplicativo.
Ferramentas de linha de comando, compiladores de linha de comando e bibliotecas são seus três componentes básicos.
Ferramentas de linha de comando A interface de linha de comando do Dart permite escrever, formatar, analisar, testar, compilar e executar programas Dart. Isso inclui o seguinte:
· dart: Este comando permite que você execute um arquivo Dart na Máquina Virtual Dart.
· dart2js: Este é um programa que converte o código-fonte do Dart em JavaScript.
· dartanalyser: Este é um programa que analisa o código-fonte do Dart. Muitos editores de código empregam essa técnica para destacar erros e avisos.
· dartdevc: Este é um programa que converte o código-fonte do Dart em JavaScript. É semelhante ao dart2js, exceto que permite compilação incremental, o que é útil para desenvolvedores.
· dartdoc: Esta é uma ferramenta que gera documentação para Dart a partir do código fonte.
· dartfmt: Este é um programa muito útil porque fornece formatação de dart ao código-fonte Dart.
Desenvolvimento Flutter
Como você aprendeu no capítulo anterior, a estrutura Flutter é um kit de ferramentas de interface do usuário impressionante que é executado em iOS, Android, macOS, Windows, Linux e na Web e é conduzido pela plataforma Dart. Inclui ferramentas e bibliotecas de interface do usuário para criar experiências de interface do usuário que operam em iOS, Android, macOS, Windows, Linux e na Web.
O Flutter foi construído principalmente no Dart e opera em plataformas nativas. Como resultado, o Flutter é rápido e adaptável, pois os widgets do Flutter foram escritos no Dart. Na maioria das vezes, ao desenvolver um aplicativo Flutter, você o executa no modo de depuração e seu código é compilado e interpretado por JIT. O modo 'check' ou 'slow' é o nome deste modo. As funções de asserção, incluindo todas as informações de depuração, extensões de serviço e auxílios de depuração como “observatório”, estão disponíveis neste modo.
Este modo foi projetado para desenvolvimento e operação rápidos, mas não para velocidade de execução, tamanho do pacote ou implantação. Depois que seu aplicativo estiver concluído, você poderá compilá-lo para ser executado no modo de lançamento como um aplicativo nativo, o que melhorará significativamente seu desempenho. Discutiremos isso com mais detalhes mais adiante no livro.
Dart avançado com exemplos
DartPad
Como você já sabe, o Flutter — o kit de ferramentas de interface do usuário do Google para criar aplicativos móveis, web e desktop atraentes e construídos nativamente a partir de uma única base de códigom— usa o Dart como sua linguagem de programação. Você pode facilmente construir e executar seus exemplos no DartPad desde que tenha um navegador estável.
O DartPad é uma ferramenta gratuita e de código aberto que permite que você experimente os recursos e as bibliotecas principais do Dart em qualquer navegador moderno. É preciso uma nova abordagem para recursos com os quais os desenvolvedores Java podem não estar familiarizados.
O DartPad também suporta as bibliotecas package:flutter e dart:ui ao criar aplicativos Flutter. O DartPad não oferece suporte a nenhuma biblioteca ou carregamento adiado e não permite que você use pacotes do repositório de pacotes pub. Você pode, no entanto, usar um IDE como WebStorm ou IntelliJ com o plug-in Dart - ou Visual Studio Code com a extensão Dart Code - se desejar.
		
A imagem acima é a aparência do DartPad quando configurado para executar o Dart.
Acesse dartPad.dev para começar. À esquerda, você verá o código Dart e, à direita, verá um local para a saída. Usando a lista Samples no canto superior direito, selecione uma amostra Flutter como Sunflower. À direita está a saída renderizada. Você pode usar o New Pad para escrever um aplicativo de linha de comando simples nestas etapas:
1. Confirme que deseja descartar as alterações nopad existente clicando no botão New Pad.
2. Depois de clicar no logotipo do Dart , verifique se o suporte a HTML está desativado e clique em Criar .
3. Faça uma alteração de código. Altere a função main() para incluir o seguinte código:
	for (var char in 'hello'.split(' )) {
print(char);
}
4. O DartPad exibe dicas, documentação e sugestões de preenchimento automático conforme você digita.
5. Selecione Formatar no menu suspenso. O DartPad emprega o formatador Dart para garantir recuo apropriado, espaço em branco e quebra de linha em seu código.
6. Inicie seu aplicativo.
7. Tente adicionar um bug se você não tiver nenhum ao digitar o código. Se você alterar “split” para “spit”, por exemplo, você receberá avisos no canto inferior direito da janela. Ao iniciar o aplicativo, o terminal exibe um erro de compilação.
Os recursos de linguagem e APIs do DartPad dependem da versão do SDK do Dart que ele está usando no momento. Esta versão do SDK pode ser vista no canto inferior direito do DartPad. O DartPad também pode ser incorporado em páginas da Web e personalizado para atender às suas necessidades.
Exemplos
Hello World
A função main() está presente em todos os programas. Você pode usar o método print() de nível superior para exibir texto no console:
	void main() {
print('Hello, World!');
}
Variáveis
​​Aqui está um exemplo de como gerar e inicializar uma variável:
	var name = 'Bob';
Variáveis ​​são usadas para manter o controle de referências. A variável name contém uma referência a um objeto String com o valor “Bob”. O tipo da variável name é assumido como String, mas você pode alterá-lo especificando-o. Especifique o tipo de objeto se um objeto não estiver vinculado a um único tipo.
	Object name = 'Bob';
Valores default
variáveis ​​não inicializadas que têm um tipo anulável têm um valor inicial nulo. (Cada variável tem um tipo anulável se você não ativou a segurança nula.) Como os números, como tudo no Dart, são objetos, até mesmo as variáveis ​​numéricas começam nulas.
	int? lineCount;
assert(lineCount == null );
A chamada assert() é ignorada pelo código de produção. Se a condição for falsa durante o desenvolvimento, no entanto, assert(condition) produzirá uma exceção. Se a segurança nula estiver habilitada, você deve definir os valores das variáveis ​​não anuláveis ​​antes de usá-las:
	int lineCount = 0;
Uma variável local não precisa ser inicializada onde é declarada, mas deve receber um valor antes de poder ser usada. Como o Dart pode detectar que lineCount não é nulo no momento em que é fornecido para print() , o código a seguir é válido:
	int lineCount;
if (weLikeToCount) {
lineCount = countLines();
} else {
lineCount = 0;
}
print(lineCount);
Variáveis late
O modificador late foi criado no Dart 2.12 e tem dois usos principais: declarar uma variável não anulável que será inicializada posteriormente e inicializar uma variável tardiamente.
Declarando uma variável não anulável que será inicializada posteriormente A análise de fluxo de controle do Dart geralmente pode detectar se uma variável não anulável é definida como um valor não nulo antes de ser usada, mas essa detecção nem sempre é feita. Variáveis ​​de nível superior e variáveis ​​de instância são dois exemplos frequentes: o Dart nem sempre pode dizer se elas estão definidas, então em alguns casos ele não tenta. Se você tem certeza de que uma variável é definida antes de ser usada, mas o Dart contesta, você pode resolver o problema declarando a variável como late:
	late String description;
void main() {
descrição = 'Feijoada!';
print(descrição);
}
Lazy inicialização
Quando uma variável late é utilizada sem ser inicializada corretamente, ocorre um erro de tempo de execução. Se você declarar uma variável com late, mas inicializá-la em sua declaração, o inicializador será executado na primeira vez que a variável for usada. Essa inicialização laze é útil em algumas situações:
· Onde a variável pode não ser necessária e inicializá-la é caro(em relação a uso de memoria)
· Se você estiver configurando uma variável de instância e oinicializador da variável exigir acesso a ela.
Tipos de variaveis
integrados A linguagem de programação Dart oferece funcionalidade adicional para cada um dos seguintes:
· Numbers (int , double )
· Strings (string )
· Booleans (bool )
· Lists (list ; também conhecido como arrays)
· Sets (set )
· Maps (map )
· Runes ( runes ; frequentemente substituído pelos caracteres API)
· Symbols (símbolo )
· O valor null (null )
A capacidade de criar objetos usando literais faz parte dessa capacidade específica. Um bom exemplo de um literal de string é “isto é uma string”, enquanto um literal booleano é “true”. Normalmente, você pode usar construtores para inicializar variáveis ​​no Dart, pois cada variável está relacionada a um objeto como uma instância de classe. Existem construtores para vários tipos internos. Para fazer um mapa, por exemplo, você pode usar o construtor Map(). Outros tipos também desempenham papéis importantes na linguagem Dart.
· Object: Exceto Null, Object é a superclasse de todas as classes Dart.
· Future e Stream: Usado para suportar assincronia.
· Iterable: Este tipo de variável é usado em loops for-in e funções de gerador síncrono.
· Never: Indica que uma expressão nunca poderá concluir sua avaliação.
· Dynamic: indica que a verificação estática deve ser desabilitada. Na maioria dos casos, Objeto ou Objeto? deve ser usado em seu lugar.
· Void: Um valor nulo é usado quando está definido como nulo. Isso é frequentemente usado como um tipo de retorno.
· Números (Num): Os números de dardos são divididos em dois tipos: inteiros e ponto flutuantes.
Inteiros (int): Números sem ponto decimal são conhecidos como inteiros. Dependendo da plataforma, são permitidos valores inteiros de no máximo 64 bits.
Os valores para sistemas nativos variam de -263 a 263 -1. Os valores inteiros variam de -253 a 253 -1 sendo representados na Web como números JavaScript (valores de ponto flutuante de 64 bits sem parte fracionária).
Doubles: Um número é um double se contiver um decimal. O padrão IEEE 754 especifica números de ponto flutuante de 64 bits (precisão dupla).
Operadores básicos como + , - , / e * são incluídos no tipo num, assim como abs() , ceil() e floor() , entre outras formas. (A classe int define operadores bit a bit como >> .) A biblioteca dart:math pode ter o que você está procurando se num e seus subtipos não tiverem. Aqui estão alguns exemplos de definições de literais inteiros:
	var x = 1;
var hex = 0xDEADBEEF;
var expoente = 8e5;
Aqui estão alguns exemplos de definições de literais duplos:
	var y = 1.1;
var expoentes = 1,42e5;
Uma variável também pode ser declarada como um número. Quando isso acontece, a variável pode ter valores inteiros e duplos, conforme mostrado abaixo:
	num x = 1; // x pode ter valores int e double
x += 2.5;
Literais inteiros podem ser convertidos em doubles quando necessário:
	 double z = 1; // Equivalente a double z = 1.0.
Uma string também pode ser convertida em um número e vice-versa:
	// String -> int
var one = int.parse('1');
assert(um == 1);
// String -> double
var onePointOne = double.parse('1.1');
assert(umPontoUm == 1.1);
// int -> String
String oneAsString = 1.toString();
assert(oneAsString == '1');
// double -> String
String piAsString = 3.14159.toStringAsFixed(2);
assert(piAsString == '3.14');
Booleans: Dart contém um tipo chamado bool que representa valores booleanos. Os literais booleanos true e false , que são constantes de tempo de compilação, são os únicos objetos do tipo bool. Como resultado da segurança de tipo do Dart, você não pode usar if (nonbooleanValue) ou assert (nonbooleanValue) . Em vez disso, verifique os valores explicitamente, como em:
	// Verifique se há uma string vazia.
var ful Nome = '';
assert(ful Name.isEmpty);
// Verifica se há zero.
var pontos de acerto = 0;
assert(hitPoints <= 0);
// Verifica se há null .
var unicorn;
assert(unicorn == null );
// Verifica sehá NaN.
var iMeantToDoThis = 0 / 0;
assert(iMeantToDoThis.isNaN);
List: O array, ou grupo ordenado de coisas, talvez seja a coleção mais comum em praticamente todas as linguagens de programação. Arrays são objetos de lista no Dart, então a maioria das pessoas apenas se refere a eles como listas. Os literais de lista de dardos se assemelham a literais de matriz JavaScript na aparência. Aqui está uma lista rápida no Dart:
	var list = [1, 2, 3];
Dart deduz que a lista é do tipo List<int> . O analisador ou o tempo de execução gera um erro se você tentar adicionar objetos não inteiros a essa lista. O operador spread (...) e o operador spread com reconhecimento de nulo (...?) foram adicionados no Dart 2.3 e fornecem uma maneira simples de inserir vários valores em uma coleção. Para inserir todos os valores de uma lista em outra lista, por exemplo, você pode usar o operador spread (...) : 
	var list = [1, 2, 3];
var list2 = [0, ...list];
assert(list2.length == 4);
Se você supõe que a expressão à direita do operador spread pode ser nula, use um operador spread com reconhecimento de nulo (...?) para evitar exceções:
	var list;
var list2 = [0, ...?list];
assert(list2.length == 1);
O Dart também possui a coleção if e a coleção para funções, que você pode usar para criar coleções com condicionais (if) e repetição (for) . Aqui está um exemplo de como usar a coleção para fazer uma lista de três ou quatro itens:
	var nav = [
'Casa',
'Móveis',
'Plantas',
if (promoActive) 'Saída'
];
Sets: No Dart, um Set é uma coleção não ordenada de itens exclusivos. Os literais de Set e o tipo de conjunto fornecem suporte para conjuntos. Abaixo está um conjunto básico de Dart feito com um conjunto literal:
	var halogênios = {'fluorine', 'chlorine', 'bromo', 'iodine', 'astatine'};
 Dart deduz que os halogênios são do tipo Set<>. O analisador ou o tempo de execução gerará um erro se você tentar adicionar o tipo de valor impróprio ao conjunto. Você pode usar {} seguido por um argumento de tipo para gerar um conjunto vazio ou atribuir {} a uma variável do tipo Set conforme mostrado abaixo:
	var names = <String>{};
// Set<String> nomes = {}; // Isso também funciona.
// nomes de var = {}; // Cria um mapa
Observe que os literais de mapa têm uma sintaxe semelhante à dos literais de conjunto. Os literais de mapa vieram primeiro e, portanto, {} assume como padrão o tipo de mapa. O Dart produz um objeto do tipo Map<dynamic, dynamic> para casos em que se esquece a anotação de tipo em {} ou a variável à qual está atribuída.
Maps: Um map é um objeto que associa chaves e valores em geral. Qualquer tipo de objeto pode ser usado como chave e valor. Cada chave aparece apenas uma vez—no entanto, o mesmo valor pode ser usado várias vezes. Literais de mapa e o tipo de mapa no Dart habilitam o suporte para mapas. Aqui estão alguns exemplos de mapas Dart simples feitos com literais de mapa:
	var gifts = {
// Chave: Valor
'first': 'perdiz',
'second': 'turtledoves',
'fifth': 'golden rings'
};
var nobreGases = {
2: 'hélio',
10: 'neon',
18: 'argônio',
};
No Dart, presentes tem o tipo Map<String, String> , enquanto nobleGases tem o tipo Map<int, String> . O analisador ou o tempo de execução gerará um erro se você tentar adicionar o tipo impróprio de valor a qualquer mapa.
Functions
Dart é uma linguagem de programação orientada a objetos. Isso significa que as funções podem ser fornecidas como argumentos para outras funções ou alocadas para variáveis. Aqui está um exemplo de como executar uma função:
	bool isNoble(int atomicNumber) {
return _nobleGases[atomicNumber] != nul ;
}
Você pode usar uma sintaxe abreviada para funções que têm apenas uma expressão:
	bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] !=
nul ;
A sintaxe => expr (também conhecida como sintaxe de seta) é um atalho para { return expr; } . Apenas uma expressão pode existir entre a seta (=>) e o ponto e vírgula (;) . Você não pode usar uma instrução if, por exemplo, mas pode usar uma expressão condicional.
Parâmetros: Uma função pode ter quantos parâmetros posicionais forem necessários.
Parâmetros nomeados ou parâmetros posicionais opcionais podem ser adicionados depois deles, mas não ambos. Mesmo com os parâmetros necessários, algumas APIs, como construtores de widgets Flutter, empregam apenas parâmetros nomeados. Ao passar argumentos para uma função ou definir parâmetros de função, você pode usar vírgulas à direita.
Parâmetros nomeados: A menos que sejam declarados explicitamente como obrigatórios, os parâmetros nomeados são opcionais. Você pode usar paramName: value para especificar parâmetros nomeados ao chamar uma função. Considere o seguinte cenário:
	 enableFlags(bold: true, hidden: false);
Ao definir uma função, você normalmente também usa {param1, param2,…} para especificar os parâmetros nomeados, se houver:
	/// Define os sinalizadores [bold] e [hidden] ...
void enableFlags({bool? bold, boolocultos
Valores de parâmetro padrão
Sua função pode usar = para definir valores padrão para parâmetros nomeados ou posicionais. Constantes de tempo de compilação devem ser usadas como valores padrão. O valor padrão é nulo se nenhum valor padrão for especificado. Definindo valores padrão para parâmetros nomeados pode ser feito da seguinte maneira:
	/// Define os sinalizadores [bold] e [hidden] ...
void enableFlags({bool bold = false, bool hidden = false}) {...}
// bold wil be true ; oculto será falso.
enableFlags(bold: true);
Todo programa deve ter uma função main() de nível superior que atue como o ponto de entrada do aplicativo. A função main() retorna void e tem um parâmetro opcional List<String> para argumentos. Aqui está uma função main() simples:
	void main() {
print('Hello, World!');
}
Para aplicativos de linha de comando que aceitam argumentos, aqui está uma ilustração o f uma função main():
	// Execute o aplicativo assim: dart args.dart 1 test
void main(List<String> arguments) {
print(arguments);
assert(argumentos.comprimento == 2);
assert(int.parse(argumentos[0]) == 1);
assert(argumentos[1] == 'teste');
}
Classes
Uma classe de três atributos, dois construtores e uma função é mostrada abaixo. Como um dos atributos não pode ser definido diretamente, um método getter é usado para especificá-lo (em vez de uma variável).
	class Spacecraft{
String name;
DataTime? launchDate;
int? get launchYear => launchDate?.year; // propriedade não final somente leitura
// Construtor, com açúcar sintático para atribuição aos membros.
Spacecraft(this.name, this.launchDate) {
// O código de inicialização vai aqui.
}
// Construtor nomeado que encaminha para o padrão.
Spacecraft.unlaunched(String name) : this(name, null );
// Método.
void describe() {
print('Nave espacial: $nome');
var launchDate = this.launchDate; // A promoção de tipo não funciona em getters.
if (launchDate != nul ) {
int years = DateTime.now().difference(launchDate).inDays ~/ 365;
print('Lançado: $launchYear ($anos anos atrás)');
} else {
print('Não lançado');
}
}
}
Interfaces e classes abstratas
Não há palavra-chave de interface na linguagem de programação Dart. Todas as classes, por outro lado, especificam uma interface automaticamente. Como resultado, qualquer classe pode ser implementada:
	class MockSpaceship implements Spacecraft {
// ···
}
Você pode projetar uma classe abstrata que uma classe concreta pode estender (ou implementar), e métodos abstratos podem ser encontrados em classes abstratas (com corpos). A função describeWithEmphasis() está disponível em qualquer classe que estenda Describable e invoque a versão do extensor de describe() :
	abstract class Describable {
void describe();
void describeWithEmphasis() {
print('=========');
describe();
print('=========');
}
}
Async
Ao trabalhar com o Dart, você pode usar async e await para tornar seu código mais legível:
	const oneSecond = Duration(seconds: 1);
// ···
Future<void> printWithDelay(String message) async {
await Future.delayed(oneSecond);
print(message);}
O acima é idêntico a:
	Future<void> printWithDelay(String message) {
return Future.delayed(oneSecond).then((_) {
print(message);
});
}
Conforme mostrado no exemplo, async e await facilitam a leitura da programação assíncrona.
	Future<void> createDescriptions(Iterable<String> objects) async {
for (var object in objects) {
try {
var file = File('$object.txt');
if (await file.exists()) {
var modified = await file.lastModified();
print('Arquivo $object jé existe. Modificado em: $modified.');
continue;
}
await file.create();
await file.writeAsString('Começando escrever $object neste arquivo.');
} on IOException catch (e) {
print('Não foi possivel@ $object: $e');
}
}
}