# JavaScript Operators: The Basics You Need to Know

*By Saurabh Prajapati | IBM Software Engineer & Full-Stack Developer*

* * *

## Why I Decided to Explore This

When I first started learning JavaScript, I thought operators were just... math symbols. Like, how complicated can `+` and `-` really be?

Turns out — more interesting than I expected. 😄

The moment that really got me was when I wrote this:

```js
console.log(0 == "0");  // true
console.log(0 === "0"); // false
```

Wait, what? How are those different?

That confusion sent me down a rabbit hole. And honestly? I'm glad it did. Because once operators *clicked* for me, writing conditions, doing calculations, and controlling logic in JavaScript became so much easier.

Let me walk you through what I learned — step by step.

* * *

## So... What Even Is an Operator?

Think of an operator as a **symbol that tells JavaScript to do something with values**.

That's it.

```js
let result = 5 + 3; // '+' is the operator. It adds 5 and 3.
```

The values around the operator (like `5` and `3`) are called **operands**. The operator sits between them and does the work.

JavaScript has several *types* of operators — each with its own job. Let's go through them one by one.

* * *

## 1\. Arithmetic Operators — The Math Ones

These are the ones you probably already know. They handle basic math.

| Operator | What It Does | Example | Result |
| --- | --- | --- | --- |
| `+` | Addition | `5 + 3` | `8` |
| `-` | Subtraction | `5 - 3` | `2` |
| `*` | Multiplication | `5 * 3` | `15` |
| `/` | Division | `6 / 2` | `3` |
| `%` | Remainder (Modulus) | `7 % 3` | `1` |

Most of these feel natural. But `%` (modulus) confused me at first.

Here's how I think about it now: **it gives you the leftover after division**.

```js
console.log(7 % 3); // 1
// Because 7 ÷ 3 = 2, with 1 left over
```

A super common real-world use? **Checking if a number is even or odd:**

```js
let num = 8;
console.log(num % 2); // 0 → even!

let num2 = 7;
console.log(num2 % 2); // 1 → odd!
```

I use this trick all the time. Once I learned it, I started seeing it everywhere in code.

* * *

## 2\. Comparison Operators — Is This True or False?

These operators **compare two values** and return either `true` or `false`.

| Operator | Meaning | Example | Result |
| --- | --- | --- | --- |
| `==` | Equal (loose) | `5 == "5"` | `true` |
| `===` | Equal (strict) | `5 === "5"` | `false` |
| `!=` | Not equal (loose) | `5 != 3` | `true` |
| `>` | Greater than | `10 > 5` | `true` |
| `<` | Less than | `3 < 7` | `true` |
| `>=` | Greater than or equal | `5 >= 5` | `true` |
| `<=` | Less than or equal | `4 <= 3` | `false` |

### The Big One: `==` vs `===`

This is where I made my first mistake. And honestly, so does almost everyone.

`==` **(loose equality)** compares values, but **ignores the data type**. JavaScript does some behind-the-scenes type conversion to make the comparison work.

`===` **(strict equality)** compares both the **value AND the type**. No shortcuts. No conversions.

```js
console.log(5 == "5");   // true  → value is same, type is ignored
console.log(5 === "5");  // false → number vs string, not the same!

console.log(0 == false);  // true  → 0 and false are treated as equal
console.log(0 === false); // false → different types!
```

My rule now? **Always use** `===` **unless you have a very specific reason not to.**

It avoids bugs that are really hard to track down. Trust me on this one — I've been there.

* * *

## 3\. Logical Operators — Combining Conditions

Once you can compare values, you'll want to **combine those comparisons**. That's where logical operators come in.

There are three of them:

| Operator | Name | Meaning |
| --- | --- | --- |
| `&&` | AND | Both conditions must be true |
| `||` | OR | At least one condition must be true |
| `!` | NOT | Flips true to false, false to true |

### `&&` — AND

```js
let age = 20;
let hasID = true;

if (age >= 18 && hasID) {
  console.log("You can enter!"); // Both are true → runs this
}
```

**Both** conditions have to be `true` for `&&` to return `true`.

### `||` — OR

```js
let isWeekend = false;
let isHoliday = true;

if (isWeekend || isHoliday) {
  console.log("No work today! 🎉"); // At least one is true → runs this
}
```

**At least one** condition being `true` is enough for `||`.

### `!` — NOT

This one just flips the value.

```js
let isLoggedIn = false;

if (!isLoggedIn) {
  console.log("Please log in first."); // !false = true → runs this
}
```

### Truth Table (For Reference)

| A | B | A && B | A || B | !A |
| --- | --- | --- | --- | --- |
| true | true | true | true | false |
| true | false | false | true | false |
| false | true | false | true | true |
| false | false | false | false | true |

When I first saw a truth table, it felt very CS-textbook. But once I started writing real conditions in my code, I referred back to this mental model constantly.

* * *

## 4\. Assignment Operators — Setting (and Updating) Values

You already know `=`. It assigns a value to a variable.

```js
let score = 10; // assigns 10 to score
```

But there are shorter ways to **update** a variable using assignment operators:

| Operator | What It Does | Example | Same As |
| --- | --- | --- | --- |
| `=` | Assign | `x = 5` | — |
| `+=` | Add and assign | `x += 3` | `x = x + 3` |
| `-=` | Subtract and assign | `x -= 2` | `x = x - 2` |
| `*=` | Multiply and assign | `x *= 4` | `x = x * 4` |
| `/=` | Divide and assign | `x /= 2` | `x = x / 2` |

```js
let score = 10;

score += 5;  // score is now 15
score -= 3;  // score is now 12
score *= 2;  // score is now 24

console.log(score); // 24
```

I started using `+=` and `-=` a lot once I realized it made score-tracking, counters, and loops so much cleaner to write.

* * *

## 5\. Key Discoveries Along the Way

A few things that surprised me or saved me later:

*   `===` **over** `==` **— always.** Loose equality has caused so many sneaky bugs in real projects. Strict equality is your friend.
    
*   `%` **is more useful than it looks.** Checking even/odd, cycling through items in a list, pagination logic — the modulus operator shows up everywhere.
    
*   `!` **can be stacked.** `!!value` is a common trick to convert any value into a proper boolean. Weird at first, useful once you know it.
    
*   **Logical operators don't always return** `true` **or** `false`**.** They return one of the actual values. This one's a bit more advanced, but keep it in mind for later.
    

* * *

## 6\. Let's Put It All Together — Quick Assignment

Here's a small exercise I'd suggest trying yourself. It covers everything we talked about:

```js
// --- Arithmetic ---
let a = 15;
let b = 4;

console.log("Sum:", a + b);        // 19
console.log("Difference:", a - b); // 11
console.log("Product:", a * b);    // 60
console.log("Quotient:", a / b);   // 3.75
console.log("Remainder:", a % b);  // 3

// --- Comparison ---
console.log(a == "15");  // true  (loose)
console.log(a === "15"); // false (strict)
console.log(a > b);      // true
console.log(a < b);      // false

// --- Logical ---
let isAdult = a > 18;     // false
let hasPermission = true;

if (!isAdult && hasPermission) {
  console.log("Minor with permission — allowed conditionally.");
}

if (isAdult || hasPermission) {
  console.log("At least one condition passed — allowed!");
}
```

Try running this in your browser console or a quick Node.js script. Then **change the values** of `a` and `b` and see how the outputs shift. That's the best way to really internalize it.

* * *

## About the Author

**Saurabh Prajapati** is a Full-Stack Software Engineer at IBM India Software Lab, currently building cloud-native enterprise solutions on **Maximo**. He specializes in GenAI, React, and modern web technologies — and loves documenting his learning journey for other developers.

*   🐙 GitHub: [prajapatisaurabh](https://github.com/prajapatisaurabh)
    
*   💼 LinkedIn: [saurabh-prajapati](https://linkedin.com/in/saurabh-prajapati)
    
*   📧 Email: [saurabhprajapati120@gmail.com](mailto:saurabhprajapati120@gmail.com)
    

* * *