Try catch trong TypeScript: kiểu lỗi và lỗi tùy chỉnh

TypeScript dùng try, catch, finally và throw của JavaScript. Phần riêng của TypeScript nằm ở biến của catch: khi bật strict, nó có kiểu unknown, nên bạn phải kiểm tra thứ được ném ra trước khi dùng.

function parsePort(text: string): number {
    const port = Number(text);
    if (!Number.isInteger(port) || port < 1 || port > 65535) {
        throw new RangeError(`invalid port: "${text}"`);
    }
    return port;
}

try {
    console.log(parsePort("8080")); // 8080
    console.log(parsePort("http")); // throws
} catch (e) {
    // e: unknown
    if (e instanceof Error) {
        console.log(`${e.name}: ${e.message}`); // RangeError: invalid port: "http"
    }
} finally {
    console.log("done");
}

Phần lúc chạy (cách stack được gỡ ra, có những kiểu lỗi có sẵn nào) được trình bày trong try/catch trong JavaScript.

Vì sao biến của catch có kiểu unknown

JavaScript có thể ném ra bất cứ thứ gì: một Error, một chuỗi, một số, undefined, một đối tượng từ thư viện. TypeScript không thể biết là thứ nào, nên khi bật strict (cờ useUnknownInCatchVariables), biến này có kiểu unknown và bạn phải thu hẹp nó trước khi dùng:

// This does not compile: e is unknown, so e.message is not allowed.
try {
    JSON.parse("{ broken");
} catch (e) {
    console.log("parse failed:", e.message);
}

index.ts(5,34): error TS18046: 'e' is of type 'unknown'.

Không có strict, e có kiểu any và cùng đoạn code đó biên dịch được, rồi hỏng lúc chạy khi một chuỗi bị ném ra: e.message là undefined, và bất cứ thứ gì sâu hơn, như e.message.length, sẽ ném ra TypeError. Bạn cũng không thể thoát bằng cách chú thích kiểu: catch (e: Error) gây lỗi TS1196 (Catch clause variable type annotation must be 'any' or 'unknown' if specified).

Thu hẹp kiểu của lỗi

instanceof Error bao quát mọi thứ xây dựng trên Error, gồm TypeError, SyntaxError, RangeError và các lớp con do bạn tự viết. Với những thứ còn lại, hãy chuyển giá trị thành chuỗi. Một hàm trợ giúp nhỏ giúp chỗ gọi gọn gàng:

function toError(value: unknown): Error {
    if (value instanceof Error) return value;
    if (typeof value === "string") return new Error(value);
    return new Error(`non-error thrown: ${JSON.stringify(value)}`);
}

const throwers: Array<() => void> = [
    () => JSON.parse("{"),
    () => { throw "plain string"; },
    () => { throw { code: 42 }; },
];

for (const run of throwers) {
    try {
        run();
    } catch (e) {
        const err = toError(e);
        console.log(err.constructor.name, "|", err.message);
    }
}
// SyntaxError | Expected property name or '}' in JSON at position 1 (line 1 column 2)
// Error | plain string
// Error | non-error thrown: {"code":42}

Một catch chỉ xử lý một số lỗi thì nên ném lại phần còn lại: if (!(e instanceof ValidationError)) throw e;. Nuốt mất những lỗi chưa biết sẽ che giấu các bug thật.

Ném lỗi

throw nhận bất kỳ biểu thức nào, và TypeScript không giới hạn điều đó. Dù vậy, hãy ném đối tượng Error: chúng mang theo stack trace, và mọi phép kiểm tra instanceof Error trong codebase đều dựa vào điều này.

Một hàm luôn ném lỗi có kiểu trả về never, và TypeScript dùng điều đó để thu hẹp kiểu sau lời gọi:

function fail(message: string): never {
    throw new Error(message);
}

function getEnv(env: Record<string, string | undefined>, key: string): string {
    const value = env[key];
    if (value === undefined) fail(`missing ${key}`);
    return value; // value: string, because fail() never returns
}

const env = { HOME: "/home/ada" };
console.log(getEnv(env, "HOME")); // /home/ada
try {
    getEnv(env, "PORT");
} catch (e) {
    if (e instanceof Error) console.log(e.message); // missing PORT
}

Từ ES2022, Error nhận đối số thứ hai có cause, dùng để nối một lỗi cấp thấp vào lỗi bạn ném ra: throw new Error("could not load settings", { cause: e }). Nơi gọi có thể đọc err.cause (kiểu unknown).

Lớp lỗi tùy chỉnh

Một lớp con của Error giúp nơi gọi phân biệt các lỗi bằng instanceof và mang theo dữ liệu bổ sung. Hãy đặt name, vì giá trị kế thừa là "Error" và nó xuất hiện trong log cũng như trong String(err):

class HttpError extends Error {
    override name = "HttpError";

    constructor(readonly status: number, message: string, options?: ErrorOptions) {
        super(message, options);
    }
}

class NotFoundError extends HttpError {
    override name = "NotFoundError";

    constructor(resource: string) {
        super(404, `${resource} not found`);
    }
}

function handle(e: unknown): string {
    if (e instanceof NotFoundError) return `404 page for: ${e.message}`;
    if (e instanceof HttpError) return `HTTP ${e.status}: ${e.message}`;
    if (e instanceof Error) return `unexpected: ${e.message}`;
    return "unknown failure";
}

console.log(handle(new NotFoundError("user 7"))); // 404 page for: user 7 not found
console.log(handle(new HttpError(503, "maintenance"))); // HTTP 503: maintenance
console.log(handle(new TypeError("oops")));        // unexpected: oops

const wrapped = new HttpError(500, "db down", { cause: new Error("timeout") });
const cause = wrapped.cause; // unknown
console.log(String(wrapped), "| cause:", cause instanceof Error ? cause.message : cause);
// HttpError: db down | cause: timeout

Kiểm tra lớp cụ thể nhất trước, vì một NotFoundError cũng là một HttpError. Từ khóa override ở đây là tùy chọn, trừ khi bật noImplicitOverride.

Các hướng dẫn cũ thêm Object.setPrototypeOf(this, new.target.prototype) vào mọi hàm khởi tạo lỗi. Điều đó cần thiết khi biên dịch lớp xuống hàm ES5, lúc instanceof bị hỏng với lớp con của Error. TypeScript 7 không còn hỗ trợ target: "es5" (nó báo TS5108: Option 'target=ES5' has been removed), và với ES2015 trở lên thì class ... extends Error gốc hoạt động bình thường, như ở trên.

Mẫu Result

TypeScript không theo dõi những lỗi mà một hàm có thể ném ra, nên không có gì nhắc nơi gọi xử lý chúng. Với những lỗi đã lường trước (đầu vào không hợp lệ, thiếu một bản ghi), trả về một giá trị cho biết "thành công hay thất bại" sẽ đưa lỗi vào hệ thống kiểu:

type Result<T, E = string> =
    | { ok: true; value: T }
    | { ok: false; error: E };

function parseAge(input: string): Result<number> {
    const n = Number(input);
    if (!Number.isInteger(n)) return { ok: false, error: `"${input}" is not a whole number` };
    if (n < 0 || n > 150) return { ok: false, error: `${n} is out of range` };
    return { ok: true, value: n };
}

for (const input of ["36", "abc", "200"]) {
    const r = parseAge(input);
    if (r.ok) {
        console.log("age:", r.value + 1); // r.value only exists when ok is true
    } else {
        console.log("error:", r.error);
    }
}
// age: 37
// error: "abc" is not a whole number
// error: 200 is out of range

Đọc r.value trước khi kiểm tra r.ok là lỗi biên dịch, và đó chính là mục đích. Dùng ngoại lệ (exception) cho những điều bất ngờ (bug, kết nối bị đứt) và giá trị Result cho những kết quả mà nơi gọi phải tự quyết định.

Lỗi trong code bất đồng bộ

Một promise bị từ chối trở thành lỗi được ném ra tại await, nên try/catch bao quanh await hoạt động theo cùng cách, và biến lỗi lại có kiểu unknown. Khác biệt duy nhất là .catch() trên một promise: tham số của callback có kiểu any, không phải unknown, nên bạn tự chú thích kiểu (.catch((e: unknown) => ...)). Xem async/await để có ví dụ.

Lỗi thường gặp

• Đọc e.message mà không thu hẹp kiểu. Khi bật strict thì code không biên dịch được; không có strict thì hỏng khi thứ bị ném ra không phải Error.
• Bắt mọi lỗi rồi chạy tiếp. Xử lý những lỗi bạn đã lường trước và ném lại phần còn lại.
• Quên đặt name cho lỗi tùy chỉnh. Khi đó log ghi Error cho tất cả.
• Ném chuỗi. throw "failed" không có stack trace và không qua được phép kiểm tra instanceof Error.