Null Safety & Error Handling

1. Vì sao có null safety?

Năm 2009, Tony Hoare — người tạo ra null reference năm 1965 — gọi đây là "billion dollar mistake". Lý do: null reference gây ra uncountable bug runtime ở mọi ngôn ngữ có nó (Java, C#, JS, Python).

Dart trước version 2.12 (2021): có null tự do — biến bất kỳ có thể là null. Mỗi access có thể throw.

Dart 2.12+: sound null safety. Compile-time guarantee: nếu type là T (không ?), giá trị không bao giờ là null. Mọi nullable phải explicit T?.

2. Nullable T? vs non-nullable T

// Non-nullable — không bao giờ null
int count = 0;
count = null;       // ❌ Lỗi compile

// Nullable — có thể null
int? maybeCount = 0;
maybeCount = null;  // OK

// Default value cho nullable: null
String? name;       // = null mặc định
print(name);        // null

// Non-nullable chưa gán → lỗi compile khi đọc
String message;
print(message);     // ❌ "Non-nullable variable 'message' must be assigned"

3. Definite assignment analysis

Analyzer kiểm tra biến non-nullable phải được gán chắc chắn trước khi đọc:

void demo(int input) {
  String name;
  if (input > 0) {
    name = 'positive';
  } else if (input < 0) {
    name = 'negative';
  } // ⚠ Thiếu case input == 0
  print(name);  // ❌ Lỗi — không chắc chắn gán
}

Fix: thêm else hoặc gán default:

void demo(int input) {
  String name;
  if (input > 0) {
    name = 'positive';
  } else if (input < 0) {
    name = 'negative';
  } else {
    name = 'zero';
  }
  print(name);  // ✅
}

4. 5 null-aware operator

?. — Safe call

String? name;
print(name?.length);  // null (không throw)

name = 'Việt';
print(name?.length);  // 4

// Chain
print(user?.address?.city?.toLowerCase());

?? — Default value

String? name;
final displayName = name ?? 'Khách';  // 'Khách'

name = 'Việt';
final d2 = name ?? 'Khách';            // 'Việt'

??= — Assign nếu null

String? name;
name ??= 'default';   // gán vì null
print(name);          // 'default'

name ??= 'override';  // không gán vì đã có giá trị
print(name);          // 'default'

...? — Spread null-safe

List<int>? maybeXs;
final combined = [0, ...?maybeXs, 99];
print(combined);   // [0, 99] — maybeXs null bị skip

maybeXs = [1, 2, 3];
final c2 = [0, ...?maybeXs, 99];
print(c2);          // [0, 1, 2, 3, 99]

?[] — Index null-safe

Map<String, int>? map;
print(map?['key']);   // null (map null)

map = {'a': 1};
print(map?['a']);     // 1
print(map?['b']);     // null (key không tồn tại)

Bảng tóm tắt 5 null-aware operator:

! — Non-null assertion

! promote T? thành T. Nếu thực sự là null → runtime exception.

String? maybeName = getName();

// Dùng ! khi BẠN biết chắc không null nhưng analyzer không
print(maybeName!.length);  // promote → String, throw nếu null

// Cẩn thận — đây là escape hatch
final users = <User>[];
final first = users.firstOrNull!;  // throw vì list rỗng

5. Flow analysis / Type promotion

Analyzer thu hẹp type sau check null:

void demo(String? name) {
  if (name != null) {
    // Trong block này, name PROMOTED thành String
    print(name.length);   // ✅ — không cần !
  }

  // Pattern early return cũng work
  if (name == null) return;
  print(name.length);     // ✅ — sau early return, chắc chắn không null
}

class User {
  String? name;

  void show() {
    if (name != null) {
      print(name.length);  // ❌ — field không promoted
    }

    // Pattern: copy field ra local
    final n = name;
    if (n != null) {
      print(n.length);     // ✅ — local n được promote
    }
  }
}

6. late keyword

Late initialization

class User {
  late String name;       // "tôi hứa sẽ gán trước khi đọc"

  void init(String v) {
    name = v;
  }
}

final u = User();
// print(u.name);   // ❌ Runtime: LateInitializationError
u.init('Việt');
print(u.name);     // ✅ Việt

late final — lazy init

class Config {
  late final String token = _loadToken();  // chỉ gọi khi đọc lần đầu

  String _loadToken() {
    print('Loading...');
    return 'abc123';
  }
}

final c = Config();
print('created');    // created
print(c.token);       // Loading... abc123
print(c.token);       // abc123 (không loading lại)

7. Exception vs Error

// Exception — lỗi có thể recover, nên catch
throw FormatException('Invalid JSON');
throw HttpException('404 Not Found');

// Error — bug programming, KHÔNG nên catch
throw RangeError('Index out of range');
throw StateError('Object in invalid state');
throw ArgumentError('value cannot be negative');

Bảng:

8. try / catch / finally

try {
  final result = int.parse('abc');
} catch (e) {
  print('Lỗi: $e');              // FormatException
} finally {
  print('Cleanup');              // Luôn chạy
}

on Type catch — bắt type cụ thể

try {
  doStuff();
} on FormatException catch (e) {
  print('Parse fail: ${e.message}');
} on HttpException catch (e) {
  print('Network fail: $e');
} on Exception catch (e) {
  print('Generic exception: $e');
} catch (e, stackTrace) {
  print('Unknown: $e');
  print(stackTrace);
}

rethrow — giữ stack trace

int parsePositive(String s) {
  try {
    final n = int.parse(s);
    if (n < 0) throw ArgumentError('Negative not allowed');
    return n;
  } on FormatException {
    print('Log: parse failed for "$s"');
    rethrow;        // throw lại, giữ stack trace gốc
  }
}

rethrow khác throw e: rethrow giữ stack trace gốc — dev debug được nơi exception sinh ra ban đầu. throw e tạo stack trace mới ở dòng throw.

9. Custom exception class

class ApiException implements Exception {
  final int statusCode;
  final String message;

  const ApiException(this.statusCode, this.message);

  @override
  String toString() => 'ApiException($statusCode): $message';
}

Future<User> fetchUser(int id) async {
  final response = await http.get(...);
  if (response.statusCode != 200) {
    throw ApiException(response.statusCode, response.body);
  }
  return User.fromJson(response.body);
}

// Usage
try {
  final u = await fetchUser(1);
} on ApiException catch (e) {
  print('API lỗi: ${e.statusCode}');
}

10. Async error handling

Future<String> fetchData() async {
  await Future.delayed(Duration(seconds: 1));
  throw Exception('Network down');
}

// Cách 1: try/catch quanh await — idiomatic
Future<void> main() async {
  try {
    final data = await fetchData();
    print(data);
  } catch (e) {
    print('Lỗi: $e');
  }
}

// Cách 2: .catchError — legacy nhưng vẫn dùng được
void main2() {
  fetchData()
    .then((data) => print(data))
    .catchError((e) => print('Lỗi: $e'));
}

ElevatedButton(
  onPressed: () async {
    await fetchData();   // nếu throw, không có gì catch
  },
  ...
)

// Pattern an toàn: wrap try/catch trong callback
ElevatedButton(
  onPressed: () async {
    try {
      await fetchData();
    } catch (e) {
      _showError(e.toString());
    }
  },
  ...
)

11. Bài tập

class User { final String name; final Address? address; ... }
class Address { final String? city; ... }

String displayCity(User u) =>
    u.address?.city ?? 'Không có địa chỉ';

void show(User? u) {
  print(u!.name!.toUpperCase());
  print(u!.address!.city!);
}

void show(User? u) {
  if (u == null) return;
  print(u.name?.toUpperCase() ?? '(không tên)');
  print(u.address?.city ?? '(không địa chỉ)');
}

class App {
  late final Database db;

  void setDb(Database d) {
    db = d;
  }
}

void main() {
  final app = App();
  try {
    app.db.query();  // throws LateInitializationError
  } catch (e) {
    print('Error: $e');
  }

  app.setDb(Database());
  app.db.query();  // OK
}

class ApiException implements Exception {
  final int statusCode;
  final String message;
  final String endpoint;
  const ApiException(this.statusCode, this.message, this.endpoint);

  @override
  String toString() => 'ApiException($statusCode @ $endpoint): $message';
}

Future<String> fetchUser(int id) async {
  if (id < 0) throw ApiException(400, 'Invalid id', '/users/$id');
  return 'user_$id';
}

void main() async {
  try {
    await fetchUser(-1);
  } on ApiException catch (e) {
    print(e);
  }
}

class NetworkException implements Exception {}

Future<Map> fetchAndParse(String url) async {
  try {
    final response = await mockFetch(url);
    return jsonDecode(response);
  } on NetworkException {
    return {'error': 'offline'};
  } on FormatException {
    return {'error': 'invalid response'};
  } catch (e) {
    return {'error': 'unknown: $e'};
  }
}

12. Quiz

13. Tổng kết

• ✅ Sound null safety = compile-time guarantee.
• ✅ T? nullable, T non-nullable. Mọi escape phải explicit.
• ✅ 5 null-aware operator: ?., ??, ??=, ...?, ?[].
• ✅ ! non-null assertion — bypass nhưng runtime risk.
• ✅ Flow promotion — chỉ work với local var (không field).
• ✅ late = "hứa sẽ gán"; late final = expr = lazy init.
• ✅ Exception vs Error — semantic khác.
• ✅ try/catch/on/finally/rethrow.
• ✅ Async error: try/catch quanh await idiomatic.

14. Kết nối

• Chương 4 — class field late.
• Chương 7 — Async/Stream — Future error đầy đủ.
• Flutter chương 6+ — state nullable / non-nullable, mounted check pattern.