any vs unknown TypeScript: Perbedaan dan Kapan Dipakai

any dan unknown sama-sama menerima semua nilai. Bedanya ada pada apa yang bisa kamu lakukan dengan nilai itu setelahnya: any membolehkan apa saja tanpa memeriksa apa pun, sedangkan unknown hampir tidak membolehkan apa-apa sampai kamu membuktikan nilai itu apa.

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
}

Tanpa baris @ts-expect-error, u.toUpperCase() adalah error kompilasi TS18046. Pemeriksaan typeof mempersempit u menjadi string, dan di dalam blok itu semua method string tersedia.

Sekilas any vs unknown

Dalam istilah teori tipe, unknown adalah top type: setiap tipe bisa diberikan kepadanya, dan ia hanya bisa diberikan ke unknown dan any. any adalah jalan pintas yang berlaku dua arah, bisa diberikan ke semua tipe kecuali never.

any Mematikan Pemeriksaan Tipe

Nilai bertipe any dipercaya begitu saja. Compiler menerima salah ketik, tipe yang salah, dan property yang tidak ada, lalu kesalahannya baru muncul saat 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);
}

Output-nya memperlihatkan masalahnya: variabel yang dianotasi number berisi string, dan baris terakhir melempar Cannot read properties of undefined (reading 'city'). any juga menyebar. user.name bertipe any, jadi nilai apa pun yang dihitung darinya juga any, dan satu nilai tanpa tipe bisa mematikan pemeriksaan jauh dari tempat ia masuk.

unknown Mewajibkanmu Memeriksa Dulu

Dengan unknown, compiler menolak semua operasi sampai kode mempersempit nilainya. Mempersempit memakai pemeriksaan JavaScript biasa, dan di dalam setiap cabang nilainya punya tipe yang sudah diperiksa.

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

Pemeriksaan value === null harus datang sebelum pemeriksaan objek karena typeof null adalah "object". Setelah "id" in value, TypeScript tahu objek itu punya property id, bertipe unknown karena tidak ada yang menyebutkan isinya. String() mengubahnya menjadi teks secara eksplisit; untuk memakainya sebagai angka, kamu perlu memeriksanya dengan typeof dulu.

Kamu juga bisa melewati pemeriksaan dengan assertion, value as string, dan compiler akan menerimanya. Itu janji tanpa pemeriksaan runtime di belakangnya, jadi pilih pemeriksaan sungguhan; lihat type assertion.

Memvalidasi JSON dengan unknown

JSON.parse dideklarasikan mengembalikan any, jadi hasilnya diam-diam mematikan pemeriksaan. Beri anotasi unknown pada hasilnya dan tulis type guard yang memeriksa bentuknya sebelum kode lainnya memercayainya.

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);
  }
}

Input pertama mencetak dark at 14px, sedangkan yang kedua ditolak karena fontSize tidak ada. Dengan any, input kedua akan lolos sebagai Settings dengan fontSize bernilai undefined. Untuk skema yang besar, library validasi melakukan pekerjaan yang sama dan menurunkan tipenya untukmu.

noImplicitAny

any tidak hanya muncul karena ada yang menuliskannya. Parameter tanpa anotasi dan tanpa konteks untuk inferensi juga akan menjadi any. Opsi noImplicitAny, yang dinyalakan oleh strict, melaporkannya sebagai error:

// 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.

Perbaikannya adalah anotasi, function double(x: number). Menulis x: any secara eksplisit juga bisa dikompilasi, dan memang itu intinya: any tetap terlihat di kode, sehingga bisa dicari dan ditinjau.

Tempat any Masih Diam-diam Masuk

Bahkan dengan strict, hal-hal berikut menghasilkan any tanpa kata itu muncul di kodemu:

Variabel catch bertipe unknown dengan strict karena apa pun bisa dilempar, bukan hanya objek Error. Persempit dengan e instanceof Error sebelum membaca e.message.

Kapan any Bisa Diterima

any tidak dilarang, tetapi setiap pemakaiannya adalah titik yang tidak lagi dilindungi compiler. Pemakaian yang wajar:

• Migrasi codebase JavaScript, di mana any menandai bagian yang belum diberi tipe.
• Kode yang tidak bisa diekspresikan dengan baik oleh sistem tipe, dijaga tetap kecil dan berada di balik signature fungsi yang bertipe.
• Kode tes yang sengaja mengirim data yang salah.

Untuk semua hal lainnya, unknown menangani kasus "aku tidak tahu tipe ini" yang sama sambil tetap menjaga pemeriksaannya. Banyak tim menegakkan ini dengan aturan lint @typescript-eslint/no-explicit-any. Tipe yang terkait, Record<string, unknown>, adalah pilihan umum untuk "objek dengan nilai yang tidak diketahui".