Manejo de errores

Tu código Dart puede lanzar y capturar excepciones. Las excepciones son errores que indican que algo inesperado sucedió. Si la excepción no se captura, el isolate que originó la excepción se suspende y, por lo general, el isolate y su programa finalizan.

A diferencia de Java, todas las excepciones de Dart son excepciones no comprobadas (unchecked). Los métodos no declaran qué excepciones podrían lanzar, y no estás obligado a capturar ninguna excepción.

Dart proporciona los tipos Exception y Error , así como numerosos subtipos predefinidos. Por supuesto, puedes definir tus propias excepciones. Sin embargo, los programas Dart pueden lanzar cualquier objeto que no sea nulo —no solo objetos Exception y Error— como excepción.

Aquí tienes un ejemplo de cómo lanzar o generar una excepción:

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

También puedes lanzar objetos arbitrarios:

throw 'Out of llamas!';

Debido a que lanzar una excepción es una expresión, puedes lanzar excepciones en sentencias de tipo =>, así como en cualquier otro lugar que permita expresiones:

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

Capturar o atrapar una excepción detiene la propagación de la misma (a menos que vuelvas a lanzar la excepción con rethrow). Capturar una excepción te da la oportunidad de manejarla:

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

Para manejar código que puede lanzar más de un tipo de excepción, puedes especificar múltiples cláusulas catch. La primera cláusula catch que coincida con el tipo del objeto lanzado manejará la excepción. Si la cláusula catch no especifica un tipo, esa cláusula puede manejar cualquier tipo de objeto lanzado:

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 muestra el código anterior, puedes usar on, catch o ambos. Usa on cuando necesites especificar el tipo de excepción. Usa catch cuando tu manejador de excepciones necesite el objeto de la excepción.

Puedes especificar uno o dos parámetros para catch(). El primero es la excepción que se lanzó, y el segundo es el rastreo de la pila (un 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 manejar parcialmente una excepción, permitiendo al mismo tiempo que se propague, usa la palabra clave 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 garantizar que algo de código se ejecute independientemente de si se lanza o no una excepción, usa una cláusula finally. Si ninguna cláusula catch coincide con la excepción, la excepción se propaga después de que se ejecute la cláusula finally:

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

La cláusula finally se ejecuta después de cualquier cláusula catch coincidente:

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

Para obtener más información, consulta la documentación de excepciones de la biblioteca principal.

Durante el desarrollo, usa una sentencia assert — assert(<condición>, <mensajeOpcional>); — para interrumpir la ejecución normal si una condición booleana es 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 adjuntar un mensaje a una aserción, añade una cadena como segundo argumento a assert (opcionalmente con una coma final):

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

El primer argumento para assert puede ser cualquier expresión que se resuelva en un valor booleano. Si el valor de la expresión es true, la aserción tiene éxito y la ejecución continúa. Si es false, la aserción falla y se lanza una excepción (un AssertionError).

¿Cuándo funcionan exactamente las aserciones? Eso depende de las herramientas y el framework que estés utilizando:

• Flutter habilita las aserciones en modo depuración (debug mode).
• Las herramientas exclusivas de desarrollo como webdev serve suelen habilitar las aserciones por defecto.
• Algunas herramientas, como dart run y dart compile js admiten aserciones a través de una bandera de línea de comandos: --enable-asserts.

En el código de producción, las aserciones se ignoran y los argumentos de assert no se evalúan.