Fluttering Dart

Fluttering Dart: The Flow

All about the control flow statements

Flutter projects can use both platform-specific and cross-platform code. The latter is written in Dart, and, for building Flutter apps, some basic knowledge of Dart is required.

Fluttering Dart’s goal is to explore fundamental knowledge and unveil tips & tricks of the powerful programming language that brings Flutter to life.

In the previous parts of the series, we went through the Dart built-in data types, functions and operators.

In this part, we’ll discover how to write and use control flow statements.

Some of the code examples can be tried out, and played with, using DartPad.

Control flow statements

If you're coming from another imperative programming language, you'll be familiar with control flow statements available in Dart.

There are the conditional statements: if — else and switch — case, and the iterative statements: for, for — in, forEach, while and do — while loops. There are also some ”helper” statements: break, continue and assert. Don’t forget that we’ve also discussed the try — catch and throw statements a while back when we talked about functions.

Conditional statements

These are used to decide actions (more specific the execution of code) based on meeting/matching certain boolean conditions.

Dart supports if statements with optional else elements:

if(myCat.meowing) {
  feed(myCat);
} else if(!myCat.sleepy) {
  pet(myCat);
} else {
  // don't disturb the cat
  takePicturesOf(myCat);
}

If you remember the conditional operator, it’s pretty much a shorthand notation of an if — else statement ( condition ? expr1 : expr2 ).

A one liner of the above example is:

myCat.meowing ? feed(myCat) : ( !myCat.sleepy ? pet(myCat) : takePicturesOf(myCat) );

We should not code this way because is way less readable.

Conditions must use only boolean values (bool typed objects or expressions that evaluation returns bool).

Switch statements can compare integer, string or compile-time constants, using ==. Compared objects must be all of the same class, with no overriding of the == operator. Enumerated types fit like a glove when used with switch statements:

enum CatMoods = {meowing, sleepy, playful, curious, angry};

switch(myCat.mood) {
  case meowing:
    feed(myCat);
    break;
  catAngerManagement:  
  case playful:
  case curious:
    pet(myCat);
    break;
  case angry:
    continue catAngerManagement
  case sleepy:
    continue;
  default:
    takePictures(myCat);
}

Using enums in switch statements forces you to handle all possible cases.

A non-empty case clause usually ends with a break statement. It can also end with continue, throw, or return. Not ending such clause will generate an error.

As we can see in the example above, Dart also supports empty case clauses (case playful:). There is also an interesting continue to custom label (catAngerManagement).

Any local variable declared inside a case statement is visible only in the scope of that clause.

Notice that the switch statements are not as flexible as we’d expect and that is because they are intended for limited circumstances, such as in interpreters or scanners.

Loop statements

Loops allow us to run a block of code multiple times. Doing so, we reuse code.

Running a dedicated amount of times is possible using the for loop:

import 'dart:math';

void weirdMeow() {

  var meow = StringBuffer('M');

  var random = Random.secure();
  
  List<String> meows = <String>['m','e','o', 'w'];
  
  meows.forEach((String m) {
    int l = 1 + random.nextInt(5);
    for (int i = 0; i < l; i++) {
      meow.write(m);
    }
  });
  print('$meow!');
  // prints something like:
  // Mmmmmeeeeeoooooww!

}

Above, we’ve defined the weirdMeow function that will produce, each time, a different meow. For that we use a random generator and two flavors of the for loop: for and forEach.

The latter is available for an Iterable object. Using forEach() is useful when we don’t need to know the iteration counter.

Iterable objects also support the third flavor of the for loop, for — in. The above forEach example becomes:

// ...
for(String m in meows) {
  int l = 1 + random.nextInt(5);
  for(int i = 0; i < l; i++) {
    meow.write(m);
  }
}
// ...

Multiple iterations are also possible using the while loop. There are two flavors of that:

• simple while loop - that evaluates the condition before the loop, and runs zero to any number of times it takes for the condition to be met
• and a do — while loop - which evaluates the condition after the loop, running at least once

// simple while
while(isTooDark()) {
  bringUpTheLevelOfLightBy(10); 
}

// do-while
do {
   bringUpTheLevelOfLightBy(10);
} while(isTooDark());

The simple while will bring up the level of light only if its too dark, compared to the do — while, which will will bring up the level of light at least by 10, no matter what.

Break and continue are used to stop looping, or respectively, skip to the next loop iteration.

<Cat>List cats = <Cat>[simba, micuta, klein, saki];

for(Cat currentCat in cats) {
  if(!currentCat.isHungry) {
    continue;
  }
  feed(currentCat);
}

In the previous example, we’ll iterate through our cats and feed only the ones that are hungry. The others, we skip.

During development we can use the assert statement with the following syntax:

assert(condition, optionalMessage);

We’ve already used it many times in our Fluttering Dart journey for disrupting normal execution if the boolean condition is false.

If the expression’s value is true, the assertion succeeds and execution continues. If it’s false, the assertion fails and an exception.

Flutter enables assertions in debug mode, while tools such as dart2js (used to build for the web platform) support assertions through a command-line flag --enable-asserts.

In production code, assertions are ignored, and the arguments to assert aren’t evaluated

In the next part of the Fluttering Dart series, we’ll delve into classes, objects and other object-orientated programming aspects of Dart.

Tha(nk|t’)s all!