🛡️ Lesson 6: Error Handling

⏱ 30-40 min 📊 Intermediate 🛡️ Essential Skill 🔥 Critical 2026 🔗 Official Source

💥

Why Error Handling Matters

Imagine driving a car without brakes. That's what running code without error handling is like - you're just hoping nothing goes wrong!

❌ Without Error Handling

💥 APP CRASHED!

Users lose data, trust, and patience

✅ With Error Handling

⚠️ Network error. Retrying...

App stays alive, user stays happy

🎯

Today's Project: "Crash-Proof CLI"

We'll build a robust CLI application that:

🛡️ Validates all user inputs
🔧 Handles file operations safely
📊 Logs errors with stack traces
🔄 Retries failed operations
📝 Provides helpful error messages

Step 1

Errors vs Exceptions: Know the Difference

🔍 Error Classifier Tool

Click on each scenario to see if it's an Error or Exception:

🔢

TypeError

Calling a method on null

📝

FormatException

Parsing invalid JSON

🌐

Network Failure

Connection timeout

✅

AssertionError

Assert condition fails

🔴 Errors

Programming mistakes that shouldn't be caught

Indicate bugs in code
Should be fixed, not handled
Examples: TypeError, AssertionError

🟡 Exceptions

Recoverable failures that should be handled

Expected to happen sometimes
Can be caught and recovered
Examples: FormatException, IOException

Step 2

Try/Catch: The Safety Net

🎮 Try/Catch Live Simulator

Write code and see how try/catch handles errors in real-time:

📝 Risky Code:

Error Handling Level:

📤 Output:

> Waiting for code...

🧬 Try/Catch Anatomy

try { Code that might fail

} on SpecificException { Handle specific errors

} catch (e, stackTrace) { Catch all exceptions

} finally { Always runs (cleanup)

Step 3

Creating Custom Exceptions

🏗️ Custom Exception Builder

Design your own exception class:

Exception Name:

Properties (comma-separated):

Extends:

📄 Generated Exception Class:

class ValidationException implements Exception {
  final String message;
  final String field;
  final dynamic value;
  
  ValidationException({
    required this.message,
    required this.field,
    this.value,
  });
  
  @override
  String toString() {
    return 'ValidationException: $message '
        '(field: $field'
        '${value != null ? ", value: $value" : ""})';
  }
}

Step 4

Throw & Rethrow: Error Propagation

🎯 Throw vs Rethrow Simulator

main() {

processData();

validateInput();

throw Exception();

Click Throw or Rethrow to see the difference!

🔼 throw

throw Exception('Error occurred');

Creates a new exception with fresh stack trace

🔄 rethrow

try {
  riskyOperation();
} catch (e) {
  log('Error: $e');
  rethrow; // Preserves original stack!
}

Preserves the original stack trace for debugging

Step 5

Real-World Error Handling Patterns

🧪 Error Handling Lab

Test different error handling patterns with realistic scenarios:

📁 File Operations

🌐 Network Requests

📊 Data Parsing

🔄 Retry Logic

🏆

Build: Crash-Proof CLI Application

🛡️ Input Validator with Custom Exceptions

🔧 Central Error Handler

class ErrorHandler {
  static int retryCount = 0;
  static const maxRetries = 3;
  
  static Future<T> handleAsyncError<T>(
    Future<T> Function() operation, {
    String operationName = 'Operation',
  }) async {
    try {
      return await operation();
    } on TimeoutException {
      print('⏰ $operationName timed out');
      rethrow;
    } on FormatException catch (e) {
      print('📝 $operationName format error: $e');
      rethrow;
    } catch (e, stackTrace) {
      print('❌ $operationName failed: $e');
      print('Stack trace: $stackTrace');
      rethrow;
    }
  }
  
  static Future<T> retryOperation<T>(
    Future<T> Function() operation, {
    int maxAttempts = 3,
    Duration delay = const Duration(seconds: 1),
  }) async {
    for (int attempt = 1; attempt <= maxAttempts; attempt++) {
      try {
        print('🔄 Attempt $attempt...');
        return await operation();
      } catch (e) {
        if (attempt == maxAttempts) rethrow;
        print('⚠️ Attempt $attempt failed, retrying in ${delay.inSeconds}s...');
        await Future.delayed(delay);
      }
    }
    throw Exception('All retry attempts failed');
  }
}

📊 Error Logger

class ErrorLogger {
  static final List<Map<String, dynamic>> _logs = [];
  
  static void logError(
    dynamic error,
    StackTrace? stackTrace, {
    String? context,
    Map<String, dynamic>? metadata,
  }) {
    final logEntry = {
      'timestamp': DateTime.now().toIso8601String(),
      'error': error.toString(),
      'stackTrace': stackTrace?.toString(),
      'context': context,
      'metadata': metadata,
    };
    
    _logs.add(logEntry);
    
    print('''
╔══════════════════════════════════════╗
║           ERROR LOGGED               ║
╠══════════════════════════════════════╣
║ Time: ${logEntry['timestamp']}
║ Error: ${logEntry['error']}
║ Context: ${context ?? 'N/A'}
╚══════════════════════════════════════╝
    ''');
  }
  
  static List<Map<String, dynamic>> getLogs() => List.unmodifiable(_logs);
  
  static void clearLogs() => _logs.clear();
  
  static void printLogSummary() {
    if (_logs.isEmpty) {
      print('✅ No errors logged');
      return;
    }
    
    print('\n📊 Error Log Summary:');
    print('Total errors: ${_logs.length}');
    
    final errorTypes = <String, int>{};
    for (var log in _logs) {
      final type = log['error'].toString().split(':')[0];
      errorTypes[type] = (errorTypes[type] ?? 0) + 1;
    }
    
    errorTypes.forEach((type, count) {
      print('  $type: $count');
    });
  }
}

🎮 Error Handling Challenge: Survival Quiz

🛡️ Score: 0/5

⚡ Streak: 0

⏱ Time: 0s

💪 Resilience: 100%

Loading question...

App Stability: 🟢🟢🟢🟢🟢