TypeScript as: Type Assertion ve Tip Dönüşümü (Cast)

value as Type bir type assertion'dır: TypeScript'e value değerini Type olarak ele almasını söyler. İnsanlar buna cast der, ama yalnızca derleyiciye verilen bir talimattır. JavaScript çıktısından silinir, çalışma zamanında hiçbir şeyi dönüştürmez ve hiçbir şeyi kontrol etmez.

interface Config {
  port: number;
  host: string;
}

const text = '{"port": 8080, "host": "localhost"}';

// JSON.parse returns any; the assertion gives the result a useful type
const config = JSON.parse(text) as Config;

console.log(config.port + 1);            // 8081
console.log(config.host.toUpperCase());  // LOCALHOST

Tipik kullanım budur: bir değer hakkında derleyicinin bilebileceğinden fazlasını biliyorsunuz (burada bir JSON'un biçimi) ve bunu söylüyorsunuz. Yanılıyorsanız hiçbir şey sizi uyarmaz. Sonraki bölümler bunun ne anlama geldiğini ve bir çalışma zamanı kontrolünün ne zaman daha iyi bir seçim olduğunu gösteriyor.

as ve Açılı Parantez Sözdizimi

Aynı assertion'ın iki yazılışı vardır:

const someValue: unknown = "hello";
const a = someValue as string;   // as syntax
const b = <string>someValue;     // angle-bracket syntax, same meaning

Açılı parantez biçimine, <string> ifadesinin bir JSX etiketi olarak okunacağı .tsx dosyalarında izin verilmez. Her yerde as kullanın, bu soru hiç gündeme gelmez. Assertion'lar gevşek bağlanır, bu yüzden ifadeye devam edecekseniz onları paranteze alın: (value as string).length.

Assertion'lar Değerleri Dönüştürmez

Gerçek hatalara yol açan kısım budur. Bir assertion, derleyicinin bir değer hakkında neye inandığını değiştirir, değerin kendisini değil:

const input: unknown = "42";

const asserted = input as number;  // compiles: unknown can be asserted to anything
const converted = Number(input);   // an actual conversion

console.log(asserted + 1);   // 421 (string concatenation: it is still "42")
console.log(converted + 1);  // 43
console.log(typeof asserted, typeof converted); // string number

Derleyici asserted değerinin bir number olduğuna inanır, bu yüzden asserted + 1 aritmetik olarak tip kontrolünden geçer. Çalışma zamanında hâlâ "42" string'idir ve JavaScript birleştirme yapar. Bir değerin tipini değiştirmek için onu dönüştürün: Number(x), String(x), Boolean(x), BigInt(x), new Date(x). Dönüşüm fonksiyonlarını string to number sayfası karşılaştırıyor.

Derleyicinin İzin Verdikleri

as sınırsız değildir. TypeScript, tiplerden biri diğerine atanabildiğinde x as T ifadesine izin verir: genişletme ("a" as string, dog as Animal) ve daraltma (animal as Dog, unknown as User) ikisi de uygundur. Tipler hiç örtüşmediğinde reddeder:

// This does not compile: string and number do not overlap.
const input = "42";
const n = input as number;

console.log(n);

Derleyici index.ts(3,11): error TS2352: Conversion of type 'string' to type 'number' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. bildirir. Mesajın kendisi kaçış kapısını söyler: input as unknown as number. Bu çift assertion derlenir ve çalışma zamanında yukarıdaki örnek kadar yanlıştır. Ona ihtiyaç duyduğunuzda doğru çözüm genellikle bir dönüşüm (Number(input)) ya da farklı bir tiptir.

Örtüşme kuralı nesneler için gevşektir. Özelliklerin bir kısmına sahip bir nesne literal'i kabul edilir; as eksik nesnelerin sessizce geçmesine bu şekilde izin verir:

interface User {
  name: string;
  email: string;
}

const draft = { name: "Ada" } as User; // compiles: email is missing
const empty = {} as User;              // compiles too

console.log(draft.name);               // Ada
console.log(typeof draft.email);       // undefined, although the type says string
console.log(empty.name?.length);       // undefined

Bir notasyon (const draft: User = { name: "Ada" }) ya da satisfies User eksik email özelliğini bildirirdi (TS2741). Bir nesne literal'inde as kullanımını yalnızca onu sonradan gerçekten dolduracaksanız yapın; eksiksiz nesneyi oluşturmayı tercih edin.

as const Farklıdır

as const bir assertion gibi görünür ama gevşetmenin tam tersini yapar: bir literal'i olabildiğince dar yapar. String'ler literal tip olarak kalır, diziler readonly tuple'lara dönüşür ve nesne özellikleri readonly olur.

const sizes = ["small", "medium", "large"] as const;
type Size = (typeof sizes)[number]; // "small" | "medium" | "large"

const point = { x: 1, y: 2 } as const; // { readonly x: 1; readonly y: 2 }

function isSize(value: string): value is Size {
  return (sizes as readonly string[]).includes(value);
}

console.log(isSize("medium"), isSize("huge")); // true false
console.log(point.x + point.y);                // 3

Güvenlidir, çünkü derleyicinin göremediği bir şeyi iddia etmek yerine literal'i tam olarak tanımlar. (isSize içindeki sizes as readonly string[] bir genişletme assertion'ıdır ve o da güvenlidir: includes metodunun her string'i kabul etmesini sağlar.) Daha fazlası için literal tipler sayfasına bakın.

Type Guard Ne Zaman Daha İyi Bir Araçtır

as bir iddiadır; bir type guard ise bir kontroldür. Verinin kodunuzun dışından geldiği bir sınırda (JSON, fetch, localStorage, kullanıcı girdisi, bir mesaj) iddia yanlış olabilir ve bir assertion, sınırdaki açık bir hatayı başka bir yerde kafa karıştırıcı bir hataya dönüştürür.

interface Point {
  x: number;
  y: number;
}

function isPoint(v: unknown): v is Point {
  return typeof v === "object" && v !== null &&
    "x" in v && typeof v.x === "number" &&
    "y" in v && typeof v.y === "number";
}

const raw: unknown = JSON.parse('{"x": 3, "y": "4"}');

// With as: compiles, and the bug surfaces later
const p1 = raw as Point;
console.log(p1.x + p1.y); // 34 (a string snuck in)

// With a guard: the bad data is caught where it enters
if (isPoint(raw)) console.log(raw.x + raw.y);
else console.log("invalid point");

Birbirine benzeyen araçlar için kaba bir rehber:

as için iki iyi kullanım kalır: derleyicinin izleyemediği bir şeyi daraltmak (iki satır önce ayarladığınız bir Map girdisi, tipsiz bir kütüphaneden gelen bir değer) ve eksik fixture'lar oluşturan test kodu. Onları küçük ve iddianın doğru olduğunu bildiğiniz yere yakın tutun.