Xử lý lỗi và các pattern phòng thủ

const err = new Error('Something broke');

err.name;     // 'Error'      — tên loại
err.message;  // 'Something broke' — chuỗi cho người đọc
err.stack;    // 'Error: Something broke\n    at :1:13\n ...' — vị trí throw

// throw nó để dừng chương trình (cho đến khi có catch)
throw err;

// TypeError
const x = null;
x.foo;  // TypeError: Cannot read properties of null (reading 'foo')

// RangeError
new Array(-1);  // RangeError: Invalid array length

// SyntaxError (runtime, từ JSON.parse)
JSON.parse('not json');  // SyntaxError: Unexpected token 'o'

// ReferenceError
console.log(notDeclared);  // ReferenceError: notDeclared is not defined

try {
  JSON.parse('xx');
} catch (e) {
  if (e instanceof SyntaxError) {
    console.log('JSON sai cú pháp');
  } else if (e instanceof Error) {
    console.log('Lỗi khác:', e.message);
  }
}

function divide(a, b) {
  if (b === 0) throw new Error('Division by zero');
  return a / b;
}

try {
  const r = divide(10, 0);
  console.log('kết quả:', r);     // không chạy
} catch (e) {
  console.error('lỗi:', e.message); // 'lỗi: Division by zero'
} finally {
  console.log('luôn chạy');          // chạy
}

function readFile(path) {
  const file = openFile(path);
  try {
    return file.readAll();          // có return — finally vẫn chạy
  } catch (e) {
    throw new Error(`Read failed: ${e.message}`); // re-throw — finally vẫn chạy
  } finally {
    file.close();                  // ✅ luôn đóng file
  }
}

// Cũ:
try { JSON.parse(input); }
catch (e) { return null; }   // `e` không dùng nhưng vẫn phải khai báo

// ES2019:
try { JSON.parse(input); }
catch { return null; }       // ✅ không cần (e)

class ValidationError extends Error {
  constructor(field, message) {
    super(message);          // gọi Error constructor — set this.message
    this.name = 'ValidationError';  // override để log đẹp + instanceof
    this.field = field;       // thêm thông tin nghiệp vụ
  }
}

class NotFoundError extends Error {
  constructor(resource) {
    super(`${resource} not found`);
    this.name = 'NotFoundError';
    this.resource = resource;
  }
}

// Sử dụng
function getUser(id) {
  if (typeof id !== 'number') {
    throw new ValidationError('id', 'id phải là number');
  }
  const u = db.find(id);
  if (!u) throw new NotFoundError('User');
  return u;
}

// Caller dispatch theo loại
try {
  getUser('abc');
} catch (e) {
  if (e instanceof ValidationError) {
    ui.showFieldError(e.field, e.message);
  } else if (e instanceof NotFoundError) {
    ui.show404();
  } else {
    ui.showGenericError();
    reportToSentry(e);
  }
}

async function loadUser(id) {
  try {
    const res = await fetch(`/api/users/${id}`);
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return await res.json();
  } catch (e) {
    console.error('loadUser failed:', e);
    throw e;   // re-throw cho caller cao hơn
  }
}

// Promise chain
function loadUserChain(id) {
  return fetch(`/api/users/${id}`)
    .then(res => {
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return res.json();
    })
    .catch(e => {
      console.error('loadUser failed:', e);
      throw e;
    });
}

async function bad() {
  try {
    foo();   // ❌ quên await — Promise reject không bị bắt
  } catch (e) {
    console.log('never reaches here');
  }
}

async function good() {
  try {
    await foo();   // ✅
  } catch (e) {
    console.log('caught', e);
  }
}

// ✅ Cách 1: re-throw
try { risky(); }
catch (e) {
  logger.error('risky failed', e);
  throw e;
}

// ✅ Cách 2: recover với default
function safeParse(s) {
  try { return JSON.parse(s); }
  catch { return {}; }   // chấp nhận parse fail → object rỗng
}

// ✅ Cách 3: return error state (Result type)
async function submit() {
  try {
    await api.save(data);
    return { ok: true };
  } catch (e) {
    return { ok: false, error: e };
  }
}

// Type: { ok: true, value: T } | { ok: false, error: E }

function ok(value)  { return { ok: true,  value }; }
function err(error) { return { ok: false, error }; }

function parseAge(input) {
  const n = Number(input);
  if (Number.isNaN(n)) return err('not a number');
  if (n < 0) return err('negative');
  if (n > 150) return err('too large');
  return ok(n);
}

// Caller buộc phải check .ok trước khi truy cập value/error
const r = parseAge(input);
if (r.ok) {
  console.log('Tuổi:', r.value);
} else {
  console.log('Lỗi:', r.error);
}

// ❌ Lazy — check muộn, có thể đã ghi DB rồi mới phát hiện
async function createOrder(items, userId) {
  await db.orders.insert({ items, userId });
  await billing.charge(userId, sum(items));   // quá muộn nếu items rỗng
}

// ✅ Fail-fast — validate trước, chỉ ghi khi chắc
async function createOrder(items, userId) {
  if (!Array.isArray(items) || items.length === 0) {
    throw new ValidationError('items', 'phải có ít nhất 1 sản phẩm');
  }
  if (typeof userId !== 'number') {
    throw new ValidationError('userId', 'phải là number');
  }

  await db.orders.insert({ items, userId });
  await billing.charge(userId, sum(items));
}

// ❌ Mutate input — surprise bug
function addTimestamp(obj) {
  obj.timestamp = Date.now();
  return obj;
}

const user = { name: 'An' };
addTimestamp(user);
console.log(user);  // { name: 'An', timestamp: ... } 🔥 caller bị mutate

// ✅ Defensive copy — clone trước
function addTimestamp(obj) {
  return { ...obj, timestamp: Date.now() };
}

// Cho object lồng nhau, dùng structuredClone (hiện đại) hoặc deepClone lib
function deepUpdate(obj, path, value) {
  const clone = structuredClone(obj);
  _.set(clone, path, value);
  return clone;
}

// Bắt sync error không catch
window.addEventListener('error', (event) => {
  console.error('Uncaught error:', event.error);
  reportToServer({
    type: 'error',
    message: event.message,
    filename: event.filename,
    lineno: event.lineno,
    stack: event.error?.stack,
  });
});

// Bắt promise reject không catch
window.addEventListener('unhandledrejection', (event) => {
  console.error('Unhandled rejection:', event.reason);
  reportToServer({
    type: 'unhandledrejection',
    reason: String(event.reason),
    stack: event.reason?.stack,
  });
});

process.on('uncaughtException', (err) => {
  logger.fatal({ err }, 'Uncaught exception');
  // Process ở state không chắc chắn — gracefully exit
  process.exit(1);
});

process.on('unhandledRejection', (reason) => {
  logger.error({ reason }, 'Unhandled promise rejection');
  // Từ Node 15+: mặc định cũng exit. Có thể override.
});

class ErrorBoundary extends React.Component {
  state = { hasError: false, error: null };

  static getDerivedStateFromError(error) {
    return { hasError: true, error };
  }

  componentDidCatch(error, info) {
    reportToSentry(error, { extra: info });
  }

  render() {
    if (this.state.hasError) {
      return <FallbackUI error={this.state.error} />;
    }
    return this.props.children;
  }
}

// Bọc khu vực rủi ro:
<ErrorBoundary>
  <UserDashboard />
</ErrorBoundary>

const err = new Error('oops');

// ❌ Tệ — mất hết info
JSON.stringify(err);                  // '{}' 🔥

// ✅ Đúng — extract field tay
JSON.stringify({
  name: err.name,
  message: err.message,
  stack: err.stack,
});

// ✅ Hoặc dùng helper:
function serializeError(err) {
  if (!(err instanceof Error)) return { value: String(err) };
  return {
    name: err.name,
    message: err.message,
    stack: err.stack,
    ...err,   // spread bao luôn custom properties
  };
}

// ✅ Console.log nhận Error object trực tiếp — devtools format đẹp
console.error(err);   // hiển thị stack + clickable line