if, else and loops: for, while and do-while

A program that only runs its lines top to bottom cannot react to anything. Control flow gives it choices: if and else pick which block runs, the conditional expression ? : picks a value, and four loops repeat work, for and for-in for a known number of turns and while and do-while until something changes.

You will write an if/else chain and a conditional expression, loop over a list and a map, leave a nested loop with a labelled break, see why three closures made in one loop return 0, 1 and 2 rather than 3, 3, 3, repair the error Dart throws when a list changes mid-loop, and learn why assert guards nothing in an ordinary run.

if, else and the conditional expression

branches.dart writes the classic FizzBuzz for 1 to 15 with an if/else-if chain, then picks a greeting with a conditional expression:

import 'dart:io';

// FizzBuzz from 1 to 15 with an if/else-if chain, then a conditional expression.
void main() {
  for (var n = 1; n <= 15; n++) {
    String say;
    if (n % 15 == 0) {
      say = 'FizzBuzz';
    } else if (n % 3 == 0) {
      say = 'Fizz';
    } else if (n % 5 == 0) {
      say = 'Buzz';
    } else {
      say = '$n';
    }
    stdout.write('$say ');
  }
  stdout.writeln();

  // An if is a statement and runs code; to choose a value, use the conditional
  // expression condition ? a : b, which an assignment can hold.
  const hour = 14;
  final greeting = hour < 12 ? 'Good morning' : 'Good afternoon';
  print(greeting);
}

1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 
Good afternoon

The first line printed 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz: each number ran exactly one branch, the first whose test was true, so 15 printed FizzBuzz because n % 15 == 0 was tested first. Every body is wrapped in braces, which Effective Dart’s style guide asks for on all flow-control statements; the one case it allows without them is a short if with no else written on a single line.

An if is a statement: it runs a block, but it is not a value, so you cannot assign the result of an if to a variable. To choose a value, Dart has the conditional expressionconditional expression: Dart's test ? a : b operator: an expression with a value, which evaluates a when test is true and b when it is false. Unlike an if statement, its result can be assigned or returned. condition ? a : b, which is an expression and does have a value. Here hour < 12 ? 'Good morning' : 'Good afternoon' gave greeting its value, and with hour set to 14 the program printed Good afternoon. The table sets the two tools side by side:

for, for-in, while and do-while

loops.dart runs all four loops, and shows how for-in reads a list and a map:

import 'dart:io';

// The four loops, and how for-in reads a List and a Map.
void main() {
  // A counting for loop, with its own loop variable i.
  for (var i = 1; i <= 3; i++) {
    stdout.write('for $i; ');
  }
  stdout.writeln();

  // for-in reads any Iterable, one element at a time.
  final cities = ['Pune', 'Kochi', 'Agra'];
  for (final city in cities) {
    stdout.write('$city; ');
  }
  stdout.writeln();

  // A Map is not an Iterable; loop over its .entries.
  final prices = {'tea': 10, 'coffee': 25};
  for (final entry in prices.entries) {
    stdout.write('${entry.key}=${entry.value}; ');
  }
  stdout.writeln();

  // while tests before the body, so it may run zero times.
  var left = 3;
  while (left > 0) {
    stdout.write('while $left; ');
    left--;
  }
  stdout.writeln();

  // do-while tests after the body, so the body always runs once.
  var tries = 3;
  do {
    stdout.write('do $tries; ');
    tries++;
  } while (tries < 3);
  stdout.writeln();
}

// stdout.write needs dart:io.

for 1; for 2; for 3; 
Pune; Kochi; Agra; 
tea=10; coffee=25; 
while 3; while 2; while 1; 
do 3; 

The counting for printed for 1; for 2; for 3;: it declares a loop variable, tests it before each turn, and updates it after. for-in reads any IterableIterable: A sequence a Dart for-in loop reads one element at a time, such as a List or a Set; its type is Iterable. A Map is not one, so you loop over its entries, keys or values. one element at a time, so it printed the three cities in order. A Map is not an Iterable, so you loop over its .entries, which is why prices.entries printed tea=10; coffee=25;. The patterns module adds a shorter form, for (final MapEntry(:key, :value) in map.entries), that names the key and value directly.

The last two loops differ only in when they test. while tests before the body, so it printed while 3; while 2; while 1; and then stopped. do-while tests after the body, so the body always runs once: with tries starting at 3, the condition tries < 3 was already false, yet do 3; still printed. Reach for do-while when the first turn must happen whatever the condition says, such as reading input before checking whether to read more.

break, continue and labels

break leaves the nearest loop and continue skips to its next turn, but a nested loop often needs to leave the outer one. A label makes that one statement. labels.dart searches a price list for the first pair that adds up to a budget, and a labelled break stops both loops at the first hit:

// A label lets break leave the outer loop at once, not just the inner one.
void main() {
  final prices = [120, 250, 80, 400, 170];
  const budget = 330;

  var found = false;
  search:
  for (var i = 0; i < prices.length; i++) {
    for (var j = i + 1; j < prices.length; j++) {
      if (prices[i] + prices[j] == budget) {
        print('prices[$i] + prices[$j] = ${prices[i]} + ${prices[j]} = $budget');
        found = true;
        break search;
      }
    }
  }
  if (!found) print('no pair adds up to $budget');
}

prices[1] + prices[2] = 250 + 80 = 330

The program printed prices[1] + prices[2] = 250 + 80 = 330 and stopped: without the label, break would have left only the inner loop, and the outer loop would have gone on comparing. continue search works the same way for the outer loop’s next turn. The label is a name written before a loop with a colon, and break or continue names it.

A fresh loop variable on every turn

A loop variable looks like one variable that changes, but Dart gives each turn of a for loop its own copy. That matters the moment a closure captures it. capture.dart adds three closures to a list, each returning the loop variable, then calls them:

// Each turn of a Dart for loop gets its own i, so each closure keeps a
// different one. In JavaScript, var would share one i and print [3, 3, 3].
void main() {
  final callbacks = <int Function()>[];
  for (var i = 0; i < 3; i++) {
    callbacks.add(() => i);
  }

  final results = <int>[];
  for (final f in callbacks) {
    results.add(f());
  }
  print(results);
}

[0, 1, 2]

The program printed [0, 1, 2], not [3, 3, 3]. Each closure kept the i of its own turn, so calling them later read three different values. Step through what each closure refers to:

JavaScript’s var behaves the other way: it is function-scoped, so one i is shared by every turn and three closures would all read the final value. Dart’s for gives a fresh binding each turn, which is why the list came out [0, 1, 2]. The lesson on closures and function types uses this to build counters that keep their own state.

Changing a list while you loop over it

A for-in loop expects the list it reads to hold still. concurrent.dart removes items from a list while it loops over it, and Dart stops the program:

// Removing from a list while a for-in reads it throws at run time.
void main() {
  final nums = [1, 2, 3, 4, 5, 6];
  for (final n in nums) {
    if (n.isEven) nums.remove(n);
  }
  print(nums);
}

Unhandled exception:
Concurrent modification during iteration: Instance(length:5) of '_GrowableList'.
#0      ListIterator.moveNext (dart:_internal/iterable.dart:366:7)
#1      main (concurrent.dart:4:19)
#2      _delayEntrypointInvocation.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:313:19)
#3      _RawReceivePort._handleMessage (dart:isolate-patch/isolate_patch.dart:192:12)

The program threw Concurrent modification during iteration and ended with status 255, the status Dart uses for an unhandled exception. The iterator noticed that the list’s length changed under it and refused to go on, rather than skip or repeat elements silently. The fix is to decide what to remove without looping by hand. removeWhere.dart does the same job in one call:

// removeWhere deletes matching elements in one pass, with no loop to disturb.
void main() {
  final nums = [1, 2, 3, 4, 5, 6];
  nums.removeWhere((n) => n.isEven);
  print(nums);
}

[1, 3, 5]

It printed [1, 3, 5]. removeWhere takes a test and deletes every element that passes it, with no loop of your own to disturb. When you do need a loop, iterate over a copy, for (final n in [...nums]), and change the original inside it.

assert checks only when it is turned on

assert states something you believe is always true, so a broken belief is caught early. But it runs only when assertions are enabled. asserts_session.py runs one file twice, first with a plain dart run and then with --enable-asserts:

from session import files, run

# The same file run twice: plain dart run skips assert, --enable-asserts checks it.
files("asserts.dart")
run(
    """
dart run asserts.dart
!dart run --enable-asserts asserts.dart
"""
)

$ dart run asserts.dart
fee is -10
$ dart run --enable-asserts asserts.dart
Unhandled exception:
'file://~/demo/asserts.dart': Failed assertion: line 4 pos 10: 'fee >= 0': fee must not be negative
#0      _AssertionError._doThrowNew (dart:core-patch/errors_patch.dart:67:4)
#1      _AssertionError._throwNew (dart:core-patch/errors_patch.dart:49:5)
#2      main (file://~/demo/asserts.dart:4:10)
#3      _delayEntrypointInvocation.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:313:19)
#4      _RawReceivePort._handleMessage (dart:isolate-patch/isolate_patch.dart:192:12)
[exit status 255]

Plain dart run asserts.dart printed fee is -10: the assert(fee >= 0, …) did nothing, even though the fee was negative. With --enable-asserts the same file threw Failed assertion: line 4 pos 10: 'fee >= 0': fee must not be negative and ended with status 255. Flutter enables assertions in debug mode, and development-only tools usually enable them by default; in production code they are ignored, which is why a plain dart run and a compiled executable walked past the check.

Practise: two functions with loops only

Write two functions using loops, not collection helpers, so the mechanics stay in view.

1. List<String> multiplicationTable(int n, {int upTo = 10}) returns the lines 1 x n = n up to upTo x n, built with a for loop.
2. int? firstRepeated(List<int> xs) returns the first value that has already been seen, or null when every value is unique; use a loop and a Set you fill as you go.
3. Run your file with dart run, then try multiplicationTable(7, upTo: 3) and firstRepeated([4, 2, 4, 7]): you should get three lines and 4.
4. Check the edges: multiplicationTable(5, upTo: 0) should give an empty list, and firstRepeated([]) should give null.

When both behave, the self-check revisits every section:

Interview questions

Warm-up (fresher): Which Dart loop always runs its body at least once, and when would you use it?

do-while runs its body first and tests the condition afterwards, so the body runs at least once however the condition starts; in loops.dart the do body printed do 3; even though its tries < 3 test was already false. while and for test before the body, so they can run zero times. Reach for do-while when the first turn must happen whatever the test says: read one line of input and then decide whether to read more, roll a die once and then decide whether to roll again, show a prompt and then decide whether to show it again. For anything that might not run at all, a while or a for reads more plainly.

Two interview questions in the bank push these loop ideas into production debugging:

Key takeaways

• if and else run one block or another, while the conditional expression test ? a : b is a value you can assign; wrap every flow-control body in braces so a stray statement is never left unguarded.
• for counts, for-in reads any Iterable (a map through its .entries), while tests before the body and do-while tests after it, so a do-while body always runs once.
• A label before a loop lets break leave an outer loop and continue move to its next turn; since Dart 3.0 a continue must target a loop or a switch member.
• Each turn of a for loop gets its own loop variable, so three closures made in one loop returned [0, 1, 2], where JavaScript’s shared var would give [3, 3, 3].
• Changing a list inside its own for-in throws Concurrent modification during iteration; use removeWhere or loop over a copy, and keep assert for development bugs, never for validating input a released program must reject.