TypeScript any ve unknown Farkı: Hangisi Ne Zaman Kullanılır

any ve unknown her değeri kabul eder. Fark, sonrasında değerle neler yapabileceğinizdedir: any her şeyi yapmanıza izin verir ve hiçbir şeyi kontrol etmez; unknown ise değerin ne olduğunu kanıtlayana kadar neredeyse hiçbir şey yapmanıza izin vermez.

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
}

@ts-expect-error satırı olmadan u.toUpperCase() TS18046 derleme hatasıdır. typeof kontrolü u değerini string tipine daraltır ve o blok içinde her string metodu kullanılabilir.

Bir Bakışta any ve unknown

Tip teorisi açısından unknown en üst tiptir (top type): her tip ona atanabilir, o ise yalnızca unknown ve any tiplerine atanabilir. any ise iki yönde de atanabilen bir kaçış kapısıdır; never dışında her şeye atanabilir.

any Tip Kontrolünü Kapatır

any tipindeki bir değere körü körüne güvenilir. Derleyici yazım hatalarını, yanlış tipleri ve eksik özellikleri kabul eder; hatalar da bunun yerine çalışma zamanında ortaya çıkar.

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

Çıktı sorunu gösteriyor: number notasyonlu bir değişken bir string tutuyor ve son satır Cannot read properties of undefined (reading 'city') fırlatıyor. any ayrıca yayılır. user.name bir any değeridir, bu yüzden ondan hesaplanan her değer de any olur ve tipsiz tek bir değer, girdiği yerden çok uzakta kontrolü kapatabilir.

unknown Önce Kontrol Etmenizi İster

unknown ile derleyici, kod değeri daraltana kadar her işlemi reddeder. Daraltma sıradan JavaScript kontrollerini kullanır ve her dalın içinde değer kontrol edilen tipe sahiptir.

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

value === null kontrolü nesne kontrolünden önce gelmelidir, çünkü typeof null sonucu "object" olur. "id" in value sonrasında TypeScript nesnenin bir id özelliğine sahip olduğunu bilir; ne tuttuğunu söyleyen bir şey olmadığı için tipi unknown olur. String() onu açıkça metne çevirir; sayı olarak kullanmak için önce typeof ile kontrol etmeniz gerekirdi.

Kontrolü bir assertion ile de atlayabilirsiniz, value as string, derleyici bunu kabul eder. Bu, arkasında çalışma zamanı kontrolü olmayan bir sözdür; gerçek bir kontrolü tercih edin, bkz. type assertion'lar.

unknown ile JSON Doğrulamak

JSON.parse, any döndürecek şekilde bildirilmiştir, bu yüzden sonucu kontrolü sessizce devre dışı bırakır. Sonuca unknown notasyonu yazın ve kodun geri kalanı ona güvenmeden önce biçimini kontrol eden bir type guard yazı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);
  }
}

İlk girdi dark at 14px yazdırır, ikincisi fontSize eksik olduğu için reddedilir. any ile ikinci girdi, fontSize değeri undefined olan bir Settings olarak akıp giderdi. Büyük şemalar için bir doğrulama kütüphanesi aynı işi yapar ve tipi sizin için türetir.

noImplicitAny

any yalnızca birinin onu yazmasından gelmez. Notasyonu olmayan ve çıkarım yapılacak bağlamı bulunmayan bir parametre de any olurdu. strict tarafından açılan noImplicitAny seçeneği bunu bir hata olarak bildirir:

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

Çözüm bir notasyondur, function double(x: number). Açıkça x: any yazmak da derlenir; amaç da budur: any kodda görünür kalır, aranabilir ve incelenebilir.

any'nin Hâlâ Sızdığı Yerler

strict altında bile şunlar, kodunuzda bu kelime görünmeden any üretir:

strict altında catch değişkeni unknown olur, çünkü yalnızca Error nesneleri değil, her şey fırlatılabilir. e.message okumadan önce onu e instanceof Error ile daraltın.

any Ne Zaman Kabul Edilebilir

any yasak değildir, ama her biri derleyicinin artık korumadığı bir noktadır. Makul kullanımlar:

• Bir JavaScript kod tabanını taşırken, any henüz tiplenmemiş yerleri işaretler.
• Tip sisteminin iyi ifade edemediği kod; küçük tutulur ve tipli bir fonksiyon imzasının arkasında kalır.
• Bilerek hatalı veri gönderen test kodu.

Geri kalan her şey için unknown, kontrolleri koruyarak aynı "bu tipi bilmiyorum" durumunu karşılar. Pek çok ekip bunu @typescript-eslint/no-explicit-any lint kuralıyla zorunlu kılar. İlgili bir tip olan Record<string, unknown> ise "değerleri bilinmeyen bir nesne" için alışılmış seçimdir.