TypeScript Tip Çıkarımı (Type Inference): Ne Zaman Tip Yazılır

Tip çıkarımı (type inference), TypeScript'in sizin yazmadığınız bir tipi kendisinin bulmasıdır. Bir değişkene başlangıç değeri verin, değerin tipini alır; bir fonksiyondan bir değer döndürün, dönüş tipi de ona göre belirlenir. Çoğu TypeScript kodu, insanların beklediğinden çok daha az notasyon taşır.

let count = 0;            // number
let language = "TypeScript"; // string
let tags = ["ts", "js"];  // string[]
let user = { name: "Ada", age: 36 }; // { name: string; age: number }

function area(w: number, h: number) {
    return w * h;          // return type inferred as number
}

const size = area(3, 4);  // number
console.log(count, language, tags, user, size);

// The inferred types are enforced like written ones:
// @ts-expect-error: Type 'string' is not assignable to type 'number'.
count = "one";

Yorumlar, her adın üzerine geldiğinizde bir editörün gösterdiklerini gösteriyor. count hiç notasyon almamış olsa da son satır bir derleme hatasıdır (TS2322); // @ts-expect-error onu beklenen hata olarak işaretler, böylece bloğun geri kalanı çalışır.

let ile const: Literal Genişlemesi

Bir const asla değişemez, bu yüzden TypeScript ona en dar tipi verir: literal değerin kendisini. Bir let ise daha geniş tipi alır, çünkü daha sonra yeniden atanabilir.

let a = "left";    // string
const b = "left";  // "left"
let c = 42;        // number
const d = 42;      // 42
const e = true;    // true

Bu, bir fonksiyon yalnızca belirli değerleri kabul ettiğinde önem kazanır:

// This does not compile: `let` widened "left" to string.
function move(direction: "left" | "right") {
    console.log("moving", direction);
}

let dir = "left";
move(dir);

const fixed = "left";
move(fixed); // fine: fixed has type "left"

index.ts(7,6): error TS2345: Argument of type 'string' is not assignable to parameter of type '"left" | "right"'.

Bunu const ile ya da değişkene notasyon ekleyerek düzeltin: let dir: "left" | "right" = "left". Literal tiplerin kendi sayfası var: literal tipler.

Nesneler ve Diziler Üyelerini Genişletir

Bir nesne literal'inin özellikleri değiştirilebilir, bu yüzden nesnenin kendisi const olsa bile let gibi genişlerler. Dizi elemanları da aynısını yapar. as const her şeyi readonly yapar ve literal tipleri korur.

const config = { mode: "dark", retries: 3 };
// config: { mode: string; retries: number }
config.mode = "light"; // allowed: mode is string

const frozen = { mode: "dark", retries: 3 } as const;
// frozen: { readonly mode: "dark"; readonly retries: 3 }

const sizes = ["s", "m", "l"];            // string[]
const fixedSizes = ["s", "m", "l"] as const; // readonly ["s", "m", "l"]

console.log(config.mode, frozen.mode, sizes.length, fixedSizes[0]);

Dönüş Tipi Çıkarımı

Bir fonksiyonun dönüş tipi return ifadelerinden çıkarılır. Birden fazlası varsa sonuç onların union'ıdır.

function parsePort(text: string) {
    if (text === "") return null;
    return Number(text);
}
// parsePort returns number | null

const port = parsePort("8080");
if (port !== null) {
    console.log(port + 1); // 8081: port is number inside the check
}

function log(message: string) {
    console.log(message);
}
// log returns void: there is no return value

log("done");

Çıkarılan dönüş tipleri çoğu fonksiyon için yeterlidir. İmzanın bir sözleşme olmasını istediğinizde export edilen veya public fonksiyonlarda dönüş tipini açıkça yazın: gövdede farklı bir tip döndüren bir değişiklik o zaman uzaktaki bir çağıranda değil, fonksiyonun kendisinde hata verir.

Bağlamsal Tipler: Callback'ler Tiplerini Alır

Parametreler, fonksiyonun nasıl çağrıldığından çıkarılmaz. İki istisna vardır. Varsayılan değeri olan bir parametre, varsayılanın tipini alır (function retry(times = 3) ifadesi times parametresini number yapar). Ve bir fonksiyon tipinin zaten beklendiği bir yere yazılan fonksiyon, parametre tiplerini o bağlamdan alır; bu yüzden callback parametrelerinin notasyona ihtiyacı yoktur.

const names = ["ada", "grace", "alan"];

// s is string: map on a string[] passes strings
const upper = names.map((s) => s.toUpperCase());

// a and b are strings, the result must be a number
const sorted = [...names].sort((a, b) => a.length - b.length);

// The variable's type gives the arrow its parameter and return types
const greet: (name: string) => string = (n) => `Hello, ${n}`;

console.log(upper, sorted, greet("Ada"));

Aynısı forEach, filter, reduce, Promise callback'leri, event handler'lar ve fonksiyon tipi bildirilmiş bir parametreye verdiğiniz her fonksiyon için geçerlidir.

Parametreler Notasyon İster

Bir varsayılan değer ya da böyle bir bağlam olmadan TypeScript, parametre tiplerini tahmin etmek için fonksiyonun nasıl çağrıldığına bakmaz. strict açıkken notasyonsuz bir parametre TS7006 hatasıdır:

// This does not compile: a parameter with no type and no context.
function double(x) {
    return x * 2;
}
console.log(double(21));

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

function double(x: number) yazın, blok 42 yazdırır; dönüş tipi number da x * 2 ifadesinden çıkarılır.

Best Common Type

Farklı türde değerler içeren bir dizi literal'i için TypeScript, bu değerlerin tiplerinin union'ından oluşan bir dizi çıkarır. Sizin belirtmediğiniz ortak bir temel tipi aramaz.

const mixed = [1, "two", null]; // (string | number | null)[]
const nums = [1, 2.5, -3];      // number[]

class Animal { name = "animal"; }
class Dog extends Animal { bark() { return "woof"; } }
class Cat extends Animal { meow() { return "meow"; } }

const pets = [new Dog(), new Cat()];            // (Cat | Dog)[]
const animals: Animal[] = [new Dog(), new Cat()]; // annotate to get Animal[]

console.log(mixed.length, nums, pets.length, animals[0].name);

Dikkat edilmesi gereken tek durum boş bir dizidir. const list = [] tipi her push ile büyüyen "evrilen" bir dizi olarak başlar; const list: string[] = [] gibi bir notasyon niyeti baştan belirtir ve daha anlaşılırdır.

Ne Zaman Tip Yazılmalı

Neyin çıkarıldığını görmenin en hızlı yolu editörünüzde adın üzerine gelmektir. Editör yoksa değeri yanlış tipte bir değişkene atayın, örneğin const probe: boolean = mixed;, derleyicinin hata mesajı çıkarılan tipi söyler.