JavaScript Cheat Sheet 2026: Learn Once, Remember Forever (ES2026)

console.log('Hello, JS');   // run in browser DevTools console, or: node file.js

const PI = 3.14159;       // default choice
let count = 0;            // when you need to reassign
// avoid var

const user = { name: 'A' };
user.name = 'B';          // allowed: const protects the binding, not the contents
// user = {};             // TypeError

console.log(a);   // undefined (var is hoisted)
var a = 5;

console.log(b);   // ReferenceError (TDZ)
let b = 5;

sayHi();          // works: function declarations are fully hoisted
function sayHi() { console.log('hi'); }

hello();          // TypeError: hello is not a function (var hoisted, value not yet assigned)
var hello = () => {};

Array.isArray([]);          // true
value === null;             // the right null check
value == null;              // true for both null and undefined (the one accepted use of ==)

let a = 1; let b = a; b = 2;       // a is still 1 (copied)

const o1 = { x: 1 };
const o2 = o1;                     // same object
o2.x = 99;                         // o1.x is now 99

0.1 + 0.2 === 0.3;                          // false (0.30000000000000004)
Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON; // true: compare floats like this
Number.MAX_SAFE_INTEGER;                    // 9007199254740991, beyond this use BigInt
NaN === NaN;                                // false
Number.isNaN(NaN);                          // true (use this, not isNaN())
9007199254740993n + 1n;                     // BigInt: arbitrary precision, no mixing with Number

1 == '1';           // true
1 === '1';          // false
null == undefined;  // true
null === undefined; // false
Object.is(NaN, NaN);// true (like === but NaN equals NaN, and +0 differs from -0)

1 + '2';        // '12'  (+ prefers strings)
'3' - 1;        // 2     (- forces numbers)
'5' * '2';      // 10
[] + [];        // ''
[] + {};        // '[object Object]'
true + 1;       // 2
Number('');     // 0
Number('12px'); // NaN
parseInt('12px', 10); // 12 (always pass the radix)

const port = config.port ?? 3000;     // keeps 0 if port is 0
const port2 = config.port || 3000;    // replaces 0 with 3000 (bug)
const city = user?.address?.city;     // undefined instead of TypeError

const name = 'World';
`Hello, ${name}! ${2 + 3}`;     // template literal, multi-line allowed

(1234.5678).toFixed(2);          // '1234.57' (returns a STRING)
Number.isInteger(5);             // true
Math.round(2.5);                 // 3
Math.floor(-1.5);                // -2
Math.trunc(-1.5);                // -1
Math.max(...nums);               // Math.max() with no args is -Infinity
Math.floor(Math.random() * (max - min + 1)) + min;   // random int in [min, max]

if (x > 0) { } else if (x === 0) { } else { }

switch (day) {
  case 'sat':
  case 'sun': console.log('weekend'); break;   // forget break and it falls through
  default: console.log('weekday');
}

for (const [i, value] of arr.entries()) { }
for (const [key, value] of Object.entries(obj)) { }
for (const [key, value] of map) { }

outer: for (const a of A) {           // label to break out of nested loops
  for (const b of B) { if (a === b) break outer; }
}

function add(a, b) { return a + b; }            // declaration (hoisted)
const sub = function (a, b) { return a - b; };  // expression
const mul = (a, b) => a * b;                    // arrow, implicit return
const makeUser = name => ({ name });            // wrap returned object literal in ()

function greet(name = 'friend', ...rest) {      // default value, rest parameter
  return `Hi ${name} (+${rest.length} extra)`;
}
const [first, second] = [1, 2];                 // destructuring
function area({ w, h = 1 }) { return w * h; }   // destructure a param object

const user = {
  name: 'Asha',
  hi() { return this.name; },
  later() { setTimeout(() => console.log(this.name), 100); }, // arrow keeps this
};

const f = user.hi;
f();                      // this is lost
f.call(user);             // 'Asha'
const bound = user.hi.bind(user);
bound();                  // 'Asha'

fn.call(obj, a, b);       // call now, args listed
fn.apply(obj, [a, b]);    // call now, args as array
fn.bind(obj, a);          // returns a new function, call later

(() => { /* IIFE: runs immediately, rarely needed with modules */ })();

const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);   // composition
const curry = a => b => a + b;                                          // currying

function fact(n) { return n <= 1 ? 1 : n * fact(n - 1); }              // recursion needs a base case

function counter() {
  let n = 0;                // private, nobody else can touch it
  return () => ++n;
}
const next = counter();
next(); // 1
next(); // 2

for (var i = 0; i < 3; i++) setTimeout(() => console.log(i));   // 3 3 3 (one shared var)
for (let i = 0; i < 3; i++) setTimeout(() => console.log(i));   // 0 1 2 (new let per iteration)

function debounce(fn, ms = 300) {            // run after the user STOPS for ms
  let t;
  return (...args) => {
    clearTimeout(t);
    t = setTimeout(() => fn(...args), ms);
  };
}

function throttle(fn, ms = 300) {            // run at most once per ms
  let last = 0;
  return (...args) => {
    const now = Date.now();
    if (now - last >= ms) { last = now; fn(...args); }
  };
}

const name = 'Asha';
const user = {
  name,                              // shorthand for name: name
  age: 30,
  ['is' + 'Admin']: false,           // computed key
  greet() { return `Hi ${this.name}`; },
  get label() { return `${this.name} (${this.age})`; },
};

user.name;  user['name'];            // two ways to read
delete user.age;
'name' in user;                      // true (includes inherited)
Object.hasOwn(user, 'name');         // true (own property, modern replacement for hasOwnProperty)

const { name: userName, age = 18, ...others } = user;      // rename, default, rest
const updated = { ...user, age: 31 };                      // copy + override
const merged = { ...defaults, ...overrides };              // later wins

const prices = { a: 10, b: 20 };
Object.fromEntries(Object.entries(prices).map(([k, v]) => [k, v * 2]));  // { a: 20, b: 40 }

Object.groupBy([1, 2, 3, 4], n => (n % 2 ? 'odd' : 'even'));  // { odd: [1,3], even: [2,4] }

const nums = [5, 1, 4];

nums.map(n => n * 2);                    // [10, 2, 8]
nums.filter(n => n > 1);                 // [5, 4]
nums.find(n => n > 1);                   // 5 (first match or undefined)
nums.findLast(n => n > 1);               // 4
nums.some(n => n > 4);                   // true
nums.every(n => n > 0);                  // true
nums.includes(4);                        // true
nums.reduce((sum, n) => sum + n, 0);     // 10 (always give an initial value)
nums.at(-1);                             // 4
nums.slice(1, 3);                        // [1, 4]
nums.flat(Infinity);                     // flatten nested arrays
Array.from({ length: 3 }, (_, i) => i);  // [0, 1, 2]
[...new Set(nums)];                      // unique values

[10, 9, 1].sort();                       // [1, 10, 9] (default sorts as STRINGS)
[10, 9, 1].sort((a, b) => a - b);        // [1, 9, 10]
[10, 9, 1].toSorted((a, b) => b - a);    // [10, 9, 1] (original untouched)

people.sort((a, b) => a.name.localeCompare(b.name));   // sort strings properly

const add    = [...arr, item];
const remove = arr.filter(x => x.id !== id);
const update = arr.map(x => (x.id === id ? { ...x, done: true } : x));
const swap   = arr.with(2, 'new');       // replace index 2

const total = orders
  .filter(o => o.status === 'paid')
  .map(o => o.amount)
  .reduce((sum, n) => sum + n, 0);

const m = new Map([['a', 1]]);
m.set('b', 2).get('b');          // 2
m.has('a');  m.delete('a');  m.size;
for (const [k, v] of m) { }

// count things (ES2026 getOrInsert, check engine support)
const counts = new Map();
for (const w of words) counts.set(w, counts.getOrInsert(w, 0) + 1);

const s = new Set([1, 2, 2, 3]);   // {1, 2, 3}
s.add(4);  s.has(2);  s.delete(1);  s.size;

const a = new Set([1, 2, 3]);
const b = new Set([2, 3, 4]);

a.union(b);                // {1, 2, 3, 4}
a.intersection(b);         // {2, 3}
a.difference(b);           // {1}
a.symmetricDifference(b);  // {1, 4}
a.isSubsetOf(b);  a.isSupersetOf(b);  a.isDisjointFrom(b);

const meta = new WeakMap();
meta.set(domNode, { clicks: 0 });    // entry disappears when domNode is collected

const animal = { eats: true };
const dog = Object.create(animal);
dog.barks = true;
dog.eats;                                  // true (found on the prototype)
Object.getPrototypeOf(dog) === animal;     // true

class Account {
  #balance = 0;                          // truly private
  static count = 0;                      // belongs to the class

  constructor(owner) {
    this.owner = owner;
    Account.count++;
  }

  deposit(n) {
    if (n <= 0) throw new RangeError('Amount must be positive');
    this.#balance += n;
    return this;                         // enables chaining
  }

  get balance() { return this.#balance; }
  static create(owner) { return new Account(owner); }
}

class Savings extends Account {
  constructor(owner, rate) {
    super(owner);                        // must call super before using this
    this.rate = rate;
  }
  deposit(n) { return super.deposit(n * 1.01); }
}

const s = new Savings('Asha', 0.05);
s instanceof Account;                    // true
s.balance;                               // 0
// s.#balance                            // SyntaxError (private)

// math.js
export const PI = 3.14;
export function add(a, b) { return a + b; }
export default class Calculator {}

// app.js
import Calculator, { PI, add as sum } from './math.js';
import * as math from './math.js';

const { default: Chart } = await import('./chart.js');     // dynamic import (lazy load)
import config from './config.json' with { type: 'json' };  // JSON modules (ES2025)

Call Stack  <---  Microtask queue (Promises, queueMicrotask)      runs FIRST, fully drained
            <---  Macrotask queue (setTimeout, events, I/O)       ONE task, then microtasks again

console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
queueMicrotask(() => console.log('4'));
console.log('5');
// 1, 5, 3, 4, 2

fetch('/api/user')
  .then(res => res.json())
  .then(user => console.log(user))
  .catch(err => console.error(err))
  .finally(() => hideSpinner());

const { promise, resolve, reject } = Promise.withResolvers();   // ES2024
Promise.try(() => maybeSyncOrAsync());   // ES2025: sync throws become rejections, result is always a Promise

async function loadUser(id) {
  try {
    const res = await fetch(`/api/users/${id}`, { signal: AbortSignal.timeout(5000) });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);   // fetch does NOT reject on 404 or 500
    return await res.json();
  } catch (err) {
    console.error('Load failed', err);
    throw err;
  } finally {
    hideSpinner();
  }
}

const a = await getA();
const b = await getB();                        // waits for A first (slow)

const [a2, b2] = await Promise.all([getA(), getB()]);   // both start together (fast)

items.forEach(async item => { await save(item); });     // forEach does NOT wait
await Promise.all(items.map(item => save(item)));       // correct, parallel
for (const item of items) await save(item);             // correct, one by one

const controller = new AbortController();
fetch(url, { signal: controller.signal });
controller.abort();                                     // cancels the request

const sleep = ms => new Promise(r => setTimeout(r, ms));

async function retry(fn, tries = 3) {
  for (let i = 0; i < tries; i++) {
    try { return await fn(); }
    catch (e) { if (i === tries - 1) throw e; await sleep(2 ** i * 500); }
  }
}

for await (const chunk of stream) { }                    // consume async iterables
const all = await Array.fromAsync(asyncGenerator());     // ES2026: collect an async iterable into an array

const res = await fetch('/api/items', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ name: 'Pen' }),
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data = await res.json();

try {
  JSON.parse('{ bad json');
} catch (err) {
  console.error(err.name, err.message);   // SyntaxError ...
} finally {
  cleanup();                              // always runs
}

class ValidationError extends Error {
  constructor(message, field, options) {
    super(message, options);
    this.name = 'ValidationError';
    this.field = field;
  }
}

try {
  await save();
} catch (err) {
  throw new Error('Could not save profile', { cause: err });   // keeps the original error
}

function* range(start, end) {
  for (let i = start; i < end; i++) yield i;     // pauses here until next() is called
}

[...range(0, 3)];                                // [0, 1, 2]

function* naturals() { let n = 0; while (true) yield n++; }

naturals()
  .filter(n => n % 2 === 0)
  .map(n => n * n)
  .take(5)
  .toArray();                  // [0, 4, 16, 36, 64]

JSON.stringify({ a: 1, b: [2, 3] }, null, 2);   // pretty print
JSON.parse('{"a":1}');                          // throws SyntaxError on bad input
JSON.parse(text, (key, value) => key === 'date' ? new Date(value) : value);   // reviver

const d = new Date();                       // now
new Date('2026-10-23');                     // date-only strings are parsed as UTC
new Date('2026-10-23T10:00');               // date-time without zone is parsed as LOCAL
new Date(2026, 9, 23);                      // month is 0-based: 9 means October
d.getTime();  Date.now();                   // ms since 1970 (Unix epoch)
d.toISOString();                            // '2026-10-23T...Z'

new Intl.NumberFormat('en-IN', { style: 'currency', currency: 'INR' }).format(1234567.5);
// '₹12,34,567.50'

new Intl.DateTimeFormat('en-IN', { dateStyle: 'medium', timeStyle: 'short' }).format(new Date());

new Intl.RelativeTimeFormat('en', { numeric: 'auto' }).format(-1, 'day');   // 'yesterday'
new Intl.ListFormat('en').format(['A', 'B', 'C']);                          // 'A, B, and C'

const url = new URL('https://x.com/search?q=js');
url.searchParams.get('q');            // 'js'
url.searchParams.set('page', '2');

const re = /pattern/flags;
const re2 = new RegExp('pattern', 'g');

/\d+/.test('abc123');                                  // true
'a1b22'.match(/\d+/g);                                 // ['1', '22']
'2026-10-23'.match(/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/).groups.y;   // '2026'
[...'a1b22'.matchAll(/\d+/g)].map(m => m[0]);          // ['1', '22']
'a-b-c'.replaceAll('-', '+');                          // 'a+b+c'

const safe = new RegExp(RegExp.escape(userInput), 'i');   // ES2025: escape user text for a regex

const el = document.querySelector('.card');            // first match
const all = document.querySelectorAll('li');           // NodeList (use for...of)

el.textContent = 'Safe text';                          // use this for user data
el.innerHTML = '<b>HTML</b>';                          // XSS risk with untrusted input
el.classList.add('active');  el.classList.toggle('open');
el.dataset.id;                                         // reads data-id
el.setAttribute('aria-expanded', 'true');

const li = document.createElement('li');
li.textContent = 'New';
list.append(li);
li.remove();

button.addEventListener('click', e => {
  e.preventDefault();         // stop default behavior (link, form submit)
  e.stopPropagation();        // stop bubbling
}, { once: true });           // options: once, passive, capture, signal

list.addEventListener('click', e => {
  const item = e.target.closest('li[data-id]');
  if (!item || !list.contains(item)) return;
  console.log(item.dataset.id);
});

localStorage.setItem('user', JSON.stringify(user));
const saved = JSON.parse(localStorage.getItem('user') ?? 'null');

console.log([] == ![]);                    // true   ([] == false, '' == 0, 0 == 0)
console.log('5' + 3, '5' - 3);             // '53' 2
console.log([1, 2, 3] + [4]);              // '1,2,34'
console.log([10, 9, 1].sort());            // [1, 10, 9]
console.log(typeof null, typeof NaN);      // 'object' 'number'
console.log(0.1 + 0.2 === 0.3);            // false
console.log(['1', '2', '3'].map(parseInt)); // [1, NaN, NaN]

for (var i = 0; i < 3; i++) setTimeout(() => console.log(i), 0);
// 3 3 3

console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
console.log('D');
// A D C B

const user = { name: 'Asha', hi() { return this.name; } };
const f = user.hi;
f();   // this is lost: TypeError in strict mode (undefined.name), or globalThis.name in sloppy mode

async function a() { console.log(1); await null; console.log(2); }
a(); console.log(3);
// 1 3 2 (code after await runs as a microtask)