Arithmetic and Comparison Operators
Julia's arithmetic operators are what you'd expect — +, -, *, / — plus a few numeric-computing specifics: ÷ (typed \div<Tab>, or the function div) performs integer (truncating) division, % computes the remainder, and ^ is exponentiation, so 2^10 is 1024 and 7 ÷ 2 is 3 while 7 / 2 is 3.5. Comparison operators (==, !=, <, <=, >, >=) can be chained the way mathematical notation allows, so 0 < x < 10 correctly checks both bounds in one expression instead of requiring 0 < x && x < 10.
Cricket analogy: It's like the distinction between overs bowled (a truncating count — you can't bowl 6.5 overs, only whole ones plus balls) and average runs per over (a true division that keeps the decimal) — Julia's ÷ mirrors the whole-overs count while / mirrors the runs-per-over average.
Broadcasting with the Dot Syntax
The dot syntax — appending . to any function or operator — broadcasts it elementwise across arrays (or any iterable), so [1, 2, 3] .+ 1 yields [2, 3, 4] and sin.(x) applies sin to every element of the array x without writing an explicit loop. This is more than syntactic sugar for convenience: Julia's compiler fuses chains of broadcasted operations like y = sin.(x) .+ cos.(x) .^ 2 into a single loop with no intermediate array allocations, so broadcasting is often the idiomatic, high-performance way to write vectorized code rather than a slow shortcut.
Cricket analogy: It's like a fielding coach giving one instruction — 'move two steps in' — to every fielder simultaneously rather than walking to each individually — Julia's .+ broadcasts one operation to every array element at once, the way one shouted call reaches the whole field.
Logical Operators and Short-Circuit Evaluation
&& and || are short-circuiting: in a && b, b is only evaluated if a is true, and in a || b, b is only evaluated if a is false — which Julia idiom exploits for control flow, as in x > 0 || error("x must be positive"), where error only runs (and throws) when the condition is false. This differs from the elementwise, non-short-circuiting & and | bitwise operators, which are used specifically for broadcasting over Boolean arrays, such as (x .> 0) .& (x .< 10) to build a combined elementwise mask.
Cricket analogy: It's like an umpire only consulting the third umpire for a run-out review if the on-field decision is genuinely unclear — the second check (b) in a && b only happens if the first condition (a) leaves it necessary, exactly like short-circuit evaluation skipping unneeded work.
Expressions and the Ternary Operator
Julia is expression-oriented: if/else blocks, for loops, and even begin...end blocks all evaluate to a value (the value of their last executed line), which is why the ternary operator cond ? a : b is really just syntax for a compact if cond; a; else; b; end — status = age >= 18 ? "adult" : "minor" assigns directly from the branch taken. This expression-oriented design lets you write things like y = if x > 0; 1; else; -1; end naturally, and it underlies why a function's return value defaults to whatever its last expression evaluates to, without needing an explicit return.
Cricket analogy: It's like a match's result being decided directly by whichever team's final delivery outcome settles it — no separate 'announce the winner' step needed — the ternary cond ? a : b directly produces the result of whichever branch runs, with no separate assignment step required.
Operators Are Just Functions
Every infix operator in Julia is ordinary syntax sugar for a function call — 1 + 2 is exactly equivalent to +(1, 2), and you can call + like any other function or even pass it as a value, e.g. reduce(+, [1, 2, 3, 4]) to sum a list. Because operators are just functions, you can extend them for your own types using multiple dispatch: defining import Base: +; +(a::Point, b::Point) = Point(a.x + b.x, a.y + b.y) teaches Julia how + should behave for two Point values, letting user-defined types participate in ordinary arithmetic syntax.
Cricket analogy: It's like a field-placement call actually being shorthand for a captain's instruction to one fielder — 1 + 2 is shorthand for calling +(1, 2), and just as a captain can redefine who covers a role, Julia lets you redefine what + does for your own types.
# Arithmetic and comparison
println(7 ÷ 2, " ", 7 / 2, " ", 7 % 2) # 3 3.5 1
println(0 < 5 < 10) # true (chained comparison)
# Broadcasting: elementwise ops with the dot syntax
x = [1, 2, 3, 4]
y = sin.(x) .+ cos.(x) .^ 2 # fused, no intermediate arrays
# Short-circuit control flow idiom
x = -3
x > 0 || error("x must be positive")
# Ternary operator (an expression, returns a value)
status = x >= 0 ? "non-negative" : "negative"
# Operators are functions
reduce(+, [1, 2, 3, 4]) # 10, same as +(1,+(2,+(3,4)))You can inspect any operator as a first-class function: methods(+) at the REPL lists every type combination + currently knows how to handle, which is a fast way to discover what arithmetic Julia supports out of the box for a given type.
/ in Julia always returns a floating-point result, even for two integers (4 / 2 is 2.0, not 2) — use ÷ (or div) when you specifically need truncating integer division, since mixing this up is a common source of subtle type-instability bugs.
÷performs truncating integer division while/always returns a floating-point result, even for integer operands.- Comparisons can be chained mathematically, e.g.
0 < x < 10, evaluating both bounds in one expression. - The dot syntax (
.) broadcasts any function or operator elementwise across arrays, and Julia fuses chained broadcasts into one allocation-free loop. &&and||short-circuit, only evaluating their second operand when necessary — a common idiom for guard clauses likex > 0 || error(...).- Julia is expression-oriented: if/else blocks and the ternary
cond ? a : bboth evaluate to a value that can be assigned directly. - Operators are ordinary functions (
1 + 2 == +(1, 2)), which is why you can extend+and other operators for your own types via multiple dispatch.
Practice what you learned
1. What does `7 ÷ 2` evaluate to in Julia?
2. What does the dot syntax (e.g., `sin.(x)`) do when `x` is an array?
3. In `a && b`, when is `b` evaluated?
4. What does `1 + 2` actually desugar to in Julia?
5. What does `status = x >= 0 ? "non-negative" : "negative"` demonstrate about Julia?
Was this page helpful?
You May Also Like
Julia Variables and Types
How Julia's dynamic variables work, how its type hierarchy of abstract and concrete types is organized, and why type stability drives performance.
What Is Julia?
An introduction to Julia as a high-performance, dynamically typed language for scientific computing, and the problem it was built to solve.
Your First Julia Script
How to write, structure, and run a complete Julia script — from functions and control flow to I/O and the standalone-vs-library entry-point convention.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics