any và unknown trong TypeScript: khác nhau, khi nào dùng

any và unknown đều nhận mọi giá trị. Điểm khác nhau là bạn làm được gì với giá trị đó sau này: any cho phép làm mọi thứ và không kiểm tra gì, còn unknown gần như không cho làm gì cho đến khi bạn chứng minh được giá trị đó là gì.

let a: any = "hello";
let u: unknown = "hello";

console.log(a.toUpperCase()); // HELLO: any allows every operation

// @ts-expect-error: 'u' is of type 'unknown'.
u.toUpperCase();

if (typeof u === "string") {
  console.log(u.toUpperCase()); // HELLO: u is a string inside this block
}

Nếu không có dòng @ts-expect-error, u.toUpperCase() là lỗi biên dịch TS18046. Phép kiểm tra typeof thu hẹp u thành string, và bên trong khối đó mọi phương thức của chuỗi đều dùng được.

So sánh nhanh any và unknown

Theo lý thuyết kiểu, unknown là top type: mọi kiểu đều gán được cho nó, còn nó chỉ gán được cho unknown và any. any là một lối thoát gán được theo cả hai chiều, cho mọi kiểu trừ never.

any tắt kiểm tra kiểu

Một giá trị có kiểu any được tin tưởng mù quáng. Trình biên dịch chấp nhận lỗi gõ sai, sai kiểu và thiếu thuộc tính, và các lỗi đó sẽ lộ ra lúc runtime.

const user: any = { name: "Ada" };

const total: number = user.name; // compiles: any is assignable to number
console.log(typeof total);       // string

const city = user.adress;        // typo, still compiles
console.log(city);               // undefined

try {
  console.log(user.address.city); // compiles, throws at runtime
} catch (e) {
  console.log((e as Error).message);
}

Kết quả cho thấy vấn đề: một biến được chú thích là number lại chứa chuỗi, và dòng cuối ném ra lỗi Cannot read properties of undefined (reading 'city'). any còn lây lan. user.name là any, nên mọi giá trị tính từ nó cũng là any, và chỉ một giá trị không có kiểu cũng có thể tắt kiểm tra ở những chỗ cách xa nơi nó đi vào.

unknown buộc bạn kiểm tra trước

Với unknown, trình biên dịch từ chối mọi thao tác cho đến khi code thu hẹp giá trị. Việc thu hẹp (narrowing) dùng các phép kiểm tra JavaScript thông thường, và bên trong mỗi nhánh, giá trị mang kiểu đã được kiểm tra.

function describe(value: unknown): string {
  if (typeof value === "string") return `string of length ${value.length}`;
  if (typeof value === "number") return `number ${value.toFixed(2)}`;
  if (Array.isArray(value)) return `array of ${value.length}`;
  if (value instanceof Date) return `date ${value.toISOString()}`;
  if (value === null) return "null";
  if (typeof value === "object" && "id" in value) return `object with id ${String(value.id)}`;
  return typeof value;
}

console.log(describe("hi"));                               // string of length 2
console.log(describe(3.14159));                            // number 3.14
console.log(describe([1, 2, 3]));                          // array of 3
console.log(describe(new Date("2024-03-15T10:30:00Z")));   // date 2024-03-15T10:30:00.000Z
console.log(describe({ id: 7 }));                          // object with id 7
console.log(describe(undefined));                          // undefined

Phép kiểm tra value === null phải đứng trước phép kiểm tra object vì typeof null là "object". Sau "id" in value, TypeScript biết object có thuộc tính id, với kiểu unknown, vì không có gì cho biết nó chứa gì. String() chuyển nó thành chuỗi một cách tường minh; để dùng nó như một số, bạn cần kiểm tra bằng typeof trước.

Bạn cũng có thể bỏ qua phép kiểm tra bằng một assertion, value as string, và trình biên dịch sẽ chấp nhận. Đó là một lời hứa không có kiểm tra nào lúc runtime đứng sau, nên hãy ưu tiên kiểm tra thật; xem type assertion.

Kiểm tra JSON với unknown

JSON.parse được khai báo trả về any, nên kết quả của nó âm thầm tắt kiểm tra. Hãy chú thích kết quả là unknown và viết một type guard kiểm tra cấu trúc trước khi phần còn lại của code tin tưởng nó.

interface Settings {
  theme: string;
  fontSize: number;
}

function isSettings(v: unknown): v is Settings {
  return (
    typeof v === "object" && v !== null &&
    "theme" in v && typeof v.theme === "string" &&
    "fontSize" in v && typeof v.fontSize === "number"
  );
}

const inputs = ['{"theme":"dark","fontSize":14}', '{"theme":"dark"}'];

for (const text of inputs) {
  const data: unknown = JSON.parse(text);
  if (isSettings(data)) {
    console.log(`${data.theme} at ${data.fontSize}px`);
  } else {
    console.log("invalid settings:", text);
  }
}

Đầu vào đầu tiên in ra dark at 14px, đầu vào thứ hai bị từ chối vì thiếu fontSize. Nếu dùng any, đầu vào thứ hai sẽ lọt qua như một Settings với fontSize là undefined. Với schema lớn, một thư viện kiểm tra dữ liệu làm cùng việc này và tự suy ra kiểu cho bạn.

noImplicitAny

any không chỉ đến từ việc ai đó viết ra. Một tham số không có chú thích kiểu và không có ngữ cảnh để suy luận cũng sẽ là any. Tùy chọn noImplicitAny, được strict bật lên, báo đó là lỗi:

// This does not compile: x has no type
function double(x) {
  return x * 2;
}

console.log(double(4));

index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type.

Cách sửa là thêm chú thích kiểu, function double(x: number). Viết x: any tường minh cũng biên dịch được, và đó chính là mục đích: any vẫn hiện rõ trong code, có thể tìm kiếm và review.

Những chỗ any vẫn lén lọt vào

Ngay cả với strict, những nguồn sau vẫn tạo ra any mà không có chữ đó trong code của bạn:

Biến trong catch là unknown khi bật strict vì bất cứ thứ gì cũng có thể bị ném ra, không chỉ đối tượng Error. Hãy thu hẹp nó bằng e instanceof Error trước khi đọc e.message.

Khi nào dùng any là chấp nhận được

any không bị cấm, nhưng mỗi chỗ dùng nó là một chỗ trình biên dịch không còn bảo vệ. Những trường hợp hợp lý:

• Chuyển đổi một codebase JavaScript, nơi any đánh dấu phần chưa có kiểu.
• Code mà hệ thống kiểu khó diễn đạt, được giữ nhỏ và nằm sau một chữ ký hàm có kiểu rõ ràng.
• Code test cố tình truyền dữ liệu sai.

Với mọi trường hợp khác, unknown xử lý cùng tình huống "không biết kiểu của giá trị" mà vẫn giữ các phép kiểm tra. Nhiều nhóm áp dụng điều này bằng quy tắc lint @typescript-eslint/no-explicit-any. Một kiểu liên quan, Record<string, unknown>, là lựa chọn thường dùng cho "một object có các giá trị không rõ kiểu".