Tratamento de erros

Seu código Dart pode lançar e capturar exceções. Exceções são erros indicando que algo inesperado aconteceu. Se a exceção não for capturada, o isolate que lançou a exceção é suspenso, e tipicamente o isolate e seu programa são terminados.

Em contraste com Java, todas as exceções do Dart são exceções não verificadas. Métodos não declaram quais exceções eles podem lançar, e você não é obrigado a capturar nenhuma exceção.

Dart fornece os tipos Exception e Error, assim como vários subtipos predefinidos. Você pode, é claro, definir suas próprias exceções. No entanto, programas Dart podem lançar qualquer objeto não-null—não apenas objetos Exception e Error—como uma exceção.

Aqui está um exemplo de lançar, ou raising, uma exceção:

throw FormatException('Expected at least 1 section');

Você também pode lançar objetos arbitrários:

throw 'Out of llamas!';

Como lançar uma exceção é uma expressão, você pode lançar exceções em instruções =>, assim como em qualquer outro lugar que permita expressões:

void distanceTo(Point other) => throw UnimplementedError();

Capturar, ou catching, uma exceção impede que a exceção seja propagada (a menos que você relance a exceção). Capturar uma exceção lhe dá a chance de tratá-la:

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

Para tratar código que pode lançar mais de um tipo de exceção, você pode especificar múltiplas cláusulas catch. A primeira cláusula catch que corresponde ao tipo do objeto lançado trata a exceção. Se a cláusula catch não especifica um tipo, essa cláusula pode tratar qualquer tipo de objeto lançado:

try {
  breedMoreLlamas();
} on OutOfLlamasException {
  // A specific exception
  buyMoreLlamas();
} on Exception catch (e) {
  // Anything else that is an exception
  print('Unknown exception: $e');
} catch (e) {
  // No specified type, handles all
  print('Something really unknown: $e');
}

Como o código anterior mostra, você pode usar on ou catch ou ambos. Use on quando você precisa especificar o tipo da exceção. Use catch quando seu tratador de exceção precisa do objeto de exceção.

Você pode especificar um ou dois parâmetros para catch(). O primeiro é a exceção que foi lançada, e o segundo é o stack trace (um objeto StackTrace).

try {
  // ···
} on Exception catch (e) {
  print('Exception details:\n $e');
} catch (e, s) {
  print('Exception details:\n $e');
  print('Stack trace:\n $s');
}

Para tratar parcialmente uma exceção, enquanto permite que ela seja propagada, use a keyword rethrow.

void misbehave() {
  try {
    dynamic foo = true;
    print(foo++); // Runtime error
  } catch (e) {
    print('misbehave() partially handled ${e.runtimeType}.');
    rethrow; // Allow callers to see the exception.
  }
}
​
void main() {
  try {
    misbehave();
  } catch (e) {
    print('main() finished handling ${e.runtimeType}.');
  }
}

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 é propagada após a cláusula finally ser executada:

try {
  breedMoreLlamas();
} finally {
  // Always clean up, even if an exception is thrown.
  cleanLlamaStalls();
}

A cláusula finally é executada após quaisquer cláusulas catch correspondentes:

try {
  breedMoreLlamas();
} catch (e) {
  print('Error: $e'); // Handle the exception first.
} finally {
  cleanLlamaStalls(); // Then clean up.
}

Para saber mais, confira a documentação de exceções da biblioteca principal.

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

// Make sure the variable has a non-null value.
assert(text != null);
​
// Make sure the value is less than 100.
assert(number < 100);
​
// Make sure this is an https URL.
assert(urlString.startsWith('https'));

Para anexar uma mensagem a uma asserção, adicione uma string como o segundo argumento para assert (opcionalmente com uma vírgula final):

assert(
  urlString.startsWith('https'),
  'URL ($urlString) should start with "https".',
);

O primeiro argumento para assert pode ser qualquer expressão que resolva para um valor booleano. Se o valor da expressão for true, a asserção é bem-sucedida e a execução continua. Se for false, a asserção falha e uma exceção (um AssertionError) é lançada.

Quando exatamente as asserções funcionam? Isso depende das ferramentas e framework que você está usando:

• Flutter habilita asserções no modo de debug.
• Ferramentas apenas para desenvolvimento, como webdev serve, tipicamente habilitam asserções por padrão.
• Algumas ferramentas, como dart run e dart compile js, suportam asserções através de uma flag de linha de comando: --enable-asserts.

Em código de produção, asserções são ignoradas, e os argumentos para assert não são avaliados.