> ## 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 Initializer List
An initializer list is a comma-separated sequence of expressions placed between a constructor's parameter list and its body, prefixed by a colon (`:`). It executes before the constructor body runs and before the superclass constructor is invoked, allowing for the assignment of instance variables before the object is fully instantiated.
```dart theme={"dark"}
ClassName(parameterList) : initializer1, initializer2 {
// constructor body
}
```
## Execution Order
When a constructor is invoked, Dart processes the initialization phase in a strict sequence:
1. Initializer list expressions (evaluated from left to right).
2. Superclass constructor.
3. Main class's constructor body.
## Scope and Restrictions
* **No `this` Access:** The right-hand side of an initializer expression does not have access to the `this` keyword. You cannot invoke instance methods or read instance variables within the initializer list because the object is in an uninitialized state.
* **Final Variables:** It is the primary mechanism for initializing `final` instance variables that require computation or parameter mapping before the constructor body executes.
* **Redirection Isolation:** If an initializer list contains a redirecting constructor call (`this(...)`), it cannot contain any other initializers.
## Syntax Mechanics
**Variable Assignment and Assertions**
The list can contain direct assignments to instance variables and `assert` statements for parameter validation.
```dart theme={"dark"}
import 'dart:math';
class Vector {
final double x;
final double y;
final double magnitude;
Vector(double x, double y)
: x = x,
y = y,
magnitude = sqrt(x * x + y * y),
assert(x >= 0 && y >= 0) {
// Body executes after x, y, and magnitude are set
}
}
```
**Superclass Delegation**
The initializer list is used to explicitly invoke a superclass constructor using `super(...)`. If omitted, Dart implicitly calls the superclass's unnamed, no-argument constructor.
```dart theme={"dark"}
class Vector3D extends Vector {
final double z;
Vector3D(double x, double y, double z)
: z = z,
super(x, y) {
// Body executes after z is set and Vector(x, y) completes
}
}
```
**Constructor Redirection**
When delegating to another constructor within the same class, the initializer list consists solely of the `this(...)` call.
```dart theme={"dark"}
class Vector {
final double x;
final double y;
Vector(this.x, this.y);
// Redirecting constructor
Vector.zero() : this(0.0, 0.0);
}
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
