Skip to main content
The switch construct evaluates a governing expression against a series of patterns to determine control flow or compute a result. It supports both statement syntax for imperative control flow and expression syntax for functional value assignment.

​
Switch Statements

A switch statement executes the block of code associated with the first matching pattern. 
switch (variable) {
  case pattern1:
    // Executed if variable matches pattern1
    statement();
    // Implicit break occurs here
  case pattern2:
    statement();
  default:
    statement();
}

​
Pattern Matching Logic

case clauses utilize pattern matching to validate the governing expression. The matching logic depends on the pattern type:
  • Constant Patterns: Compare the governing expression to a constant (e.g., case 1:, case 'A':) using the == operator.
  • Relational Patterns: Compare values using operators (e.g., case > 10:).
  • Object and List Patterns: Validate structure and types, allowing for destructuring (e.g., case [int a, int b]:).
  • Logical Patterns: Combine multiple patterns using logical operators (e.g., case 200 || 201:).

​
Guard Clauses

A case clause may include an optional guard clause using the when keyword. The case matches only if the pattern matches the value and the guard expression evaluates to true. 
switch (response) {
  case [int a, int b] when a > b:
    print('First element is larger');
}

​
Control Flow Rules

Dart enforces specific rules regarding how execution moves through switch statements:
  • Implicit Break: Non-empty case clauses automatically break at the end of their block. Explicit break statements are optional and generally unnecessary unless exiting a case early.
  • No Fall-through for Non-empty Cases: If a case body contains statements, execution does not fall through to the next case.
  • Fall-through for Empty Cases: Dart allows fall-through only for empty case clauses, allowing multiple patterns to share the same body.
switch (status) {
  case 'PENDING':
  case 'LOADING': // Falls through to 'PROCESSING'
  case 'PROCESSING':
    showSpinner();
}
  • Labels and Continue: To explicitly transfer control from one non-empty case to another, use a label and the continue statement.
switch (stage) {
  case 1:
    prepare();
    continue step2; // Jumps to the label
  step2:
  case 2:
    execute();
}

​
Switch Expressions

Dart supports switch as an expression, producing a value directly. This syntax uses the arrow (=>) instead of the colon (:) and case keyword. Unlike statements, switch expressions require commas separating the cases. 
var description = switch (day) {
  'Mon' => 'Start of work week',
  'Fri' => 'End of work week',
  _ => 'Mid-week', // Wildcard pattern acts as default
};

​
Exhaustiveness Checking

Dart enforces exhaustiveness checking for both switch statements and expressions when the governing expression’s type is “exhaustible” (e.g., enum, bool, or sealed classes).
  • Requirement: Every possible value of the exhaustible type must be covered by a case.
  • Enforcement: Missing a case for a known value in an exhaustible type results in a compile-time error.
  • Wildcards: The wildcard pattern (_) or a default clause can be used to cover remaining cases for non-exhaustible types (like int or String) or to handle future additions to an enum.
When matching against a sealed class hierarchy, direct subtypes must be declared base, final, or sealed. 
sealed class Shape {}
final class Square implements Shape {}
final class Circle implements Shape {}

void calculate(Shape shape) {
  switch (shape) {
    case Square():
      print('Square');
    case Circle():
      print('Circle');
    // No default needed; all subtypes are handled, satisfying exhaustiveness.
  }
}
Master Dart with Deep Grasping Methodology!Learn More