> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Dart Null In Dart, `null` is a built-in literal representing the intentional absence of a value. Architecturally, `null` is the single, immutable instance of the `Null` class. Under Dart's sound null safety system, types are non-nullable by default, meaning a variable cannot contain `null` unless its type explicitly permits it at compile time. ## The `Null` Class and Type Hierarchy The `Null` class occupies a specific position within Dart's unified type system: * `Null` is a subtype of all nullable types. * The absolute top type in Dart is `Object?`, which is the supertype of all types, including `Null`. * The non-nullable top type `Object` does *not* accept `null`. * The bottom type `Never` cannot be `null` (as it represents a state that never completes). ## Nullable Type Syntax To designate a type as nullable, append a question mark (`?`) to the type declaration. Conceptually, this creates a union type of the base type and the `Null` class (e.g., `String?` acts as `String | Null`). ```dart theme={"dark"} // Non-nullable type: Memory is guaranteed to hold a String. String nonNullableString = 'Dart'; // nonNullableString = null; // Static analysis error // Nullable type: Memory can hold a String or the Null instance. String? nullableString = null; ``` ## Null-Aware Operators Dart provides specific operators to safely navigate, evaluate, and cast expressions involving `null` at the syntax level: * **Null-assertion operator (`!`):** Acts as an explicit cast that the static analyzer recognizes, promoting a nullable expression's static type to its underlying non-nullable type. It throws a `TypeError` at runtime if the operand evaluates to `null`. ```dart theme={"dark"} int? nullableInt = 5; int nonNullableInt = nullableInt!; ``` * **Null-coalescing operator (`??`):** Evaluates to the left operand if it is not `null`; otherwise, evaluates to the right operand. ```dart theme={"dark"} String? nullableValue; String resolvedValue = nullableValue ?? 'Fallback'; ``` * **Null-coalescing assignment operator (`??=`):** Assigns a value to a variable only if that variable currently evaluates to `null`. ```dart theme={"dark"} int? counter; counter ??= 1; ``` * **Null-aware access operator (`?.`):** Conditionally accesses a property or method. If the receiver is `null`, the expression short-circuits and evaluates to `null` instead of throwing a `NoSuchMethodError`. ```dart theme={"dark"} String? text; int? length = text?.length; ``` * **Null-aware cascade operator (`?..`):** Performs a sequence of operations on the same object only if the target object is not `null`. ```dart theme={"dark"} List? numbers; numbers?..add(1)..add(2); ``` * **Null-aware index operator (`?[]`):** Attempts to access an index of a collection only if the collection itself is not `null`. ```dart theme={"dark"} List? items; String? firstItem = items?[0]; ``` * **Null-aware spread operator (`...?`):** Conditionally inserts multiple elements into a collection. If the source collection is `null`, it is safely ignored rather than throwing an error. ```dart theme={"dark"} List? nullableList; List combinedList = [1, 2, ...?nullableList]; ``` ## Late Initialization The `late` modifier alters how the compiler enforces initialization rules. It decouples the declaration of a variable from its initialization, deferring the definite assignment (initialization) check from compile-time to runtime. When applied to a non-nullable variable, it allows the variable to be declared without an immediate value, provided it is initialized before its first read. ```dart theme={"dark"} late String deferredString; // Accessing before initialization throws a LateInitializationError // print(deferredString); deferredString = 'Allocated'; ``` The `late` modifier can also be applied to nullable variables. This enforces that the variable is explicitly initialized before use, allowing developers to distinguish between an uninitialized state (which throws an error if read) and a state explicitly set to `null`. ```dart theme={"dark"} late String? explicitlyNullable; // print(explicitlyNullable); // Throws LateInitializationError explicitlyNullable = null; // Explicitly initialized to null print(explicitlyNullable); // Prints 'null' ```

Tired of Poor Dart Skills? Fix That With Deep Grasping! Learn More