Understanding Null Safety in Dart

Null safety is a powerful feature in Dart that ensures your code is free from null reference errors at compile time. By default, variables in Dart cannot hold null values unless explicitly allowed. Let's explore the key concepts of null safety and how to use them effectively.

Non-Nullable Types

By default, variables in Dart cannot be null:

int number = 42; // Non-nullable
number = null;   // Error: A non-nullable variable can't be null.

Nullable Types

To allow a variable to hold a null value, use a question mark (?) after the type:

int? nullableNumber; // Nullable
nullableNumber = null; // Allowed
nullableNumber = 10;   // Also allowed

Null Assertion Operator (!)

If you're certain a nullable variable is not null, use the ! operator to access its value:

int? nullableNumber = 10;
int nonNullableNumber = nullableNumber!; // Forces access

Warning: Using ! on a null value causes a runtime error.

The late Keyword

Use the late keyword to declare a variable that will be initialized later but is guaranteed to be non-nullable:

late String description;

description = "Initialized later.";
print(description);

Null-Coalescing Operators

These operators help handle null values more elegantly:

• ?? Operator: Provides a default value if the variable is null.

int? nullableNumber;
print(nullableNumber ?? 0); // Prints 0

• ??= Operator: Assigns a value if the variable is null.

int? nullableNumber;
nullableNumber ??= 10;
print(nullableNumber); // Prints 10

Type Promotion

After checking a nullable variable for null, Dart automatically promotes its type:

void printLength(String? text) {
  if (text != null) {
    print(text.length); // `text` is now non-nullable
  }
}

Null Safety and Collections

Collections can also benefit from null safety:

List nullableList = [1, null, 3]; // List with nullable elements
List nonNullableList = [1, 2, 3]; // List with non-nullable elements

Migrating to Null Safety

To migrate existing code to null safety:

1. Run the migration tool: dart migrate.
2. Analyze and update code for nullable and non-nullable cases.
3. Use ?, late, or refactor where necessary.

Conclusion

Null safety in Dart helps you write safer, more predictable code by eliminating null reference errors. By understanding and using nullable types, the late keyword, and null-aware operators, you can build robust and error-free applications.

For more details, visit the official Dart documentation.