Skip to main content

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.

A switch expression in Dart is a control flow construct introduced in Dart 3 that evaluates a matched pattern directly into a return value. Unlike traditional switch statements that execute blocks of code, switch expressions are expressions themselves; they resolve to a single value and can be assigned to variables, passed as arguments, or returned directly from functions.

​
Syntax

The syntax of a switch expression diverges from a switch statement by omitting the case keyword, replacing the colon (:) with an arrow (=>), and separating the individual branches with commas. 
final variable = switch (target) {
  pattern1 => expression1,
  pattern2 => expression2,
  _ => defaultExpression,
};

​
Technical Characteristics

  • Exhaustiveness Checking: The Dart compiler strictly enforces exhaustiveness for switch expressions. Every possible value of the matched type must be handled. If the compiler cannot guarantee that all possible inputs are covered by the defined patterns, it throws a compile-time error.
  • Wildcard Pattern (_): To satisfy exhaustiveness when not all specific cases are explicitly defined, the underscore (_) is used as a wildcard pattern. It functions identically to the default clause in a switch statement.
  • No Implicit Fall-through: Switch expressions evaluate exactly one expression. There is no concept of execution falling through to subsequent cases, rendering break or continue keywords unnecessary and invalid within the expression body.
  • Single Expression Limitation: The right side of the arrow (=>) must be a single expression, not a block of statements.

​
Guard Clauses

Switch expressions support guard clauses using the when keyword. A guard clause attaches an arbitrary boolean expression to a pattern. The pattern only matches if both the pattern itself matches the target and the guard clause evaluates to true. 
final result = switch (responseCode) {
  int code when code >= 200 && code < 300 => 'Success',
  int code when code >= 400 && code < 500 => 'Client Error',
  _ => 'Unknown',
};

​
Pattern Matching Integration

Switch expressions are deeply integrated with Dart’s pattern matching system, allowing for complex evaluation logic directly within the switch body. Logical Patterns: You can use logical operators (||, &&) to combine multiple patterns into a single case. 
final status = switch (state) {
  'pending' || 'processing' || 'queued' => 0,
  'completed' => 1,
  'failed' => -1,
  _ => throw FormatException('Invalid state'),
};
Relational Patterns: Switch expressions can evaluate relational operators directly against the target value without needing to bind the target to a variable first. 
final category = switch (temperature) {
  < 0 => 'Freezing',
  >= 0 && <= 25 => 'Moderate',
  > 25 => 'Hot',
  _ => 'Unknown', // Always required: the exhaustiveness checker does not evaluate mathematical ranges
};
Object and Record Destructuring: Switch expressions can destructure objects, records, and collections, extracting properties and evaluating them simultaneously. 
final description = switch (pointRecord) {
  (0, 0) => 'Origin',
  (int x, 0) => 'X-axis at $x',
  (0, int y) => 'Y-axis at $y',
  (int x, int y) => 'Point at $x, $y',
};
Master Dart with Deep Grasping Methodology!Learn More