JavaScript Core

function createRateLimiter(max: number) {
  let used = 0; // private, chỉ closure truy cập được
  return () => (used < max ? (++used, true) : false);
}
const allow = createRateLimiter(2);
allow(); allow(); allow(); // true, true, false

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

console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
queueMicrotask(() => console.log('4'));
(async () => {
  console.log('5');
  await null;
  console.log('6');
})();
console.log('7');

async function saveAll(orders: Order[]) {
  const results = [];
  orders.forEach(async (o) => {
    try {
      results.push(await db.save(o));
    } catch (e) {
      logger.error(e);
    }
  });
  return results; // always []
}

const cache = new Map<string, User>();
export async function getUser(req: Request) {
  const key = `${req.headers.get('x-request-id')}:${req.userId}`;
  if (!cache.has(key)) cache.set(key, await db.users.find(req.userId));
  return cache.get(key)!;
}

console.log(typeof a, typeof b);
var a = 1;
let b = 2;

const cfg = { retries: 0, label: '' };
cfg.retries || 3; // 3  (bug)
cfg.retries ?? 3; // 0

const cart = { id: 'c1', items: [{ sku: 'A', qty: 1 }] };
const next = { ...cart };
next.items[0].qty = 5;
console.log(cart.items[0].qty); // ?

setTimeout(() => console.log('t1'), 0);
Promise.resolve().then(() => {
  console.log('p1');
  setTimeout(() => console.log('t2'), 0);
  Promise.resolve().then(() => console.log('p2'));
});
Promise.resolve().then(() => console.log('p3'));
console.log('s');

class Counter {
  count = 0;
  inc() { this.count++; }
}
const c = new Counter();
const { inc } = c;
try { inc(); } catch (e) { console.log((e as Error).constructor.name); }
setTimeout(c.inc, 0);

async function f() {
  try { return Promise.reject(new Error('x')); } catch { return 'caught'; }
}
async function g() {
  try { return await Promise.reject(new Error('x')); } catch { return 'caught'; }
}
// f() → ?   g() → ?

0.1 + 0.2;                                   // 0.30000000000000004
JSON.parse('{"id":9007199254740993}').id;    // 9007199254740992
new Intl.NumberFormat('vi-VN', { style: 'currency', currency: 'VND' }).format(125000);

async function* products(client: Api, signal?: AbortSignal) {
  let cursor: string | undefined;
  do {
    const page = await client.list({ cursor, limit: 100, signal });
    yield* page.items;
    cursor = page.nextCursor;
  } while (cursor);
}

for await (const p of products(api)) {
  await indexer.push(p);   // natural backpressure: next page fetched only when needed
  if (done()) break;       // break → generator's finally/return runs
}

async function getJson<T>(url: string, parent?: AbortSignal): Promise<T> {
  const signal = AbortSignal.any([AbortSignal.timeout(3000), ...(parent ? [parent] : [])]);
  const res = await fetch(url, { signal });
  if (!res.ok) throw new Error(`HTTP ${res.status}`, { cause: { url, status: res.status } });
  return res.json() as Promise<T>;
}

// counter.mjs                     // counter.cjs
export let count = 0;              let count = 0;
export function inc() { count++; } module.exports = { count, inc: () => { count++; } };

// main.mjs                        // main.cjs
import { count, inc } from './counter.mjs';
inc(); console.log(count);         const { count, inc } = require('./counter.cjs');
                                   inc(); console.log(count);

// API returns: { "deliveryDate": "2026-03-08" }
const d = new Date(order.deliveryDate);
label.textContent = `${d.getMonth() + 1}/${d.getDate()}`; // US users see 3/7

function sql(strings: TemplateStringsArray, ...values: unknown[]) {
  const text = strings.reduce((acc, s, i) => acc + s + (i < values.length ? `$${i + 1}` : ''), '');
  return { text, values };
}
const q = sql`SELECT * FROM orders WHERE tenant_id = ${tenantId} AND id = ${orderId}`;
// { text: 'SELECT * FROM orders WHERE tenant_id = $1 AND id = $2', values: [tenantId, orderId] }

class AppError extends Error {
  constructor(public code: string, message: string, options?: { cause?: unknown; status?: number }) {
    super(message, { cause: options?.cause });
    this.name = new.target.name;
  }
}
class NotFound extends AppError {}

try { await repo.get(id); }
catch (e) { throw new AppError('ORDER_LOAD_FAILED', 'Cannot load order', { cause: e }); }

function Elapsed() {
  const [sec, setSec] = useState(0);
  useEffect(() => {
    const id = setInterval(() => setSec(sec + 1), 1000);
    return () => clearInterval(id);
  }, []);
  return <span>{sec}s</span>;
}

async function processAll(items: Item[]) {
  for (const it of items) {
    await transform(it); // transform is sync work wrapped in an async function
  }
}

setTimeout(() => console.log('fired'), 30 * 24 * 3600 * 1000);
// (node) TimeoutOverflowWarning: 2592000000 does not fit into a 32-bit signed integer.
// Timeout duration was set to 1.   → prints "fired" almost immediately

// config.ts
import { log } from './logger';
export const config = { level: process.env.LOG_LEVEL ?? 'info' };
log('config loaded');

// logger.ts
import { config } from './config';
const threshold = config.level; // top-level read, added in the refactor
export function log(msg: string) { if (threshold !== 'silent') console.log(msg); }
// entry: import './config'

import { EventEmitter } from 'node:events';
const bus = new EventEmitter();

bus.on('order.created', async (order) => {
  await inventory.reserve(order); // may reject
});

try {
  bus.emit('order.created', order);
} catch (e) {
  logger.error(e); // never runs
}

function merge(target: any, src: any) {
  for (const key in src) {
    if (typeof src[key] === 'object' && src[key] !== null) {
      target[key] ??= {};
      merge(target[key], src[key]);
    } else {
      target[key] = src[key];
    }
  }
  return target;
}
merge(settings, JSON.parse('{"__proto__": {"isAdmin": true}}'));
console.log(({} as any).isAdmin); // true

async function run() {
  try {
    JSON.parse('{bad');                             // (1)
    setTimeout(() => { throw new Error('t'); }, 0);  // (2)
    doAsyncThing();                                  // (3) returns a rejected promise, not awaited
    await Promise.reject(new Error('a'));            // (4)
  } catch (e) {
    console.log('caught', (e as Error).message);
  }
}