Uma breve introdução a linguagem Dart.

IntroductionDart.md

Introdução ao Dart

Uma breve introdução a linguagem Dart.

Introdução

Todo aquivo deve ter uma função de nível superior main(), que servira como ponto de entrada para iniciar seu arquivo.

Exemplo de uma função main(), sem retorno (void) que imprimi na tela uma string (List<String>):

void main() {
  print('Hello, World!');
}

Variáveis

Com o Dart você pode declarar a maioria das variáveis sem especificar explicitamente seu tipo usando o var no inicio da declaração. Isso é determinado pela, inferência de tipos, que determinar o tipo pelos seus valores iniciais.

Aqui está um exemplo de criação de uma variável e inicialização:

var name = 'Bob'; //  A variável chamada "name" contém uma referência a um String objeto com valor “Bob”.

Outros exemplos:

var name = 'Gabriel Rocha';
var year = 2000;
var weight = 84.5;
var flybyObjects = ['Jupiter', 'Saturn', 'Uranus', 'Neptune'];
var image = {
  'tags': ['saturn'],
  'url': '//path/to/saturn.jpg'
};

O tipo da "name" variável é inferido como String, mas você pode alterar esse tipo especificando-o. Se um objeto não estiver restrito a um único tipo, especifique o Object tipo (ou dynamic se necessário).

Object name = 'Bob';

Ou declare explicitamente o tipo:

String name = 'Bob';

No Dart temos ainda os tipos final, const que ao contrário do var que é um tipo dinâmico, eles são do tipo estatico, ou seja, não poderá ter seu valor alterado após sua inicialização.

Final e Const

Uma variável final pode ser definida apenas uma vez; uma variável const é uma constante de tempo de compilação. (As variáveis ​​Const são implicitamente finais.)

Exemplo de final:

final name = 'Bob'; // Sem uma anotação de tipo
final String nickname = 'Bobby';

Exemplo de const:

const bar = 1000000;
const double atm = 1.01325 * bar;

// const não serve apenas para declarar variáveis ​​constantes. Você também pode usá-lo para criar valores constantes, bem como para declarar construtores que criam valores constantes.
var foo = const [];
final bar = const [];
const baz = []; // Equivalente a `const []`

Segurança nula

A segurança nula evita um erro que resulta do acesso não intencional de variáveis ​​definidas como null. O erro é chamado de erro de desreferência nula. Um erro de desreferência nula ocorre quando você acessa uma propriedade ou chama um método em uma expressão avaliada como null.

String? name // Tipo anulável. Pode ser `nulo` ou string.

String name // Tipo não anulável. Não pode ser `null`, mas pode ser string.

Variáveis dos Tipos Básicos

1. int representa números inteiros. Ele suporta valores positivos e negativos.

int lineCount = 0;

2. double é usado para números de ponto flutuante, ou seja, números que possuem parte decimal.

double atm = 1.01325

3. bool representa valores booleanos, ou seja, true (verdadeiro) ou false (falso).

bool istrue = true;    
bool isfalse = false;

4. String é usado para armazenar sequências de caracteres.

String name = 'Bob';

Variáveis dos Tipos Avançados

1. List representa uma coleção ordenada de elementos. Você pode armazenar elementos de diferentes tipos em uma lista.

final fixedLengthList = List<int>.filled(5, 0); // Cria uma lista de comprimento fixo do tipo "int".
print(fixedLengthList); // [0, 0, 0, 0, 0]

final growableList = <String>['A', 'B'];
// Para adicionar dados à lista
growableList[0] = 'G';
print(growableList); // [G, B]
growableList.add('X');
growableList.addAll({'C', 'B'});
print(growableList); // [G, B, X, C, B]
// Para remover um elemento da lista
growableList.remove('C');
growableList.removeLast();
print(growableList); // [G, B, X]

2. Map é usado para armazenar pares chave-valor, permitindo a associação entre valores e suas chaves correspondentes.

final planets = <num, String>{1: 'Mercury', 2: 'Venus', 3: 'Earth', 4: 'Mars'};
final mapFrom = Map<int, String>.from(planets);
print(mapFrom); // {1: Mercury, 2: Venus, 3: Earth, 4: Mars}

var gifts = Map<String, String>();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';

// Adicione um novo par de valores-chave a um mapa existente usando o operador de atribuição de subscrito ([]=):
var gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds'; 

// Remover um elemento:
final terrestrial = <int, String>{1: 'Mercury', 2: 'Venus', 3: 'Earth'};
final removedValue = terrestrial.remove(2); // Venus
print(terrestrial); // {1: Mercury, 3: Earth}

// Remove todas as entradas do mapa.
final planets = <int, String>{1: 'Mercury', 2: 'Venus', 3: 'Earth'};
planets.clear(); // {}

3. Sets é uma coleção não ordenada de itens exclusivos.

// Para criar um conjunto vazio
Set<String> names = {}
// ou
var elements = <String>{};
elements.add('fluorine');
elements.addAll(halogens);

// Criado usando um conjunto literal:
var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};

Fluxo de Controle

O Dart oferece suporte às instruções usuais de fluxo de controle:

if (year >= 2001) {
  print('21st century');
} else if (year >= 1901) {
  print('20th century');
}

for (final object in flybyObjects) {
  print(object);
}

for (int month = 1; month <= 12; month++) {
  print(month);
}

while (year < 2016) {
  year += 1;
} 

Condicionais

Pode controlar o fluxo do seu código Dart usando ramificações:

• if declarações e elementos; A condição entre parênteses depois if deve ser uma expressão avaliada como booleana:

if (isRaining()) {
  you.bringRainCoat();
} else if (isSnowing()) {
  you.wearJacket();
} else {
  car.putTopDown();
}

• if-case declarações e elementos; As instruções Dart ifsuportam casecláusulas seguidas por um padrão:

if (pair case [int x, int y]) return Point(x, y);

Se o padrão corresponder ao valor, a ramificação será executada com quaisquer variáveis ​​que o padrão definir no escopo.

Usando if e else:

if (pair case [int x, int y]) {
  print('Era a matriz de coordenadas $x,$y');
} else {
  throw FormatException('Coordenadas inválidas.');
}

• switch declarações e expressões; _Uma switch instrução avalia uma expressão de valor em relação a uma série de casos. Cada case cláusula é um padrão para o valor corresponder.

var command = 'OPEN';
switch (command) {
  case 'CLOSED':
    executeClosed();
  case 'PENDING':
    executePending();
  case 'APPROVED':
    executeApproved();
  case 'DENIED':
    executeDenied();
  case 'OPEN':
    executeOpen();
  default:
    executeUnknown();
}

Os casos vazios passam para o próximo caso, permitindo que os casos compartilhem um corpo. Para uma caixa vazia que não caia, use break para o seu corpo. Para falhas não sequenciais, você pode usar uma continue instrução e um rótulo:

switch (command) {
  case 'OPEN':
    executeOpen();
    continue newCase; // Continues executing at the newCase label.

  case 'DENIED': // Empty case falls through.
  case 'CLOSED':
    executeClosed(); // Runs for both DENIED and CLOSED,

  newCase:
  case 'PENDING':
    executeNowClosed(); // Runs for both OPEN and PENDING.
}

Expressões condicionais

O Dart tem dois operadores que permitem avaliar concisamente expressões que, de outra forma, poderiam exigir instruções if-else:

var visibility = isPublic ? 'public' : 'private';

Se a expressão booleana for nula, considere usar ??.

String playerName(String? name) => name ?? 'Guest'; 

Manipulação de erros

• throw (Lançar); lançamento ou aumento de uma exceção:

throw FormatException('Espera-se pelo menos 1 seção');

// Você também pode lançar objetos arbitrários:
throw 'Sem lhamas!';

• try (Pegar); Capturar ou capturar uma exceção interrompe a propagação da exceção (a menos que você repita a exceção). Capturar uma exceção lhe dá a chance de lidar com isso:

try {
  breedMoreLlamas();
} on OutOfLlamasException {
  buyMoreLlamas();
}

// Para lidar com código que pode gerar mais de um tipo de exceção, você pode especificar diversas cláusulas catch.
try {
  breedMoreLlamas();
} on OutOfLlamasException {
  // Uma exceção específica
  buyMoreLlamas();
} on Exception catch (e) {
  // Qualquer outra coisa que seja uma exceção
  print('Exceção desconhecida: $e');
} catch (e) {
  // Nenhum tipo especificado, lida com todos
  print('Algo realmente desconhecido: $e');
}

// Você pode especificar um ou dois parâmetros para catch(). A primeira é a exceção lançada e a segunda é o rastreamento de pilha (um StackTraceobjeto).
try {
  // ···
} on Exception catch (e) {
  print('Detalhes da exceção:\n $e');
} catch (e, s) {
  print('Detalhes da exceção:\n $e');
  print('Rastreamento de pilha:\n $s');
}

• finally (Finalmente); Para garantir que algum código seja executado independentemente de uma exceção ser lançada ou não, use uma cláusula finally. Se nenhuma cláusula catch corresponder à exceção, a exceção será propagada após a execução da cláusula finally:

try {
  breedMoreLlamas();
} finally {
  // Sempre limpe, mesmo se uma exceção for lançada.
  cleanLlamaStalls();
}

// A cláusula `finally` é executada após qualquer cláusula `catch` correspondente:
try {
  breedMoreLlamas();
} catch (e) {
  print('Error: $e'); // Trate a exceção primeiro.
} finally {
  cleanLlamaStalls(); // Então limpe.
}

• assert (Afirmar); Durante o desenvolvimento, use uma instrução assert — assert(<condition>, <optionalMessage>); — para interromper a execução normal se uma condição booleana for falsa.

// Certifique-se de que a variável tenha um valor não nulo.
assert(text != null);

// Certifique-se de que o valor seja menor que 100.
assert(number < 100);

// Certifique-se de que este seja um URL https.
assert(urlString.startsWith('https'));

Loops

• for:

var message = StringBuffer('Dart é divertido');
for (var i = 0; i < 5; i++) {
  message.write('!');
}

var callbacks = [];
for (var i = 0; i < 2; i++) {
  callbacks.add(() => print(i));
}

for (final c in callbacks) {
  c();
}

• while:

while (true) {
  doSomething();
}

while (true) {
  if (shutDownRequested()) break;
  processIncomingRequests();
}

for (int i = 0; i < candidates.length; i++) {
  var candidate = candidates[i];
  if (candidate.yearsExperience < 5) {
    continue;
  }
  candidate.interview();
}

• do-while:

do {
  printLine();
} while (!atEndOfPage());