> ## 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-Aware Cascade
The `?..` (null-aware cascade) operator evaluates a sequence of operations on a target object only if that object is not `null`. If the target expression evaluates to `null`, the operator short-circuits, bypassing all subsequent cascaded operations, and yields `null`. If the target is non-null, it executes the operations and returns the original target object.
## Syntax
```dart theme={"dark"}
targetExpression
?..firstMember()
..secondMember = value
..thirdMember();
```
## Mechanics and Behavior
* **Short-circuiting:** The null check occurs exactly once, at the evaluation of `targetExpression`. If `targetExpression` is `null`, the entire cascade block is skipped.
* **Single Application:** The `?..` operator is only required for the *first* operation in the cascade sequence. Subsequent operations in the same chain use the standard cascade operator (`..`). The initial `?..` establishes the non-null guarantee for the remainder of the statement.
* **Return Value:** Like the standard cascade operator, the return values of the individual methods or assignments within the cascade are discarded. The expression evaluates to a reference to the original `targetExpression` (or `null`).
## Execution Equivalency
To understand the underlying control flow, the null-aware cascade operator effectively desugars to a conditional block utilizing a temporary variable.
```dart theme={"dark"}
// Using the null-aware cascade operator
var result = nullableObject
?..methodA()
..propertyB = 10;
```
The compiler treats the above expression as structurally equivalent to:
```dart theme={"dark"}
// Underlying control flow
var _temp = nullableObject;
if (_temp != null) {
_temp.methodA();
_temp.propertyB = 10;
}
var result = _temp;
```
## Operator Precedence
The `?..` operator shares the same precedence level as the standard `..` cascade operator.
* **Lower precedence than arithmetic, logical, and conditional operators:** The target expression is naturally evaluated before the cascade begins. For example, `a + b ?.. c()` automatically evaluates as `(a + b) ?.. c()`, and `a ? b : c ?.. d()` evaluates as `(a ? b : c) ?.. d()`. Parentheses are not required to enforce this evaluation order.
* **Higher precedence than assignment operators:** Cascade operators bind more tightly than assignment. Consequently, an expression like `a = b ?.. c()` evaluates as `a = (b ?.. c())`, applying the cascade operations to `b` before assigning the resulting reference to `a`.
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
