Missing values and calls that fail

Saying that a value may be absent

A plain String is always there. Add a question mark and you have said the value may be missing: String? nickname. That mark is a promise in the other direction — the compiler now refuses to treat the value as text until you have dealt with the possibility that it is null.

Null is a real value and a useful one: it is what a map gives you for a key that is not there, and what an optional field holds when nobody filled it in. The work is in deciding what a missing value should mean at the moment you use it, rather than hoping it never happens.

The safe call and the fallback

?. is the safe call: nickname?.length asks for the length only when there is something to ask about, and the whole expression answers null when there is not. Nothing after the safe call runs, so a chain of them cannot crash on a missing value.

?? supplies the fallback: nickname ?? "none" gives the nickname when it is there and the text you chose when it is not. prices["mouse"] ?? 0 is the same idea for a lookup, and it is what turns a missing price into a number a report can add up.

A value stored in a field is not one the compiler can vouch for, because another line could change it at any time. Copy it into a local first — final nick = nickname; — and the compiler can see for itself that the local is not null below your check. That is usually the tidiest answer, and it needs no bang at all.

The bang, and what to do when a call fails

! tells the compiler to trust you: prices["hub"]! is read as a value that is certainly there. It is the last resort, because it is a claim rather than a check, and when the claim is wrong the program stops with an error. Use it where the value is undeniably present, and prefer ?? everywhere else.

Some failures cannot be designed away. A function can raise one on purpose with throw: throw ArgumentError("no price") stops the ordinary flow and starts looking for someone to deal with it. try marks the lines that might fail and catch holds the answer to the failure, so the program keeps running and can print a sentence a person can act on.

The compiler follows your checks

Null safety is not only a mark on a type; the compiler tracks what it knows at each line. After if (nick == null) return; the name nick is known to be non-null below the check, so .length is allowed there. This is flow analysis, and it is why a check followed by a use needs no bang.

The tracking works best for local variables. A field can be changed by another line between the check and the use, so the compiler will not keep the promotion for it. Copy the field into a local, check the local, and use the local — the guarantee then holds for the whole block.

late is the promise that a non-nullable field will be filled before it is read. It moves the check to run time: read it too early and the program throws. Use it when the constructor cannot supply the value, not as a way to avoid deciding what a missing value means.

Failures are values you can catch

throw takes an object and starts unwinding the call stack until a catch takes it. ArgumentError and FormatException are in the standard library, and the message on them is what the reader of the output will see. Throw the most specific type that describes the problem.

on FormatException catch (error) catches only that type, while a bare catch catches everything. The narrow form is better: a bug such as a null read should not be swallowed by the handler you wrote for bad input. catch gives you the object, and its toString() is what a message should include.

finally runs whether the try succeeded, threw or returned early. It is for the step that must happen either way, such as printing a closing line or releasing a resource. A rethrow inside a catch passes the same failure on after you have recorded it.

A field that may be missing, handled with a local

class Profile {
  Profile(this.name, this.nickname);
  final String name;
  final String? nickname;
  String get display {
    final nick = nickname;
    if (nick == null) {
      return name;
    }
    return name + " aka " + nick;
  }
}

void main() {
  print(Profile("Ada", null).display);
  print(Profile("Grace", "amazing").display);
}

Try these next

• Ask a map for a missing key three ways: print the raw value, use ??, and use ?..
• Throw an ArgumentError from a function, catch it, and print the message it carries.
• Add a finally line to a try that returns early and confirm that it still runs.