Operators

Arithmetic Operators

Basic Operators

let a = 10 + 5;    // 15 (addition)
let b = 10 - 5;    // 5 (subtraction)
let c = 10 * 5;    // 50 (multiplication)
let d = 10 / 5;    // 2 (division)
let e = 10 % 3;    // 1 (modulo/remainder)
let f = 2 ** 3;    // 8 (exponentiation)

Unary Operators

let x = 5;
++x;    // x is now 6 (prefix increment)
x++;    // x is now 7 (postfix increment)
--x;    // x is now 6 (prefix decrement)
x--;    // x is now 5 (postfix decrement)

Prefix vs Postfix

let a = 5;
let b = a++; // b = 5, a = 6 (postfix: use then increment)
let c = ++a; // c = 7, a = 7 (prefix: increment then use)

Compound Assignment

let x = 10;
x += 5;   // x = x + 5 = 15
x -= 3;   // x = x - 3 = 12
x *= 2;   // x = x * 2 = 24
x /= 4;   // x = x / 4 = 6
x %= 4;   // x = x % 4 = 2
x **= 3;  // x = x ** 3 = 8

Float Precision

0.1 + 0.2;    // 0.30000000000000004
0.1 + 0.2 === 0.3; // false

// Fix: use toFixed or compare with epsilon
Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON; // true

Comparison Operators

Equality

// Loose equality (==) - with coercion
5 == '5';      // true
0 == false;    // true
null == undefined; // true

// Strict equality (===) - no coercion
5 === '5';     // false
0 === false;   // false
null === undefined; // false

Inequality

// Loose inequality (!=)
5 != '5';      // false

// Strict inequality (!==)
5 !== '5';     // true

Relational

let a = 5, b = 10;

a > b;    // false (greater than)
a < b;    // true (less than)
a >= 5;   // true (greater than or equal)
a <= 10;  // true (less than or equal)

Logical Operators

// AND (&&) - returns first falsy or last value
true && true;     // true
true && false;    // false
'hello' && 'world'; // "world"
'' && 'world';    // ""

// OR (||) - returns first truthy or last value
true || false;    // true
false || true;    // true
'' || 'default';  // "default"
'hello' || 'world'; // "hello"

// NOT (!) - negates
!true;     // false
!false;    // true
!'';       // true
!'hello';  // false

Nullish Coalescing (??)

// Returns right side only for null/undefined
null ?? 'default';    // "default"
undefined ?? 'default'; // "default"
0 ?? 'default';       // 0
'' ?? 'default';      // ""

Optional Chaining (?.)

const user = { name: 'John' };

user?.address?.city;  // undefined (no error)
user?.getName?.();    // undefined (no error)

Logical Operators

Short-Circuit Evaluation

// && stops at first falsy
false && console.log('never runs');

// || stops at first truthy
true || console.log('never runs');

Default Values

// Using ||
let name = inputName || 'Anonymous';

// Using ?? (better - only null/undefined)
let name = inputName ?? 'Anonymous';

Guard Clauses

// Instead of
if (user) {
  if (user.admin) {
    doSomething();
  }
}

// Use optional chaining
user?.admin && doSomething();

Logical AND Assignment

// ES2021
x &&= y;  // x = x && y
x ||= y;  // x = x || y
x ??= y;  // x = x ?? y

// Example
let config = {};
config.timeout ??= 5000; // Set only if undefined/null

Truth Table

| 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 |

Practical Examples

// Guard pattern
const name = user && user.profile && user.profile.name;

// Modern: optional chaining
const name = user?.profile?.name;

// Default value pattern
const timeout = config?.timeout ?? 5000;