Search for a command to run...
What is sound null safety and how to achieve it in Dart.
I am a full stack developer, a Machine Learning enthusiast & a Flutter Developer. Also, I am a budding Entrepreneur!
I am a student of Life and believe in building tech for people.
I love contributing to open-source projects and use my knowledge to develop a software solution for general problems arising in the community.
No comments yet. Be the first to comment.
In this series, I will cover interesting micro articles on how to get more comfortable with Flutter & Dart.
Real-Time Communication in Flutter: A Comprehensive Guide to Implementing WebSockets for Seamless Connectivity
Have you ever worked on a frontend codebase so large that you feared deploying a CSS change to the Settings page because it might somehow break the Checkout flow? Or perhaps you've struggled to align three different teams working on the same React re...
Real-Time Communication in Flutter: A Comprehensive Guide to Implementing WebSockets for Seamless Connectivity
Elevate Your Flutter App's Notification Game: Master Firebase Cloud Messaging Like a Pro!
Mastering Clean Architecture and GetX for High-Performing Flutter Apps
Unleash the power of Dart's Extension Methods with this simple guide
Ever wondered what is all this fuss about null safety? In this article, I'll provide a brief introduction to null safety in Dart and share code examples for a better understanding.
Null safety helps you solve one of the most common errors in software development: NullPointerException.
The main issue with the NullPointerException is that it can happen in almost any part of the app if not well handled. Checking for nulls every now and then throughout your app isn’t the best solution either. As your app grows, it can become even harder to handle the null values. For these reasons and more, handling nulls at the language level is probably the best way to avoid the infamous NullPointerEception.
To build on this idea, the Dart team introduced sound null safety. This means that variables are considered non-nullable by default. If you don’t give an object null support when you create it, it will never store a null. As a result, you avoid null reference errors in your code.
To activate null safety, you need to go to your pubspec.yaml file and ensure the SDK version is set to:
environment:
sdk: ">=2.12.0 <3.0.0"
Make sure to run flutter pub get after updating the pubspec.yaml.
Before we move on to creating null safe apps, let's discuss the type system implemented by Dart.
Dart divides types into two groups:
Let's have a look at these types in the next section.
Now that we have null-safety activated, all our types are by default non-nullable, which means they all require some value.
String name = 'Aditya Sharma'; // This works ✔
String name = null; // Will throw error ❌
Adding a ? makes the Type nullable and allows us to pass a null value to our name field.
String? name = 'Aditya Sharma'; // This works ✔
String? name = null; // This works too ✔
Let's now have a look at some real-world scenarios:
Null check is a Dart feature that helps you to avoid null related errors.
Let's take an example:
void setName(String name) {
name.toUpperCase();
print(name);
}
void main() {
setName(null); // Throws error ❌
}
In this case, type String is not nullable and thus we cannot store a null inside it.
If we want to pass a null value to setName(), we change the parameter type to String?:
void setName(String? name) {
name.toUpperCase(); // Warning here ❌
print(name);
}
void main() {
setName(null);
}
Now, the compiler warns us that we cannot call the upperCase() on name as it can also store a null value.
We have 2 ways to fix it:
The null aware accessor ?.:
void setName(String? name) {
name?.toUpperCase();
print(name);
}
//
void main() {
setName(null);
}
Check for null before calling any method on name:
void setName(String? name) {
if (name == null) return;
name.toUpperCase();
print(name);
}
//
void main() {
setName(null);
}
When converting from Type to Type?, there is no problem as Type? accepts both real value and null value.
void main() {
String name = 'Aditya';
String? newName = name; // Works fine ✔
}
When converting from Type? to Type, the compiler gives us a warning.
void main() {
String? name = null;
String newName = name; // Warning ❌
}
We have 3 ways to fix it:
Check for null before conversion:
void main() {
String? name = null;
if (name != null) {
String newName = name;
}
}
Using the if-null ?? operator for providing a default value:
void main() {
String? name = null;
String newName = name ?? 'Aditya';
}
Using the Bang operator ! (also called the null assertion operator):
void main() {
String? name = null;
String newName = name!;
}
PS: If you’re sure that an expression with a nullable type isn’t null, you can use a null assertion operator
!to make Dart treat it as non-nullable. By adding!just after the expression, you tell Dart that the value won’t benull, and that it’s safe to assign it to a non-nullable variable.
⚠️: If you’re wrong, Dart throws an exception at run-time. This makes the!operator unsafe, so don’t use it unless you’re very sure that the expression isn’t null.
Sometimes, you can’t initialize properties in the constructor, but you’ll define them in other methods of your class. In that case, you mark those properties with late.
Another advantage of late is lazy initialization. Dart will not initialize late properties until they’re used for the first time. This can be useful during app initialization when an expression is costly or might not be needed.
late String name;
@Override
void initState() {
super.initState();
name = 'Aditya Sharma';
}
Dart has three main operators to work with null:
?., which accesses properties of its operand, is an example. If the operand is null, then it will not throw an exception. Instead, it shows null text.! to cast away nullability. It tries to cast a nullable type to a non-nullable type, throwing an exception if the operand is null.?? is shorthand for an if-else condition. If the left side of the ?? operator is null, then it will use its right side.late on variables when you’re sure you’ll initialize them before using them. Use late with class properties.That's all folks! Do let me know what you liked and what can be improved in the comments below! Also, feel free to drop me a line if you don't understand something. ✌
Thanks for reading!