1. Home
  2. Dart
  3. Referência rápida de Dart

Referência rápida de Dart

Índice

1- Sobre o Dart

//TODO: Complementar

2- Referências sobre a linguagem

Documentação oficial:

3- Instalação

//TODO: Complementar

4- IDEs

Uma ótima IDE para escrever código Dart é o VSCode.

O VSCode é um editor FREE, rápido, leve e com uma infinidade de extensões para diferentes linguagens de programação, o que faz com que ele seja uma ótima opção para diferentes usos, vale destacar também que ele ganhou com folga a primeira posição da pesquisa anual do Stack Overflow de 2021 (link) como a IDE mais utilizada por programadores.

DartPad

É possível também treinar a sintaxe do Dart utilizando o DartPad, que é uma ferramenta on-line. Basta acessar o link abaixo, escrever o código e rodar:

https://dartpad.dev

5- Hello World

//TODO: Complementar

6- Básico

Comentários de código

Interação com o usuário

print('Hello World');

Variáveis

var name = "Eduardo";
String fullName = "Eduardo Coutinho";
String? phone;

Tipos

//TODO: Complementar

// Números
int meaningOfLife = 42;
double valueOfPi  = 3.141592;

//Boleanos
bool visible      = true;

// Texto
String shakespeareQuote = "All the world's a stage, ...";

// Data e Tempo
var now = DateTime.now();
var berlinWallFell = DateTime(1989, 11, 9);
var timeRemaining = const Duration(hours: 56, minutes: 14);

// Url
var dartlang = Uri.parse('http://dartlang.org/');

//Erros
Error();

Coleções

List / Array

var superheroes = ['Batman', 'Superman', 'Harry Potter'];

var numbers = <int>[];

List<int> numbers = <int>[];

Ordenando listas:

//ordenação de uma lista de strings
var superheroes = ['Batman', 'Superman', 'Harry Potter'];
superheroes.sort();

//para obter uma nova lista ordenada ao invés de ordenar a própria lista, use: ".."
var newList = superheroes..sort();

//ordem reversa:
var reverseList = superheroes..reverse();

//ordenando uma lista de objetos:
var users = [
  User(name: 'Eduardo', type: 'admin'),
  User(name: 'Coutinho', type: 'admin'),
  User(name: 'Pedro', type: 'user'),
  User(name: 'Paulo', type: 'user'),
  User(name: 'Pietro', type: 'user'),
];

var usersSortedByName = users..sort((a, b) {
  return a.name.compareTo(b.name);
});

//Ordenando por múltiplos atributos (subsorting)
var usersSortedByTypeAndName = users..sort((a, b) {
  var comparisonResult = a.type.compareTo(b.type);
  if (comparisonResult != 0) return comparisonResult;
  return a.name.compareTo(b.name);
});

Set

Lista não ordenada, de objetos únicos

var villains = {'Joker'};     // -> {'Joker'}
villains.addAll(['Joker', 'Lex Luthor', 'Voldemort']);  //{'Joker', 'Lex Luthor', 'Voldemort'}

Map

Lista chave/valor com valores únicos para as chaves

var sidekicks = {'Batman': 'Robin',
                'Superman': 'Lois Lane'};
print(sidekicks); //{'Batman': 'Robin', 'Superman': 'Lois Lane'}

sidekicks.addAll('Harry Potter': 'Ron and Hermione');
print(sidekicks); //{'Batman': 'Robin', 'Superman': 'Lois Lane', 'Harry Potter': 'Ron and Hermione'}

var headers = <String, String>{'User-Agent': 'Chrome'};

var headers = <String, String>{
	'User-Agent': 'Chrome',
	'Content-Type': 'application/json'
};

var items = <String, String>{};

Classes

//TODO: Complementar

class Person {
    String? name;
    int? age;
}

Construtores

Declarando formalment as variáveis do construtor:

class Car {
  String make;
  String model;
  String yearMade;
  bool hasABS;

  Car(String make, String model, int year, bool hasABS) {
    this.make = make;
    this.model = model;
    this.yearMade = year;
    this.hasABS = hasABS;
  }
}

É possível simplificar esse código, assim:

class Car {
  String make;
  String model;
  String yearMade;
  bool hasABS;

  Car(this.make, this.model, this.yearMade, this.hasABS);
}

Utilizando parâmetros com nome na chamada do construtor:

class Person {
    String name;
    int age;

    Person({this.name, this.age});
}

var p1 = Person(name: "Eduardo", age: 31)

Construtor com valor opcional:

class Person {
    String name;
    int age;

    Person({this.name, this.age = 30});
}

var p2 = Person(name: "Eduardo")

Iniciando variáveis “final” no constutor:

class Person {
    late final String name;

    Person() {
      name = "Eduardo";
    }
}

Factories, podem ser utilizadas quando não necessariamente você precisa de um construtor para a classe.

class Car {
	String make;
 	String model;
 	String yearMade;
 	bool hasABS;

 	factory Car.ford(String model, String yearMade, bool hasABS) {
  	return FordCar(model, yearMade, hasABS);
  }
}

class FordCar extends Car {
	FordCar(String model, String yearMade, bool hasABS): super("Ford", model, yearMade, hasABS);
}

Construtores com constante podem ser utilizados quando o seu objeto nunca vai mudar de valor

class FordFocus {
   static const FordFocus fordFocus = FordFocus("Ford", "Focus", "2013", true);

   final String make;
   final String model;
   final String yearMade;
   final bool hasABS;

   const FordFocus(this.make, this.model, this.yearMade, this.hasABS);
}

É possível um construtor chamar outro construtor, da seguinte forma:

class Car {
	String make;
 	String model;
 	String yearMade;
 	bool hasABS;

 	Car(this.make, this.model, this.yearMade, this.hasABS);

 	Car.withoutABS(this.make, this.model, this.yearMade): this(make, model, yearMade, false);
}

Funções

//TODO: Complementar

int sum(int x, int y) {
  return x + y;
}

int result = sum(2, 3);

Built-in Functions

//TODO: Complementar

Strings

StringBuffers (para construir Strings de forma mais eficiente):

var moreShakespeare = StringBuffer();
moreShakespeare.write('And all the men and women ');
moreShakespeare.write('merely players; ...');

Operadores

//TODO: Complementar

Operadores aritméticos

//TODO: Complementar

Operadores de atribuição

//TODO: Complementar

Operadores de comparação

//TODO: Complementar

Operadores lógicos

//TODO: Complementar

Comparação de objetos

//TODO: Complementar

Operadores de Bitwise

//TODO: Complementar

Estruturas condicionais

//TODO: Complementar

Laços e iterações

//TODO: Complementar

Tratamento de exceções

try {
   // Lógia da aplicação
}  
on Exception1 {
   // tratamento para a exceção 1
}  
catch Exception2 {
   // tratamento para a exceção 2
}
finally {
  // código sempre executado
}

var input = 'abc';
try {
  var value = int.parse(input);
} on FormatException {
  print('Valor é inválido');
} on Exception catch (ex) {
  print('Exception error: $ex');
}

IMPORTANTE: Nem todo erro é uma exception, então, nem sempre vai cair no bloco “Exception”.

try {
	throw Exception('Cai no catch Exception');
} on Exception catch (ex) {
	print('Exception error: $ex');
}

try {
	throw 'Não cai no catch Exception';
} on Exception catch (ex) {
	print('Exception error: $ex');
}

Para capturar todos os tipos de erros, utilize:

try {
	throw 'Erro';
} catch (error) {
	print('Error: $error');
}

–

Mais

Medir o tempo de execução de um código (Stopwatch)

Para medir o tempo de execução de um código é possível utilizar o Stopwatch

Referência: https://api.dart.dev/stable/2.14.0/dart-core/Stopwatch-class.html

Métodos:

Exemplo:

var stopwatch = Stopwatch();
sleep(new Duration(seconds: 1));
print(stopwatch.elapsedMilliseconds); // 0

s.start();
sleep(new Duration(seconds: 2));
print(s.isRunning); // true
print(stopwatch.elapsedMilliseconds); // around 2000ms

sleep(new Duration(seconds: 1));
s.stop();
print(s.elapsedMilliseconds); // around 3000ms
print(stopwatch.isRunning); // false

sleep(new Duration(seconds: 1));
print(stopwatch.elapsedMilliseconds); // around 3000ms

s.reset();
print(stopwatch.elapsedMilliseconds); // 0

Dica: Para criar e já iniciar o Stopwatch é possível utilizar:

var stopwatch = Stopwatch()..start();

Comentários