What's the difference between && and & in JavaScript?

&& is the logical AND (short-circuits). & is the bitwise AND (operates on individual bits of numbers). For boolean logic, always use &&.

How do I check multiple conditions efficiently?

Order conditions by likelihood of being false first (for &&) or true first (for ||). This takes advantage of short-circuit evaluation to avoid unnecessary work.

When should I use ?? instead of ||?

Use ?? (nullish coalescing) when 0, '', or false are valid values you want to keep. Use || when you want to treat all falsy values as 'missing'.

Can too many conditions make code hard to read?

Yes! If you have more than 2-3 conditions combined, extract them into named boolean variables or a helper function. 'const isEligible = age >= 18 && hasLicense' is much clearer than inline checks.

What does !! (double NOT) do?

!! converts any value to its boolean equivalent. !value flips the truthiness, then ! flips it back. So !!0 = false, !!'hello' = true. It's a shorthand for Boolean(value).

JavaScript Logical Thinking

Combine conditions, think in booleans, and build complex decision logic.

Module 2 · Control Flow

Programs make decisions and repeat work. Conditionals choose paths, loops repeat actions, and nested structures combine both. Mastering control flow turns a script that runs once into software that reacts to data and user input.

Learn Logical Thinking in JavaScript — covering Boolean Logic, Truth Tables, Complex Conditions, Short-Circuit with interactive visual examples and step-by-step explanations.

About this module

Control flow is how programs decide what to do next. If a user is logged in, show the dashboard; otherwise, redirect to login. If a cart total exceeds a threshold, apply a discount. These everyday behaviors all depend on conditionals and loops.

This module walks through if/else, switch, for and while loops, and how to combine them without losing readability. Visual step-throughs help you see exactly which branch runs and how loop counters change on each iteration.

Why this matters

Understanding logical thinking is essential for every JavaScript developer. It shows up in frontend UI code, backend APIs, and framework internals — and getting it wrong leads to bugs that are hard to trace. This chapter builds intuition with visuals so the behavior sticks.

Key topics covered

Boolean Logic
Truth Tables
Complex Conditions
Short-Circuit
Decision Patterns

Where you'll use it

Building interactive web applications with logical thinking
Processing and transforming data in frontend and backend code
Writing cleaner, more maintainable JavaScript modules
Debugging and reviewing code during development

Boolean Logic

The foundation of all decision making in programming.

Every decision in programming boils down to true or false. Boolean logic gives us tools to combine and manipulate these values.

AND

Both must be true

At least one true

NOT

Flips the value

// AND (&&) — both conditions must be true
let age = 25;
let hasLicense = true;

if (age >= 18 && hasLicense) {
  console.log("Can drive"); // ✓ Both true
}

// OR (||) — at least one must be true
let isWeekend = true;
let isHoliday = false;

if (isWeekend || isHoliday) {
  console.log("Day off!"); // ✓ One is true
}

// NOT (!) — inverts the value
let isLoggedIn = false;
if (!isLoggedIn) {
  console.log("Please log in"); // ✓ !false = true
}

Truth Tables

See every possible combination of AND, OR, and NOT.

A && B

false

A || B

true

false

AND (&&)

T && T	true
T && F	false
F && T	false
F && F	false

OR (||)

T \|\| T	true
T \|\| F	true
F \|\| T	true
F \|\| F	false

Complex Conditions

Combine multiple checks with parentheses for grouping.

// Loan approval logic:
const approved = age >= 21 && (income >= 30000 || creditScore >= 700);

// Reads as:
// "Age at least 21 AND (income 30k+ OR credit 700+)"

// Parentheses control grouping:
// A && B || C   → (A && B) || C  (AND first)
// A && (B || C) → different!      (OR first)

Loan Approval Simulator

Age:25

Income:$50k

Credit:720

✓age >= 21

✓income >= 30000

✓creditScore >= 700

✓ Approved

Short-Circuit Evaluation

JavaScript stops evaluating as soon as the result is determined.

JavaScript is lazy — it won't evaluate more than it needs to. This is called short-circuit evaluation.

AND (&&) — stops at first false

false && anything → false

"anything" is never evaluated — why check more if one is already false?

OR (||) — stops at first true

true || anything → true

"anything" is never evaluated — already found one true value.

// && returns the first falsy value (or last value)
console.log(0 && "hello");      // 0
console.log(1 && "hello");      // "hello"
console.log("a" && "b" && "c"); // "c"

&& doesn't return true/false — it returns the actual value where it stopped. If all truthy, returns the last one.

1 / 3

// ⚠️ || vs ?? for defaults:
let count = 0;

count || 10;   // 10  ← wrong! 0 is falsy
count ?? 10;   // 0   ← correct! ?? only checks null/undefined

let text = "";
text || "default";  // "default" ← wrong!
text ?? "default";  // ""         ← correct!

Decision Patterns

Common patterns for making decisions in real code.

1. Guard Clause Pattern

function processOrder(order) {
  if (!order) return;           // guard
  if (!order.items.length) return; // guard
  if (!order.payment) return;   // guard
  
  // Happy path — all checks passed
  shipOrder(order);
}

Exit early for invalid cases. Main logic stays un-nested.

2. Lookup Object Pattern

// Instead of long if/else chains:
const actions = {
  "save": () => saveDocument(),
  "delete": () => deleteDocument(),
  "share": () => shareDocument(),
};

const handler = actions[command];
if (handler) handler();

Replace switch/if-else with an object map. Cleaner and extensible.

3. Validation Chain

function validateForm(data) {
  const errors = [];
  
  if (!data.email) errors.push("Email required");
  if (!data.email?.includes("@")) errors.push("Invalid email");
  if (data.password?.length < 8) errors.push("Password too short");
  
  return errors; // empty = valid
}

Collect all issues instead of stopping at the first one.

4. State Machine

function getNextState(current, event) {
  const transitions = {
    idle:    { click: "loading" },
    loading: { success: "done", error: "failed" },
    done:    { reset: "idle" },
    failed:  { retry: "loading", reset: "idle" },
  };
  return transitions[current]?.[event] ?? current;
}

Model complex logic as states and transitions.

Frequently Asked Questions

Common questions about logical thinking.

// AND (&&) — both conditions must be true let age = 25; let hasLicense = true; if (age >= 18 && hasLicense) { console.log("Can drive"); // ✓ Both true } // OR (||) — at least one must be true let isWeekend = true; let isHoliday = false; if (isWeekend || isHoliday) { console.log("Day off!"); // ✓ One is true } // NOT (!) — inverts the value let isLoggedIn = false; if (!isLoggedIn) { console.log("Please log in"); // ✓ !false = true }

// Loan approval logic: const approved = age >= 21 && (income >= 30000 || creditScore >= 700); // Reads as: // "Age at least 21 AND (income 30k+ OR credit 700+)" // Parentheses control grouping: // A && B || C → (A && B) || C (AND first) // A && (B || C) → different! (OR first)

// ⚠️ || vs ?? for defaults: let count = 0; count || 10; // 10 ← wrong! 0 is falsy count ?? 10; // 0 ← correct! ?? only checks null/undefined let text = ""; text || "default"; // "default" ← wrong! text ?? "default"; // "" ← correct!

function processOrder(order) { if (!order) return; // guard if (!order.items.length) return; // guard if (!order.payment) return; // guard // Happy path — all checks passed shipOrder(order); }

// Instead of long if/else chains: const actions = { "save": () => saveDocument(), "delete": () => deleteDocument(), "share": () => shareDocument(), }; const handler = actions[command]; if (handler) handler();

function validateForm(data) { const errors = []; if (!data.email) errors.push("Email required"); if (!data.email?.includes("@")) errors.push("Invalid email"); if (data.password?.length < 8) errors.push("Password too short"); return errors; // empty = valid }

function getNextState(current, event) { const transitions = { idle: { click: "loading" }, loading: { success: "done", error: "failed" }, done: { reset: "idle" }, failed: { retry: "loading", reset: "idle" }, }; return transitions[current]?.[event] ?? current; }

About this chapter

About this module

Why this matters

Key topics covered

Where you'll use it

Boolean Logic

Truth Tables

Complex Conditions

Short-Circuit Evaluation

Decision Patterns

Frequently Asked Questions

About this chapter

About this module

Why this matters

Key topics covered

Where you'll use it

Boolean Logic

Truth Tables

Complex Conditions

Short-Circuit Evaluation

Decision Patterns

Frequently Asked Questions