Operators in JavaScript: think like the engine to make better decisions

Master arithmetic, comparison, logical and assignment operators so you can build reliable conditions, avoid coercion bugs and write clearer business rules.

How much do you know about JavaScript?

📘 Theory

A mental map: which operator to use and when

Choosing the right operator leads to predictable decisions in your code.

Not all operators solve the same problem. Some calculate, some compare, some combine conditions and others update values with clear intent.

If you internalize that classification, it becomes much easier to build clean logic instead of chaining patches together.

Arithmetic

They transform numbers.

+, -, *, /, %
Prices, tax, discounts, averages

Comparison

They answer with `true` or `false`.

===, !==, >, =, =
Useful in validation and access rules

Logical

They combine conditions.

&&, ||, !
Permission systems and compound filters

Assignment

They update state quickly.

=, +=, -=, *=, /=
Counters and accumulators

Arithmetic plus compound assignment: calculate without noise

Fewer lines, the same clarity, no magic.

In real projects you constantly update totals, counters and balances. That is where compound operators such as `+=` and `-=` shine.

Use them when the purpose is explicit: accumulate, subtract or increment. If the expression becomes too dense, split it into intermediate variables so readability stays high.

`%` helps with cyclical patterns such as shifts, even and odd rows, or pagination.
`++` and `--` are convenient, but avoid hiding them inside long expressions.
If money is involved, round at the end with formatting tools.

Comparisons without surprises: strict by default

`===` and `!==` are your safety net.

With `==`, JavaScript converts types to try to make the comparison work. In real business logic, that behavior usually adds noise instead of helping.

The professional rule is simple: use `===` and `!==` unless there is a very specific and justified reason not to.

Logical operators and short-circuit behavior

They do more than combine conditions. They also help with fallbacks and guarded logic.

`&&` returns the first falsy value or the last truthy one. `||` returns the first truthy value. This is called short-circuiting and it appears constantly in frontend work.

Once you understand the pattern, you can write compact validations and more resilient interfaces.

Use `||` for quick fallbacks on empty strings or missing values.
Do not cram too many conditions into one line. Extract intermediate booleans.
If the rule is critical, spread the condition across lines and document the intent.

The ternary operator: excellent for small decisions

If the decision fits in one sentence, a ternary usually improves readability.

The ternary operator (`condition ? A : B`) works very well for labels, classes and short display decisions.

Avoid nested ternaries at the beginner level. They make debugging harder and slow down reading.

Real mistakes you will make and how to get out fast

Learning operators also means learning how to debug them.

Typical mistake one: using `=` inside a condition by habit. Typical mistake two: mixing strings and numbers and comparing without converting.

Typical mistake three: giant unnamed conditions. The fix is to split them into well named booleans such as `isAdult` or `hasBalance`.

1 A mental map: which operator to use and when 2 Arithmetic plus compound assignment: calculate without noise 3 Comparisons without surprises: strict by default 4 Logical operators and short-circuit behavior 5 The ternary operator: excellent for small decisions 6 Real mistakes you will make and how to get out fast

🧭 Key visuals

Operators in JavaScript

It summarizes how expressions are evaluated to make decisions in code.

Diagram of arithmetic, logical and comparison operators

From variables to results through operators

It helps show that operators are not isolated symbols. They are the bridge between stored data and program decisions.

Diagram connecting input variables, operators and numeric or boolean results

🧪 Learn by doing

Example Guided example: calculate a final price with conditions Combine arithmetic, comparison and ternary logic in a small ecommerce scenario.

⌄

Example Guided example: access rule by role and account state Build a readable compound condition using intermediate booleans.

⌄

Example Interactive demo: monthly budget simulator Adjust income and expenses to see how operators change a simple financial decision.

⌄

🏁 Challenges

Challenge Challenge 1: risk level classifier Use comparisons and logical thinking to assign a level based on debt and income.

⌄

Challenge Challenge 2: an accumulator with valid-value filtering Loop over an array, sum only positive numbers and discard the rest with comparison logic.

⌄

🧰 Resources

Useful links

MDN: Expressions and operators javascript.info: Comparisons javascript.info: Logical operators MDN: Strict equality (`===`) MDN: Conditional operator MDN: Logical operators

Test

Check your knowledge with a test about JavaScript.

Test for JavaScript

Course resources 62

📘 Glossary 🎧 Audio 📄 PDFs 🖼️ Infographics 🎬 Videos 🔗 Links 🧠 Flashcards 🧩 Snippets

‹

Lesson 06

Types and coercion in JavaScript: avoid silent bugs

Lesson 08

Control flow: design clear decisions with if, else if and switch

›