Conditionals in Julia

Analogy categoryAnalogies

How Julia Evaluates Conditions

Julia requires that the condition in an if statement evaluate strictly to a Bool — unlike Python or JavaScript, values like 0, "", or nothing are not automatically "truthy" or "falsy". Trying if 1 ... end throws a TypeError: non-boolean used in boolean context. This strictness catches bugs early, because a stray integer where a boolean was expected fails loudly instead of silently taking the wrong branch.

🏏

Cricket analogy: A third umpire reviewing a run-out doesn't accept 'probably out' — the decision must be a hard OUT or NOT OUT before it's relayed, just as Julia refuses to treat a stray integer as an implicit true or false.

if / elseif / else as an Expression

Because if/elseif/else is itself an expression in Julia, the value of whichever branch executes becomes the value of the whole block, so you can write x = if a > b; a; else; b; end instead of a separate assignment in each branch. Blocks are closed with a matching end rather than braces or significant indentation, and parentheses around the condition are optional — if a > b reads more idiomatically than if (a > b).

🏏

Cricket analogy: A DRS review doesn't just say out/not-out — it returns which decision stands so the scoreboard updates immediately, similar to how Julia's if block returns the value of whichever branch ran rather than requiring a separate assignment step.

For a simple two-way choice, the ternary operator cond ? a : b is more compact than a full if/else and is idiomatic for short inline expressions, such as abs_x = x >= 0 ? x : -x. Julia requires whitespace around both ? and : — cond?a:b fails to parse — and while ternaries can be nested, doing so more than one level typically hurts readability more than it saves typing.

🏏

Cricket analogy: Deciding to bowl or bat first after winning the toss is a single quick call captains make on the spot, much like the ternary operator packs a whole if/else decision into one compact line: bat_first ? "field" : "bat".

Short-Circuit Evaluation with && and ||

The && and || operators short-circuit: in a && b, b is only evaluated if a is true, and in a || b, b is only evaluated if a is false. Beyond combining conditions, this makes them a compact idiom for guard clauses, such as n >= 0 || throw(ArgumentError("n must be non-negative")), which raises an error only when the guard fails. Julia style generally reserves this pattern for simple checks and argument validation, preferring an explicit if when a branch has multiple side effects.

🏏

Cricket analogy: A bowler only gets to bowl the next over if the previous over didn't get them taken off for economy reasons — the second condition is never even checked if the first already fails, just like a && b skips evaluating b when a is false.

Both operands of && must ultimately resolve to booleans when used for control flow; unlike some languages, Julia does not treat empty collections, zero, or nothing as falsy — always compare explicitly, e.g., isempty(v) rather than relying on v being falsy.

Chained and Element-wise Comparisons

Julia supports chained comparisons like 0 <= x < 100, which is evaluated as 0 <= x && x < 100 without evaluating x twice, making range checks concise. Applying && or || directly to arrays is an error, since arrays aren't single Bool values; instead, use the dotted broadcast operators .==, .<, .&, and .| to compare and combine boolean arrays element-wise, as in mask = (data .> 0) .& (data .< 100).

🏏

Cricket analogy: Checking whether a batter's strike rate falls between 100 and 150 for the whole top order at once — not one player at a time — is like using Julia's .==/.< broadcast comparisons across an entire array of scores instead of one value.

julia

function classify_grade(score::Real)
    grade = if score >= 90
        "A"
    elseif score >= 80
        "B"
    elseif score >= 70
        "C"
    else
        "F"
    end
    return grade
end

# Ternary + short-circuit guard clause
abs_x(x) = x >= 0 ? x : -x
validate(n) = n >= 0 || throw(ArgumentError("n must be non-negative"))

# Chained comparison and element-wise mask
in_range = 0 <= 42 < 100          # true
data = [-5, 10, 55, 120, 30]
mask = (data .> 0) .& (data .< 100)   # BitVector: [0,1,1,0,1]

Never compare floating-point results with ==. Because of rounding error, 0.1 + 0.2 == 0.3 evaluates to false in Julia. Use isapprox(a, b) or the ≈ operator (typed \\approx<TAB>), optionally with an explicit atol or rtol tolerance.

Julia if conditions must evaluate to a genuine Bool — no implicit truthiness for 0, "", or nothing.
if/elseif/else is an expression and returns the value of the taken branch.
The ternary operator cond ? a : b requires spaces around ? and : and is best kept to one level of nesting.
&& and || short-circuit, making them handy for guard clauses like n >= 0 || throw(...).
Chained comparisons like 0 <= x < 100 avoid re-evaluating x.
Use the dotted .==, .<, .&, .| operators to compare and combine arrays element-wise.
Never use == to compare floats; use isapprox or ≈ instead.