Comparing Values and Combining Conditions in JavaScript

Why Comparison Is the Heart of Every Program

Strip away the fancy frameworks, and every program is just a long series of questions:

Every question is acomparison, and every comparison produces aboolean—trueorfalse. That boolean then drives a decision (which we'll fully explore in the next lesson onif/else).

So let's make sure your questions arecorrect— because asking the wrong question is how bugs are born. 🐛

Part 1: Comparing Values — The Full Toolkit

Equality: The === Family

You met these in Lesson 6, but here's the quick reference:

The rule you should tattoo on your brain:always use===/!==. The loose versions (==,!=) secretly convert types, and their surprises are legendary:

console.log("" == 0);
// true  😱console.log(" " == 0);         // true  😱😱console.log(null == undefined); // true 😬console.log([] == "");         // true  🔥🗑️

With===, all of these are honestlyfalse. No conversion, no surprises.

Relational: Greater, Less, and Friends

let cartTotal = 750;
const FREE_DELIVERY_MIN = 500;
console.log(cartTotal >= FREE_DELIVERY_MIN);
// true → free delivery! 🚚

💡 Interview gem:>=includes equality. The most common off-by-one bug in history is using>where>=was needed — "must be 18or older" isage >= 18, notage > 18(which rejects 18-year-olds!).

⚠️ Comparing Strings: Dictionary Rules

Strings compareletter by letter, like a dictionary — based on character codes:

console.log("apple" < "banana");
// true — a comes before bconsole.log("cat" > "car");        // true — 't' beats 'r' at position 3console.log("Zebra" < "apple");    // true 😮 — capital letters have lower codes!console.log("10" < "9");           // true 😱 — string "1" < "9", NOT numeric!

That last line causes real bugs: comparing numeric strings compares themas text. Convert first:Number("10") > Number("9")→true. ✅

⚠️ The Special Case: NaN Can Never Equal Anything

RememberNaNfromLesson 5? It's the only value in JavaScript that isnot equal to itself:

console.log(NaN === NaN);
// false! 🤯

To check for NaN, never use===— use:

console.log(Number.isNaN(NaN));
// true ✅
console.log(Number.isNaN("hello" * 2));
// true ✅ (failed math)
console.log(Number.isNaN(42));
// false

Part 2: Truthy and Falsy — The Hidden Rule 🎭

Here's something most tutorials mention too late:JavaScript conditions don't require actual booleans.Every single value in JavaScript is secretly eithertruthy(acts liketrue) orfalsy(acts likefalse) when used in a condition.

The Complete Falsy List (Only 8 Exist!)

Everything else is truthy.Memorize the falsy list — it's tiny, and everything NOT on it is truthy:

// These are ALL truthy — even the weird ones:
Boolean("hello");
// true
Boolean(42);
// true
Boolean([]);
// true 😮 — empty ARRAY is truthy!
Boolean( {
});
// true 😮 — empty OBJECT is truthy!
Boolean("0");
// true 😮 — the STRING "0" is truthy!
Boolean("false");
// true 😮 — a non-empty string is truthy!

The!!Trick — Revealing Any Value's Truthiness

Double-NOT converts any value to its true boolean nature:

console.log(!!"hello");
// true
console.log(!!"");
// false
console.log(!!0);
// false
console.log(!![]);
// true

Why This Matters in Real Code

Truthy/falsy checks let you write beautifully clean conditions:

let userName = "";
if (userName) {
  console.log("Welcome, " + userName);
} else {
  console.log("Please enter your name! 📝");
  // ← this runs (empty string is falsy)
}

No=== ""needed — the string itself answers the question. This pattern appearseverywherein professional code.

Part 3: Combining Conditions — && || ! in Real Life

One question is rarely enough. Real decisions combine several:

&&(AND) — The Bouncer 🕶️

Everyone must pass:

let age = 25;
let hasTicket = true;
let hasID = true;
if (age >= 18 && hasTicket && hasID) {
  console.log("Welcome to the concert! 🎸");
  // ← runs — all three passed}

Onefalseruins everything:

let isLoggedIn = true;
let isPaidMember = false;
console.log(isLoggedIn && isPaidMember);
// false → no premium content

||(OR) — The Flexible Friend 🤝

Any single pass is enough:

let isWeekend = true;
let isHoliday = false;
if (isWeekend || isHoliday) {
  console.log("Sleep in today! 😴");
  // ← runs — weekend alone is enough}

!(NOT) — The Reverser 🔄

let isBlocked = false;
if (!isBlocked) {
  console.log("You can send messages ✅");
  // ← runs (!false = true)}

Combining Multiple Operators — Real-World Example

An e-commerce free-shipping rule:"Order must be ₹500+, AND (the user is a member OR has a coupon), AND the address is not remote."

let cartTotal = 750;
let isMember = false;
let hasCoupon = true;
let isRemoteArea = false;
if (cartTotal >= 500 &&(isMember || hasCoupon) && !isRemoteArea) {
  console.log("🎉 Free delivery applied!");
} else {
  console.log("Delivery charges apply.");
}// Output: 🎉 Free delivery applied!

Notice the parentheses—(isMember || hasCoupon)groups the OR so it's evaluated as one unit. When mixing&&and||, always use parentheses for clarity. (&&runs before||by default — but explicit grouping makes your intent obvious to every reader, including future you.)

Part 4: Short-Circuit Evaluation ⚡ — The Secret Behavior

Here's what almost no beginner tutorial explains:&&and||don't just return true/false — they return actual values, and they stop checking as soon as the answer is decided. This is calledshort-circuit evaluation.

||Returns the First Truthy Value

console.log("" || "Guest");
// "Guest" — "" is falsy, move on
console.log("Priya" || "Guest");
// "Priya" — found truthy, STOP
console.log(0 || "" || "fallback");
// "fallback" — keeps searching

This is how professionals write default values:

let userInput = "";
let displayName = userInput || "Guest";
console.log(displayName);
// "Guest" — elegant one-liner!

You'll see this pattern in every real codebase. It's the older sibling of??(which you met in Lesson 6 —??only falls back onnull/undefined, while||falls back onanyfalsy value including""and0).

&&Returns the First Falsy Value (or the Last One Standing)

console.log(true && "Hello");
// "Hello" — all truthy, returns last
console.log(false && "Hello");
// false — found falsy, STOP
console.log("Hi" && 0 && "Bye");
// 0 — stopped at the first falsy

Real-world use — conditional execution:

let isLoggedIn = true;
isLoggedIn && console.log("Show the dashboard! 📊");
// Logs only if isLoggedIn is truthy — an if-statement in one line!

Why "Short-Circuit"? Efficiency + Safety

JavaScript stops evaluating the moment the result is certain — which protects you from errors:

const user = null;
// user.name would CRASH ❌ — but short-circuit saves us:
console.log(user && user.name);
// null ✅ — never touched .name!

This is exactly how?.(optional chaining, Lesson 6) works under the hood.

Common Beginner Mistakes (And Fixes)

⚠️ The chained-comparison trapdeserves emphasis:18 <= age <= 65looks natural but breaks. JavaScript evaluates18 <= agefirst (→true/false), then comparesthat booleanto65. Always writeage >= 18 && age <= 65.

Quick Self-Check: Lesson 7 Quiz 🧠

1. List anyfourfalsy values in JavaScript.
2. What's the output?console.log("" || "Guest");
3. What's the output?console.log(true && "Hello");
4. Fix this buggy code:if (age = 21) { console.log("Adult"); }
5. Why doesconsole.log("10" < "9");returntrue?

(Answers: 1. Any four of: false, 0, -0, 0n, "", null, undefined, NaN · 2. "Guest" — empty string is falsy, so || moves on · 3. "Hello" — && with all truthy returns the last value · 4.if (age === 21)— single = assigns instead of comparing · 5. Strings compare character-by-character; "1" has a lower character code than "9" — convert to numbers first)