Concise Null, False, and Empty Checking in Dart: Leveraging Safe Navigation and Null Coalescing Operators

In Dart programming, handling null, false, and empty checks is a common task. Developers often need to write conditional statements to check if a variable is null, an empty string, false, or zero. Traditional approaches typically involve multiple logical OR (||) operators, leading to verbose and hard-to-maintain code. This article explores how to leverage Dart's language features to simplify these checks, improving code readability and safety.

Limitations of Traditional Checking Methods

Consider the following code snippet that checks if a key in a map is null, an empty string, or false:

if (routeinfo["no_route"] == "" || routeinfo["no_route"] == null || routeinfo["no_route"] == false) {
    // do something...
}

While intuitive, this approach has several drawbacks: first, it is repetitive, requiring multiple references to routeinfo["no_route"]; second, extending the check (e.g., adding zero) makes the code even more verbose. For example:

if (routeinfo["no_route"] == "" || routeinfo["no_route"] == null || routeinfo["no_route"] == false || routeinfo["no_route"] == 0) {
    // do something...
}

This motivates the search for more concise solutions.

Using Safe Navigation and Null Coalescing Operators

Dart provides the safe navigation operator (?.) and null coalescing operator (??), which can significantly simplify null and empty string checks. The safe navigation operator calls a method or property only if the object is non-null, otherwise returning null. Combined with the null coalescing operator, we can handle default values for null cases.

For checking empty strings or null, the following approach can be used:

if (routeinfo["no_route"]?.isEmpty ?? true) {
    // do something...
}

Here, routeinfo["no_route"]?.isEmpty calls the isEmpty method if the value is non-null to check for an empty string, returning null if it is null. Then, ?? true converts null to true, ensuring the condition holds when the value is null. This method consolidates multiple checks into a single line, enhancing conciseness.

If the map itself might be null, safe navigation can be applied further:

if (routeinfo?["no_route"]?.isEmpty ?? true) {
    // do something...
}

This ensures the entire expression handles null safely even if routeinfo is null.

List Containment Check Method

Another simplification method involves using the contains method of a list, placing the values to check into a list. For example, to check for null, empty string, false, and zero:

if (["", null, false, 0].contains(routeinfo["no_route"])) {
    // do something...
}

This method is intuitive and easy to extend by adding new values to the list. However, it may sacrifice some type safety since the list can contain elements of different types, though it is acceptable in this context.

Advanced Applications with Extension Methods

For more complex checks, such as including empty iterables, empty maps, or type-specific checks, Dart's extension methods can be utilized. Extension methods allow adding custom functionality to existing types without modifying the original class.

Below is an example of an extension method that adds null, empty, or false checks to the Object type:

extension GeneralUtilsObjectExtension on Object {
    bool get isNullEmptyOrFalse =>
        this == null ||
        _isStringObjectEmpty ||
        _isIterableObjectEmpty ||
        _isMapObjectEmpty ||
        _isBoolObjectFalse;

    bool get _isStringObjectEmpty =>
        (this is String) ? (this as String).isEmpty : false;

    bool get _isIterableObjectEmpty =>
        (this is Iterable) ? (this as Iterable).isEmpty : false;

    bool get _isMapObjectEmpty => (this is Map) ? (this as Map).isEmpty : false;

    bool get _isBoolObjectFalse =>
        (this is bool) ? (this as bool) == false : false;
}

Using this extension, the check simplifies to:

if (routeinfo["no_route"].isNullEmptyOrFalse) {
    // do something...
}

This approach offers high modularity and type safety, but note that in Dart's Null Safety environment, type promotion may not occur within extension methods. Therefore, in Null Safety code, direct == null checks might be preferable for type inference.

Impact of Null Safety

Dart's Null Safety feature introduces non-nullable and nullable types, changing how null checks are performed. Under Null Safety, direct == null checks can promote types from nullable to non-nullable. For example:

int definitelyInt(int? aNullableInt) {
    if (aNullableInt == null) {
        return 0;
    }
    return aNullableInt; // type promoted to int
}

However, if using an isNull property in an extension method, type promotion might not occur because the check is encapsulated in a sub-scope. Thus, in Null Safety code, it is advisable to prefer direct null checks to ensure type safety.

Best Practice Recommendations

Based on the analysis above, here are some best practices:

1. For simple null or empty string checks, use the safe navigation and null coalescing operators (?.isEmpty ?? true), which are concise and safe.
2. When checking multiple specific values, consider the list containment method, but be aware of potential risks due to its type flexibility.
3. In complex scenarios, extension methods provide reusable solutions, but be mindful of type promotion limitations under Null Safety.
4. In Null Safety environments, prioritize direct null checks (== null) to leverage type promotion and enhance code safety.
5. Always consider code readability and maintainability, choosing the approach that best fits project needs.

By effectively utilizing Dart's language features, developers can write code that is both concise and safe, efficiently handling null, false, and empty checks to improve overall code quality.