> ## 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 Assert Statement
An `assert` statement is a debugging and validation construct that evaluates a boolean expression, immediately halting execution or compilation if the expression evaluates to `false`. Depending on the context, a failed assertion either throws an `AssertionError` at runtime or triggers a compile-time error.
## Syntax
```dart theme={"dark"}
assert(condition, [message]);
```
## Parameters
* **`condition`**: A required expression that must evaluate to a `bool`. If the condition evaluates to `true`, execution proceeds normally. If `false`, the assertion fails and throws an `AssertionError`. In Dart, an `AssertionError` is a subclass of `Error` (representing a programming mistake that should not be caught), strictly distinct from an `Exception`.
* **`message`**: An optional second argument of type `Object?`. If provided, it is evaluated and passed directly to the `AssertionError` constructor, where it is stored in the `message` property to provide specific context regarding the failure.
## Constructor Initializer Lists
Dart permits the use of `assert` statements directly within a constructor's initializer list. This syntactic feature allows for the validation of constructor parameters before the constructor body executes or the object is fully instantiated.
```dart theme={"dark"}
class Point {
final int x;
final int y;
Point(this.x, this.y) : assert(x >= 0, 'x must be a non-negative integer');
}
```
## Compilation and Evaluation Behavior
The Dart compiler handles `assert` statements differently depending on the build environment and the instantiation context:
* **Debug Mode**: Assertions are actively evaluated at runtime. In the standalone Dart VM, they are enabled using the `--enable-asserts` command-line flag. Frameworks like Flutter enable them by default during standard debug builds.
* **Release Mode**: The compiler omits `assert` statements from the final generated executable code, ensuring they incur zero CPU or memory overhead in production binaries. However, the compiler still parses and type-checks the expressions inside `assert` statements. A syntax or type error within an `assert` will still break a release build.
* **Compile-Time Constant Evaluation**: When an `assert` is used in a `const` constructor to create a compile-time constant, it is evaluated at compile time. If the condition evaluates to `false` during const evaluation, it halts compilation and produces a compile-time error.
## Code Examples
```dart theme={"dark"}
void main() {
int port = 8080;
// Standard runtime assertion
assert(port >= 1024);
// Assertion with an optional message
assert(port <= 65535, 'Port number $port is out of the valid range.');
}
// Compile-time assertion in a const constructor
class Config {
final int timeout;
const Config(this.timeout) : assert(timeout > 0, 'Timeout must be positive');
}
// Evaluates to false at compile time, halting compilation with an error:
// const Config invalidConfig = Config(-1);
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
