How to Use Dart Switch Statements: A Beginner's Guide

Ever wondered how to control the flow of your program based on different conditions? In Dart, the switch statement is your friend. In this blog, we will delve into the dart switch statement and how it can be used to control the flow of your program.

What is a Dart Switch?

A Dart switch statement is a control flow statement that allows the program to evaluate an expression and execute different code blocks based on the value of the expression. The switch statement evaluates an expression against multiple possible values. If the switch expression matches a case value, the corresponding code block is executed.

Copy
switch (expression) {
  case value1:
    // Code block 1
    break;
  case value2:
    // Code block 2
    break;
  default:
    // Default code block
}

Understanding the Switch Statement

The switch statement evaluates an expression and compares it with the values of each case clause. If there is a match, the switch case associated with that value is executed. If no match is found, the default case is executed.

The Switch Expression

The switch expression is evaluated once. The value of the switch expression is compared with the values of each case. Only constants can be used as a case value in Dart, and each case must be unique.

Copy
var fruit = 'Apple';

switch (fruit) {
  case 'Apple':
    print('Apple is good for health');
    break;
  case 'Banana':
    print('Banana is rich in potassium');
    break;
  default:
    print('All fruits are good for health');
}

In this example, the switch expression is fruit, which is a variable with the value 'Apple'. The switch statement compares fruit with the case values 'Apple' and 'Banana'. Since fruit matches the case value 'Apple', it prints 'Apple is good for health'.

The Case Clauses

The case clauses in a switch statement specify the code block to be executed when the switch expression matches the case value. Each case clause ends with a break statement to prevent fallthrough to the next case.

The Default Case

The default case in a switch statement specifies the code block to be executed when the switch expression does not match any case value. It's like a guard clause for the switch statement.

Copy
var color = 'Yellow';

switch (color) {
  case 'Red':
    print('Red signifies danger');
    break;
  case 'Green':
    print('Green signifies go');
    break;
  default:
    print('Color not recognized');
}

In this example, the switch expression is color, which is a variable with the value 'Yellow'. The switch statement compares color with the case values 'Red' and 'Green'. Since the color doesn't match any of the case values, it executes the default case and prints 'Color not recognized'.

Dart Switch Case with Enum

In Dart, switch statements can be used with Enum. Enum in Dart is a special kind of class used to represent a fixed number of constant values.

Copy
enum Seasons { Spring, Summer, Autumn, Winter }

void main() {
  var season = Seasons.Summer;

  switch (season) {
    case Seasons.Spring:
      print('Spring is here');
      break;
    case Seasons.Summer:
      print('Summer is hot');
      break;
    default:
      print('It\'s either Autumn or Winter');
  }
}

In this example, we have an Enum Seasons with four constant values: Spring, Summer, Autumn, and Winter. We then create a variable season with the value Seasons.Summer. The switch statement compares season with the case values Seasons.Spring and Seasons.Summer. Since season matches the case value Seasons.Summer, it prints 'Summer is hot'.

Dart Switch Case with Exception Handling

In Dart, if a switch statement doesn't cover all possible values and doesn't include a default case, it results in a compile-time error. To handle this, we can use a default case to catch any invalid choice.

In this example, the switch expression is animal, which is a variable with the value 'Lion'. The switch statement compares animal with the case values 'Dog' and 'Cat'. Since animal doesn't match any of the case values, it executes the default case and prints 'Invalid choice'.

Dart Switch Case with Class

In Dart, switch statements can also be used with classes. However, the switch expression must return a constant value at compile time.

In this example, we have a class Vehicle with a final string field type. We then create a constant instance of Vehicle with the type 'Car'. The switch statement compares vehicle.type with the case values 'Car' and 'Bike'. Since vehicle.type matches the case value 'Car', it prints 'Car is a four wheeler'.

The Bottom Line!

The dart switch statement is a powerful tool for controlling the flow of your program. It allows you to evaluate an expression and execute different code blocks based on the value of the expression. Remember to always include a default case in your switch statements to handle any invalid choice and prevent compile-time errors.

var animal = 'Lion';

switch (animal) {
  case 'Dog':
    print('Dog is a pet');
    break;
  case 'Cat':
    print('Cat is a pet');
    break;
  default:
    print('Invalid choice');
}

class Vehicle {
  final String type;

  const Vehicle(this.type);
}

void main() {
  var vehicle = const Vehicle('Car');

  switch (vehicle.type) {
    case 'Car':
      print('Car is a four wheeler');
      break;
    case 'Bike':
      print('Bike is a two wheeler');
      break;
    default:
      print('Vehicle type not recognized');
  }
}