JavaScript

// Prefer const, then let — never var
const PI = 3.14159;
let count = 0;

// Primitives
const str = 'hello';
const num = 42;
const bool = true;
const nothing = null;
const undef = undefined;
const sym = Symbol('id');
const big = 9007199254740991n; // BigInt

// typeof
typeof 'hello'  // 'string'
typeof 42       // 'number'
typeof null     // 'object' (known quirk!)

// Array destructuring
const [a, b, ...rest] = [1, 2, 3, 4, 5];

// Object destructuring
const { name, age, city = 'Unknown' } = user;

// Rename while destructuring
const { name: userName } = user;

// Nested
const { address: { street } } = user;

// In function params
function greet({ name, age }) {
  return `${name} is ${age}`;
}

const nums = [1, 2, 3, 4, 5];

// map: transform
nums.map(x => x * 2);           // [2,4,6,8,10]

// filter: select
nums.filter(x => x % 2 === 0);  // [2,4]

// reduce: accumulate
nums.reduce((acc, x) => acc + x, 0);  // 15

// find / findIndex
nums.find(x => x > 3);          // 4
nums.findIndex(x => x > 3);     // 3

// some / every
nums.some(x => x > 4);          // true
nums.every(x => x > 0);         // true

// flat / flatMap
[[1,2],[3,4]].flat();            // [1,2,3,4]
nums.flatMap(x => [x, x*2]);

// async/await (preferred)
async function fetchUser(id) {
  try {
    const res = await fetch(`/api/users/${id}`);
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return await res.json();
  } catch (err) {
    console.error('Failed:', err);
    throw err;
  }
}

// Parallel execution
const [user, posts] = await Promise.all([
  fetchUser(1),
  fetchPosts(1),
]);

// Promise.allSettled — never throws
const results = await Promise.allSettled([p1, p2]);
results.forEach(r => {
  if (r.status === 'fulfilled') use(r.value);
});

// Shorthand properties
const name = 'Alice';
const user = { name, age: 30 };  // { name: 'Alice', age: 30 }

// Spread — shallow clone / merge
const updated = { ...user, age: 31 };
const merged = { ...defaults, ...overrides };

// Optional chaining
user?.address?.street  // undefined instead of TypeError
arr?.[0]?.name
fn?.()  // Call if function exists

// Nullish coalescing
const port = config.port ?? 3000;  // Use 3000 only if null/undefined

// Object.entries / fromEntries
Object.entries(obj).map(([k, v]) => [k, v * 2]);
Object.fromEntries(pairs);