Deep Dive Into Null and Null Safety in Dart
Tags: dart, flutter, mobile, programming
Published: 2022-08-25 10:11:00

## Introduction

You are in a class and a teacher walks in, asks for a student to assign a task but the student is absent. The teacher can either call another student for the task or ask someone to relay the task's message to the student whenever he/she gets back. This is a model for handling a request with absent recipient.

This analogy can also be modelled in our codes where a variable could either be absent at a point of call or assigned to a value at that point. The ability to handle such case effectively is paramount for every developer.

In this article, we'll be looking at _Null_ and _Null safety_ in Dart.

We will specifically cover the following:

- Introduction to Null and Null safety in Dart
- Nullable and Non-nullable Dart datatypes
- Null-aware operators
- The `late` keyword

Having mentioned that, let's start:
![Let's get started](https://media.giphy.com/media/flbcUFdLSHwZC03p11/giphy.gif)

## Null and Null safety in Dart


_Null_, as a programming concept, simply mean “absence of value”. Having a data type to denote this absence is useful. Let's take a scenario where people are asked to fill their full names in a form. It is possible for some of these people not to have middle names. In a case like this, we want to make an expression that this field could contain a value of String, or it may have no data at all.

The _Null_ class in Dart provides this null value. Imagine there’s no option for null values, we could simply assign an empty string ( “” ) to represent the absence of a middle name. But then, we would need to specify this with a comment for our colleagues to understand.

`String middleName = “”;`

Using an empty String such as this works but we would have to tell other colleagues about it. What if we can actually set `middleName` to the null that it is?

`String middleName = null;`

This is very clear to everyone that there is no value for `middleName`, and based on this, we can easily decide what should happen when the value of the `middleName` is null.

The code above will work just fine in versions of Dart prior to 2.12. However for versions above this, an error will be thrown (at compile time).

`A value of type ‘Null’ can’t be assigned to a variable of type ‘String’`

Before the introduction of _Null_ safety, Dart allows us to pass in values that could be null, calling a method on it on compile time (i.e while typing the code) without throwing an error. This could be dangerous at some point because if that value is eventually null, then our code breaks at runtime. We don’t want our users to see our flaws, right?

Let’s take an example:

Assuming we wish to check the length of our `middleName` variable, we can define a function:

```
int capitalize(String middleName){
  return middleName.toUpperCase();
}
```
Let’s try this code in our main.dart file, in the main function.

```
void main(){
	print (capitalize(‘Adeyemi’)); // ‘ADEYEMI’
	print(capitalize(‘learning flutter’)); // 'LEARNING FLUTTER’
        }
```
This works just fine as long as we do not pass null as a value in the capitalize function. Once we pass null as a parameter to capitalize, in Dart <2.12 (before null safety), the code doesn’t throw an error on compile time but if we run it, the code breaks with an error.

`NoSuchMethodError: The getter ‘length’ was called on null.`

As much as possible we do not want our users to see this, and we might not be able to catch it since it doesn’t appear before running the code. This is why we need null safety. If the same code as above is written in Dart version >2.12 (i.e null safe version), an error is thrown instantly when null is passed as an argument to capitalize.

`print(capitalize(null));`
Error shown: 

`The argument type ‘Null’ can’t be assigned to the parameter type ‘String’`


This change eliminates the possibility of being surprised by null, hence prevents a number of errors. In short, _Null_ safety help keep us safe from the problems of forgotten null occurrence.

## Nullable and Non-nullable Data Types


With the advent of Dart null safety, Dart guarantees us that all its data types are non-null by default. This means that all the data types must have a value, unless we want it to be otherwise (i.e we want it to be null).

Non-nullable types are the common easy-to-understand types that we know, they are declared without using the `?` (question mark) at the end.

Examples of non-nullable types:

- String: “Flutter”, “Dart”, ‘Google’
- int: 2, 35, 7, 22, 100
- double: 0.003, 22.7, 3.142
- bool: true, false
- Sport: basketball, football

This means that all these values are acceptable. For example, we can write in our editor.

```
int myAge = 20;
bool userRegistered = true;
String myWord = “I love Flutter”;
Sport football = Sport(name: “Football”, players: 11);
```
All these would work fine as they are not null. But when we try:

`String myName = null; //A red underline shows on compile time`

A compile-time error is shown immediately.

`A value of type 'Null' can’t be assigned to a variable of type ‘String’.
`
But how then do we assign null to a variable?
![Money Heist professor showing - That is where Dart nullable types comes in](https://cdn.images.express.co.uk/img/dynamic/20/590x/secondary/Money-Heist-season-5-Netflix-2414403.jpg?r=1586858054881)
Picture Reference: [express.co.uk](https://www.express.co.uk/showbiz/tv-radio/1268691/Money-Heist-season-4-professor-Alvaro-Morte-scene-series-Netflix-La-Casa-de-Papel)

**This is where Dart nullable types comes in.**

To make a type nullable, all we have to do is to add a ‘?’ in front of the type.

`int? myAge = null; //This works`

A nullable type allows null value in addition to its original type. This means that the type ‘double?’ can take values such as 1.42, 23.5, null, 0.005 amongst others.

The question mark (?) in front of the type is not an operation on the data type, rather it indicates a whole new datatype.

String? is a whole different datatype from String.


![String? Hierachy in Dart null safety](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xc9bd55bw9drhvt94if7.png)

Reference: [Dart doc](https://dart.dev/null-safety/understanding-null-safety)

> Every non-nullable Dart type has its corresponding nullable type

Also, we can say the non-nullable type is a subtype of its corresponding nullable type. That is, int is a subtype of int? since int? can take a value of int.

Finally, if a nullable variable is not assigned initially, it is given a type of Null.

```
int? year;
String? middleName;
```
If this is printed on console:
```
print(‘Year is $year’);
print(‘Middle name is $middleName’);
```
We have:

```
Year is null
Middle name is null
```

## Null Aware Operators
One of the major issues before the introduction of null safety is how easy it is for developers to forget to handle values that might turnout to be null. With null safety now, Dart ensures that developers cannot perform specific operations on nullable values unless they’ve handled the possibility of null.
For example:

```
int? age;
print(age.isEven);
```
Instantly, on compile-time, Dart throws an unchecked_use_of_nullable_value error stating:

`The property ‘isEven’ can’t be unconditionally accessed because the receiver can be ‘null’
`
Then it goes ahead to suggest:
`Try making the access conditional (using ‘?.’) or adding a null check to the target (‘!’).
`
We can, with this improvement, easily handle the compile-time error instead of waiting until this crashes our app.

Dart provides a set of operators to help handle the possibility of null values, these are known as the null-aware operators.

The null-aware operators are as follows:

- If-null operator (??)
- Null-aware access operator (?.)
- Null assertion operator(!)
- Null-aware assignment operator (??=)
- Null-aware cascade operator(?..)
- Null-aware index operator (?[ ])

Now let’s see how these operators work

### If-null operator (??)
If we have:

```
int? numberOfYears;
final age = numberOfYears ?? 0;
```

> This is simply read as “If numberOfYears is not null, then set age equals numberOfYears, if it is null, set age equals 0”

It should be noted that using that using ?? ensures that the value of age can never be null. Hence, Dart infers the variable as int, not int?
From above, using the ?? operator is same as writing:

```
  int? numberOfYears;
  int? age;
  if(numberOfYears != null){
    age = numberOfYears;
  }else{
    age = 0;
  }
```
That is about 6 additional lines of code instead of the one-liner using the ?? operator.

### Null-aware access operator (?.)
Earlier, we tried age.isEven, and we saw that Dart give us an error at compile-time. To by-pass this, one of the suggested way is to use the ?. operator on age. That is, `age?.isEven`.

This can be explained simply as “If age is null, return null, otherwise if age has a value, return true/false if it’s even or not”.

The operator ?. should be used when we’re not totally sure if the variable will be null or not. Hence, if it turns out to be null, we can easily handle it, if it isn’t null too, we handle it accordingly.


### Null assertion operator (!)
Unlike the Null aware access operator (?.), whenever we’re so sure that the variable we’re handling is definitely not null, we could use the ! operator (bang operator).

`age!.isEven`

In this case, we’re saying that “ Yes, I am sure age is not going to be null, so just check if it’s even”. This comes at a cost though, because if age eventually turns out to be null, our app will crash at runtime.

> The ! operator should be treated as a dangerous operator and only used when we’re very sure our variable will not be null. By using this operator, we simply tell Dart that “look, I am going out of null safety on this variable because I’m sure it’s null, so let me handle it myself”.

### Null- aware assignment operator (??=)
This works like the if-null operator (??), but we use the ??= when updating the same value.
For example:
`String? country;`

When it’s time to use the address variable, it will be wise to check if an address has been assigned earlier. This can be done using the ?? operator as:

`country = country ?? “Nigeria”;`

But since it’s the same variable we want to update, we can simply write:

`country ??= “Nigeria”;`

In simple terms, the ??= operator simply says “If country is null, set country to “Nigeria”, otherwise, retain the current value of country”.

### Null-aware cascade operator (?..)
In Dart, the cascade operator (..) allows us to call multiple method on the same object at a go OR help set multiple properties on the same object.

For example, given a class Sport like this:

```
class Sport{
  String? name;
  int? players;
}
```
If Sport class isn’t nullable, we can us the cascade operator like this:

```
	Sport sport = Sport()
		..name = "Football"
		..players = 11;
```
A common use case of the null-aware cascade operator is on the Path object, during painting in Flutter.

```
Path? path;
Path
   ?..moveTo(0, 0)
    ..lineTo(0, 4)
    ..lineTo(4, 4)
    ..lineTo(4, 0)
    ..lineTo(0,0);
```
> The null-aware cascade operator can be short-circuited, you only need to use it for the first time in the chain and if the variable (path) is null, all operations in the chain do not get called.

### Null-aware Index Operator (?[])
In Dart, indexing is used to access an element of a List

`List<String> myColors = [“Blue”, “Green”, “Red”];`

The indexes begin at 0, hence to call out “Green”, we do this:

`var green = myColors[1];`

Now with null-safety, we know that a List might be null, hence, to index an item of that List we have our helper ?[] operator.

Let’s see an example:
`List<String>? myColors = [“Blue”, “Green”, “Red”];`

Even though, the List is nullable but since we’ve assigned a value to it, it has been promoted.

Setting myColors to null.

`myColors = null;`

Now, when we try to get the “Green” value again, we use the null-aware index operator as thus:

`String? green = myColors?[1];`

This, in literal term means “if myColors is null, assign null value to green. If otherwise, assign the 1th index of myColors to green”.
If we try to access a value from a null list before null-safety, it would have resulted in our app crashing. But again, thanks to null-safety.

## The `late` keyword
Sometimes, we want to make our variable non-nullable but we do not have the value to initialize it. The late keyword helps us to promise Dart that a value will be green to the variable before its usage, but that will be later. Using the late keyword means that the variable’s value won’t be calculated until we access the variable for the first time. This is called *lazy initialization*. There are different ways by which we could later assign a value to that variable before using it like using the initState (for a StatefulWidget) or calling a function that returns that value.

Whenever we try to access a variable that we specific with the late keyword without later assigning a value to it, we broke our promise, hence we get a LateInitializationError
Example:

```
class Sport{
  late String name;
}
```

And then we have something like this somewhere else.

```
Sport sport = Sport();
print(sport.name) //an error would be thrown since we have not initialized name.
```
`LateInitializationError: Field ‘name’ has not been initialized`

## Conclusion

In this article, we have looked at the concept of Null and the beauty of Null safety. If used appropriately, Null safety can help you in writing better and less error-prone codes. 

## Additional Resources

* [Understanding Null Safety](https://dart.dev/null-safety/understanding-null-safety)
* [Dart Null Safety: The Ultimate Guide to Non-Nullable Types](https://codewithandrea.com/videos/dart-null-safety-ultimate-guide-non-nullable-types/)
* [Video - Null Safety in Dart and Flutter](youtube.com/watch?v=PnSpQkOKwv0)