Скачать или смотреть Understanding the Null Safety in Dart: The Difference Between var and int

Explore why using `var` allows null assignments in Dart while `int` enforces non-nullability, impacting your code's error handling and logic.
---
This video is based on the question https://stackoverflow.com/q/75363995/ asked by the user 'ZahRaF' ( https://stackoverflow.com/u/21159252/ ) and on the answer https://stackoverflow.com/a/75365142/ provided by the user 'Abion47' ( https://stackoverflow.com/u/1255873/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: What has the difference between declaring a variable with var and int do with the Null Safety?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Null Safety in Dart: The Difference Between var and int

Introduction to Null Safety in Dart

Dart, as a modern programming language, incorporates a feature known as Null Safety to prevent runtime null dereference errors. This is crucial because null dereference errors can lead to crashes and unpredictable behavior in applications. One common question arising in Dart programming is the difference between declaring variables with var and int, especially in relation to Null Safety. Let's explore this topic in-depth.

The Problem: Assigning Values to Variables

When you declare a variable in Dart, how you declare it (using var or a specific type like int) significantly affects its behavior regarding nullability. Here's the crux of the problem presented:

Using var:

[[See Video to Reveal this Text or Code Snippet]]

In this case, the variable A is declared with var and defaults to dynamic. Since it hasn't been assigned a value, it equates to null by default, allowing the assignment A ??= 12; to occur smoothly.

Using int:

[[See Video to Reveal this Text or Code Snippet]]

Here, the use of int mandates that A must be a non-nullable integer. This will throw an error because A is not assigned any value before it is used. As per Dart's rules, non-nullable variable must be assigned a value before being referenced.

Why the Differences Exist

Understanding var Declaration

When you declare a variable with var, you're essentially telling the Dart compiler:

Type Inference: "I want you to figure out what type this variable should be based on future assignments."

Since A has no initial assignment, the compiler infers its type as dynamic. Dynamic types can hold any value, meaning they default to null, enabling assignments without prior initialization.

Understanding int Declaration

By declaring a variable with a specific type like int, you are explicitly defining the variable as non-nullable. This means:

Non-null assurance: "This variable will always have an integer value and cannot be null."

With int A, Dart requires that you initialize A prior to any usage. If you attempt to use it before assigning it a value, as you may have noticed, you receive a compilation error.

The ??= Operator: A Special Case

The operator ??= checks if a variable is null and if it is, assigns it a value. However, when using int:

Error Explanation: The line A ??= 12 fails because A is non-nullable. The compiler prevents this, knowing that attempting to check for null would require evaluating a variable that hasn't been initialized.

Key Takeaway:

Redundant attempts to assign a default value using ??= on non-nullable variables are flagged as errors.

In essence, non-nullable variables like int must be assigned before use, eliminating the potential for null-related bugs at runtime.

Conclusion: Best Practices for Variable Declaration in Dart

When choosing between var and int, consider the following best practices:

Use var for variables where you might want to allow null values or for flexibility in type assignment.

Use int (or other non-nullable types) when you want to enforce strict non-null rules for better code safety and clarity.

Always initialize non-nullable variables upon declaration to avoid runtime exceptions related to null dereferences.

Understanding these distinctions not only enhances your coding practices in Dart but also leads to greater confidence in writing safe and robust applications. Happy coding!