How do you handle exceptions in Dart?

In Dart, exception handling is done using try-catch blocks, optionally with a finally block. Exception handling is essential to make programs robust and prevent crashes when unexpected errors occur, like invalid input, file not found, or network failure.

1. Basic try-catch:
   You wrap the code that might throw an exception in a try block and handle the exception in a catch block.

void main() {
  try {
    int result = 12 ~/ 0; // Integer division by zero
    print(result);
  } catch (e) {
    print("An error occurred: $e");
  }
}

Here, ~/ is integer division. Dividing by zero throws an exception, which is caught in the catch block.

2. Catching the Stack Trace:
   You can also capture the stack trace to debug where the error happened:

try {
  int result = 12 ~/ 0;
} catch (e, stackTrace) {
  print("Error: $e");
  print("Stack trace: $stackTrace");
}

3. Using finally:
   The finally block executes regardless of whether an exception occurred, which is useful for cleanup tasks, like closing files or database connections.

try {
  int result = 12 ~/ 0;
} catch (e) {
  print("Error occurred: $e");
} finally {
  print("This always runs");
}

4. Practical Use:
   In projects, I often handle exceptions when making network requests or parsing JSON data, because APIs can fail or return unexpected data. Handling exceptions prevents the app from crashing and allows me to show meaningful error messages to users.
5. Challenges:

• Overusing generic catch (e) can hide the type of error. Sometimes it’s better to catch specific exceptions like FormatException or IOException.
• Forgetting to handle exceptions in asynchronous code (async functions) can lead to unhandled Future errors.

try {
  await fetchData(); // async function
} catch (e) {
  print("Network error: $e");
}

6. Alternative:

• Use on keyword to catch specific exception types:

try {
  int result = int.parse("abc");
} on FormatException catch (e) {
  print("Invalid number: $e");
}

Exception handling in Dart is flexible, safe, and combines well with asynchronous programming to make applications stable and user-friendly.