Operators & Control Flow

After this lesson you will be able to read ANY Dart expression and predict its exact value (including tricky cases like 7 << 2 or short-circuit skips), trace what a loop or a switch does step by step on paper before you ever run it, and choose the right control-flow tool (if-chain vs guard clause vs switch expression) for a given problem.

1. Operators

1.1 Arithmetic operators

Dart's basic arithmetic operators work on int and double (both are kinds of num):

Integer division ~/ throws the fractional part away by cutting toward zero: 17 ~/ 5 is 3 and -17 ~/ 5 is -3 (not -4). The two operators always fit together as a == (a ~/ b) * b + a.remainder(b). Dividing by zero follows different rules: / returns Infinity/NaN, but ~/ and % on ints throw.

The same thing as runnable Dart — every arithmetic operator on a = 17, b = 5, the negative-number cases, a double result, and a native 64-bit wrap-around (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: one arithmetic operator is O(1) whether the numbers are 5 or 10¹⁸; the only size limit is the 64-bit range (about ±9.22·10¹⁸ on native Dart) — a loop doing 10⁸ of them takes about a second.

The same thing as runnable Dart — what /, ~/ and % do when the divisor is zero (the // => lines are the exact output, checked by verify/d06.dart):

The same thing as runnable Dart — Dart's % next to the Java-style remainder method, the two defining identities, and the circular-index bug it prevents (the // => lines are the exact output, checked by verify/d06.dart):

1.2 Relational & equality operators — == vs identical

Relational operators (< <= > >=) compare order and return a bool. Equality is subtler: == asks "do these two things have equal value?" — and a class can define exactly what "equal value" means by overriding operator==. identical(a, b) asks a completely different question: "are these two variables pointing at the very same box in memory?"

Rule: whenever a class overrides == it must also override hashCode so that equal objects give equal hash codes (hash-based Set/Map rely on it) — the runnable Dart panel below does both.

The same thing as runnable Dart — relational operators, then == versus identical() on the same three Point variables as the animation (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: == on ints is O(1); a user-defined == costs as much as the comparison you write in it (here 2 field checks), and identical() is always O(1) because it compares one reference.

1.3 Logical operators & short-circuit evaluation

The same thing as runnable Dart — the three animated expressions, the null-guard idiom, and a call counter proving the right side was skipped (and that & does not skip) (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: short-circuiting saves the right side's cost entirely: in a() && b() with a() false, b() costs 0 steps — even if b() would have taken 10⁶.

1.4 Assignment, compound assignment, prefix vs postfix ++

The same thing as runnable Dart — postfix vs prefix, then every compound assignment on one variable (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: every x++ or x += n is O(1); a loop that runs it 10⁸ times takes about a second.

1.5 Conditional operator c ? a : b

A compact if/else that produces a value instead of running a branch of statements:

Reads as: "if age >= 18 is true, the whole expression's value is 'adult'; otherwise it's 'minor'." Use it only for simple, short expressions — nesting ? : inside another ? : quickly becomes unreadable.

1.6 Cascade .. and null-shorting cascade ?..

The same thing as runnable Dart — the same Order built with a cascade, a ?.. on a null receiver, and the equivalent code without a cascade (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: a cascade of k calls costs exactly the k calls — it is only a shorter way to write the receiver once, not a faster or slower one.

1.7 Type test operators — is, is!, as

is asks "is this object (also) of this type?" and returns a bool — and inside a branch where it's true, Dart's flow analysis promotes the variable so you can use type-specific members directly. as forcibly casts, throwing a runtime error if the object isn't actually that type.

2. Precedence & associativity

Type your own expression below (digits and + - * / only, e.g. 2+3*4-8/2) and watch Dart's exact evaluation order, including the int→double promotion that / causes.

Dart's operators from tightest (evaluated first) to loosest (evaluated last) — a simplified table of the ones in this lesson:

Note the difference from C/Java: in Dart the bitwise operators bind tighter than ==, so a & b == 0 means (a & b) == 0. When in doubt, add parentheses — they cost nothing and the next reader will thank you.

The same thing as runnable Dart — the page's expression 2+3*4-8/2 plus the associativity and precedence rules above, each checked (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: evaluating an expression with k operators takes k steps; the animation accepts at most 20 characters (at most 7 numbers of up to two digits, so every int result stays below 99⁷ ≈ 9.3·10¹³, well under 2⁵³ ≈ 9·10¹⁵, where the animation's JavaScript numbers and Dart's 64-bit ints agree exactly).

3. if / else if / else, guard clauses

Type a score (any integer, including out-of-range ones like -5 or 150) and watch which branch runs and why the others are skipped.

The same thing as runnable Dart — the guard clause and the if / else if chain on eight scores, including both out-of-range ones and both boundaries (75 and 50) (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: an if / else-if chain with k branches costs at most k comparisons — O(1) for a fixed grade table, and the same for 10⁷ calls (≈ 5·10⁷ steps).

4. Loops

4.1 for loops — init → condition → body → update

The same thing as runnable Dart — the animated loop, the zero-iteration loop, and a loop whose update steps by −3 (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: a loop of n passes costs n × (body cost): n = 10⁶ → about 10^-2 s, n = 10⁸ → about 1 s, n = 10¹⁰ → minutes (too slow). Nested loops multiply: two loops of 10⁴ = 10⁸ passes.

The same thing as runnable Dart — a formula for the pass count and the code that checks it (the // => lines are the exact output, checked by verify/d06.dart):

4.2 while and do-while

while checks the condition before every iteration (so it can run zero times). do-while checks it after the body, so the body always runs at least once, even if the condition was already false to begin with.

The same thing as runnable Dart — whileDemo(3) (normal) and whileDemo(0) (edge: the condition is false at once, the body never runs) (the // => lines are the exact output, checked by verify/d06.dart):

The same thing as runnable Dart — doWhileDemo(3) (same output as while) and doWhileDemo(0) (edge: the body still runs once with n=0 before the check discovers the condition is false) (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: the loops above run n passes for start = n: n ≤ 10⁸ is fine, n = 10¹⁰ is not.

4.3 for-in and forEach

The same thing as runnable Dart — for-in, forEach and indexed iteration (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: iterating a list of n items is O(n) — 10⁶ items ≈ 10^-2 s; indexed adds no extra pass, it just pairs each element with its 0-based index.

The same thing as runnable Dart — the pitfall and its fix, with the exact order in which the log fills (the // => lines are the exact output, checked by verify/d06.dart):

4.4 break and continue

The same thing as runnable Dart — continue on even numbers and break after 7, over i = 1…10 (the // => lines are the exact output, checked by verify/d06.dart):

continue skips the rest of this iteration's body and jumps to the next one; break exits the loop entirely, right now.

4.5 Labeled break in nested loops

For contrast, if line 5 said plain break; instead of break outer;, only the inner j loop would stop — the outer i loop would continue on to i=3. The panel below runs both versions side by side, plus a labeled continue:

The same thing as runnable Dart — break outer versus a plain break versus continue next (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: nested loops multiply: a 3×3 grid is 9 cells, a 10⁴×10⁴ grid is 10⁸ (≈ 1 s) — a labeled break can cut the work short the moment the answer is found.

4.6 Loop invariants — a preview

The same thing as runnable Dart — the invariant sum == (i−1)·i/2 checked before every pass, and the closed form n(n+1)/2 at the end (Dart is 0-indexed in lists, but this loop is 1-based: i is the number being added) (the // => lines are the exact output, checked by verify/d06.dart):

5. switch — statements & expressions with patterns

5.1 switch statement (Dart 3: no fall-through, no break needed)

Input size → what's feasible: a switch over a fixed set of cases costs a handful of comparisons (O(1)); even 10⁷ calls ≈ 10⁸ steps ≈ 1 s.

5.2 switch expression with relational & logical patterns

Try a score below (including out-of-range values) and watch Dart test each pattern from top to bottom until one matches:

The same thing as runnable Dart — gradeLabel on twelve scores, including every boundary (−1, 101, 90, 89, 75, 74, 50, 49) (the // => lines are the exact output, checked by verify/d06.dart):

5.3 switch expression with record patterns and when guards

5.4 Patterns — the basics

A pattern describes the shape of a value and, when the value matches, can pull parts of it into new variables. You have already used four kinds: relational (>= 90), logical (||, &&), record patterns ((var x, var y)) and the wildcard _. Three more cover most everyday code: a type pattern (String s), a list pattern ([var first, ...]) and the null constant pattern. Outside a switch you can use them to destructure (var (a, b) = (3, 4);) and with if (value case pattern).

The same thing as runnable Dart — destructuring, a switch over type/list/null patterns, and an if-case (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: matching a pattern is O(size of the pattern) — a list pattern [var first, ...] looks only at the first element, so it costs the same for 3 elements or 10⁶.

6. assert

7. How to trace code in your head (and on paper)

Method: (1) write one column per variable that exists, plus a column for what line is executing. (2) Start at the first line. (3) For every statement, write down which variables change and their new value — for a condition, write down true or false explicitly before deciding which branch to take. (4) Never skip a line, even ones that "obviously" do nothing surprising — that's exactly where bugs hide.

Worked example — trace sumOfDigits(129) from the interview bank by hand:

The same thing as runnable Dart — the same loop, printing one line per pass so you can compare it with the table row by row (the final line is the returned sum) (the // => lines are the exact output, checked by verify/d06.dart):

Input size → what's feasible: tracing by hand is for small inputs (n ≤ ~10 passes); for n = 10⁶ passes you let the computer run it and trust the invariant instead.

Quiz

Interview questions

Solve each one yourself first — write it on paper or in a scratch file — before opening the solution.

Cheat sheet