Tipizzazione degli errori (unknown), restrizione nei blocchi catch

async function boom(): Promise<void> { throw new Error("boom") }

async function run() {
  try {
    await boom();
  } catch (e: unknown) {
    if (e instanceof Error) {
      console.error("Handled:", e.message);
    } else {
      console.error("Non-Error thrown:", e);
    }
  }
}

run();

function throwString() { throw "bad" }

try {
  throwString();
} catch (e: unknown) {
  if (typeof e === "string") {
    console.warn("string error:", e.toUpperCase());
  } else {
    console.warn("other error", e);
  }
}

type ErrorLike = { message: string; code?: string };

function isErrorLike(e: unknown): e is ErrorLike {
  return !!e && typeof e === "object" && "message" in e;
}

try {
  throw { message: "oops", code: "E_BAD" };
} catch (e: unknown) {
  if (isErrorLike(e)) {
    console.error(e.message, e.code ?? "no-code");
  } else {
    console.error("unknown error", e);
  }
}

function logErrorSafe(e: unknown): void {
  if (e instanceof Error) {
    console.error("Error:", e.message);
  } else if (typeof e === "string") {
    console.error("Error(string):", e);
  } else {
    try {
      console.error("Error(obj):", JSON.stringify(e));
    } catch {
      console.error("Error(unknown)");
    }
  }
}

try { throw { oops: true } } catch (e: unknown) { logErrorSafe(e) }