Errors & Exceptions

const attempts = [
  () => undefinedVariable,                 // ReferenceError
  () => null.property,                     // TypeError
  () => (1).toFixed(200),                  // RangeError
  () => JSON.parse("{bad"),                // SyntaxError (at runtime, from JSON.parse)
  () => decodeURIComponent("%"),           // URIError
  () => { throw new Error("custom") },     // plain Error
]
for (const fn of attempts) {
  try {
    fn()
  } catch (err) {
    console.log(`${err.name}: ${err.message.split(",")[0]}`)
    console.log("   instanceof Error:", err instanceof Error, "| constructor:", err.constructor.name)
  }
}

function parseAge(input) {
  try {
    const n = Number(input)
    if (Number.isNaN(n)) throw new TypeError(`"${input}" is not a number`)
    if (n < 0 || n > 150) throw new RangeError(`${n} is not a plausible age`)
    return n
  } catch (err) {
    if (err instanceof RangeError) return null            // handle what you can
    throw err                                             // re-throw what you cannot
  } finally {
    console.log("  (checked", JSON.stringify(input) + ")")    // always runs
  }
}

console.log(parseAge("36"))
console.log(parseAge("200"))
try {
  parseAge("abc")
} catch (err) {
  console.log("caller got:", err.name, "—", err.message)
}

// Optional catch binding when you do not need the error
function safeJson(text) {
  try { return JSON.parse(text) } catch { return null }
}
console.log(safeJson('{"ok":true}'), safeJson("nope"))

// finally runs even after return, and it should not itself return
function withCleanup() {
  try { return "result" } finally { console.log("cleanup") }
}
console.log(withCleanup())

class AppError extends Error {
  constructor(message, options) {
    super(message, options)
    this.name = this.constructor.name      // "NotFoundError", not "Error"
  }
}
class NotFoundError extends AppError {
  constructor(what, id) {
    super(`${what} ${id} not found`)
    this.status = 404
  }
}
class ValidationError extends AppError {
  constructor(field, problem) {
    super(`${field}: ${problem}`)
    this.status = 400
    this.field = field
  }
}

const db = new Map([[1, { id: 1, email: "[email protected]" }]])
function getUser(id) {
  if (!Number.isInteger(id)) throw new ValidationError("id", "must be an integer")
  const user = db.get(id)
  if (!user) throw new NotFoundError("user", id)
  return user
}

for (const id of [1, 2, "x"]) {
  try {
    console.log("ok", getUser(id).email)
  } catch (err) {
    if (err instanceof NotFoundError) console.log(err.status, err.message)
    else if (err instanceof ValidationError) console.log(err.status, err.field, "→", err.message)
    else throw err
  }
}

// Wrapping with cause keeps the original
function loadConfig() {
  try {
    JSON.parse("{bad")
  } catch (e) {
    throw new AppError("config.json is unreadable", { cause: e })
  }
}
try { loadConfig() } catch (e) { console.log(e.name + ":", e.message, "| cause:", e.cause.name) }

// Never throw strings — no stack, no name, instanceof fails
try { throw "oops" } catch (e) { console.log(typeof e, e instanceof Error, e.stack) }

function formatName(user) {
  return user.name.toUpperCase()
}
function listUsers(users) {
  return users.map(u => formatName(u))
}

try {
  listUsers([{ name: "ada" }, {}])
} catch (err) {
  // The first line of the stack is the message; the rest is the frames
  const [first, ...frames] = err.stack.split("\n")
  console.log(first)
  console.log("frames:", frames.length > 0 ? "present — top one is the throw site" : "none")
}

// Error.captureStackTrace-free tip: log the object, not just the message
try {
  null.x
} catch (err) {
  console.log("message only:", err.message)
  console.log("full:", err.name, "| has stack:", typeof err.stack === "string")
}

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

// 1. try/catch does NOT catch a throw inside a later callback
try {
  setTimeout(() => { try { throw new Error("in timer") } catch (e) { console.log("caught inside the callback:", e.message) } }, 0)
} catch (e) {
  console.log("never here")
}

// 2. In a promise chain, a throw becomes a rejection; one catch at the end covers all
Promise.resolve()
  .then(() => { throw new Error("step 2 failed") })
  .then(() => console.log("skipped"))
  .catch(e => console.log("chain caught:", e.message))

// 3. With async/await, try/catch works again
async function load() {
  await sleep(5)
  throw new Error("load failed")
}
async function main() {
  try {
    await load()
  } catch (e) {
    console.log("await caught:", e.message)
  }
}
main()

// 4. Missing await = the try/catch is useless
async function main2() {
  try {
    const p = load()            // returns a rejected promise; nobody awaits it
    p.catch(e => console.log("only a handler on the promise itself sees:", e.message))
  } catch (e) {
    console.log("never here either")
  }
}
main2()

// 5. Promise.all fails fast; allSettled reports each
const tasks = [sleep(5).then(() => "a"), sleep(5).then(() => { throw new Error("b failed") })]
Promise.all(tasks).catch(e => console.log("all:", e.message))
Promise.allSettled(tasks).then(r => console.log("allSettled:", r.map(x => x.status)))