TypeScript Gelişmiş Türleri Örneklerle Açıklandı

TypeScript, temel tiplerin ötesine geçen ve daha esnek ve güçlü tip sistemlerine olanak tanıyan çeşitli gelişmiş tipler sunar. Bu gelişmiş tipler, tip kısıtlamalarını tanımlamanın ve uygulamanın ek yollarını sağlayarak sağlam uygulamalar oluşturmaya yardımcı olur. Bu makale, bu gelişmiş tiplerden bazılarını örneklerle inceler.

Birlik Türleri

Birleşim türleri bir değişkenin birkaç türden biri olmasına izin verir. Bu, bir değerin birden fazla türden olabileceği ancak gerçek türüne göre uygun şekilde işlenmesi gerektiğinde yararlı olabilir.

// Union type example

function formatValue(value: string | number): string {
  if (typeof value === 'string') {
    return `String: ${value}`;
  } else {
    return `Number: ${value.toFixed(2)}`;
  }
}

console.log(formatValue("Hello"));
console.log(formatValue(123.456));

Bu örnekte `formatValue` fonksiyonu bir dize veya sayı kabul eder ve değeri buna göre biçimlendirir.

Kavşak Türleri

Kesişim türleri birden fazla türü bir araya getirir. Bir kesişim türünün nesnesi, birleştirilmiş türlerin tüm özelliklerine sahip olacaktır. Bu, birden fazla türü bir araya getirmek için kullanışlıdır.

// Intersection type example

interface Person {
  name: string;
  age: number;
}

interface Contact {
  email: string;
  phone: string;
}

type Employee = Person & Contact;

const employee: Employee = {
  name: "John Doe",
  age: 30,
  email: "john.doe@example.com",
  phone: "123-456-7890"
};

console.log(employee);

Burada, `Çalışan` türü `Kişi` ve `Kişi` türlerinin kesişimidir, yani her iki arayüzden de özellikler içerir.

Kelime Türleri

Sabit türler, bir değişkenin tutabileceği kesin değerleri belirtir. Bu, yalnızca belirli belirli değerlere izin verildiğinden emin olmak için özellikle yararlı olabilir.

// Literal type example

type Direction = "up" | "down" | "left" | "right";

function move(direction: Direction): void {
  console.log(`Moving ${direction}`);
}

move("up");    // Valid
move("down");  // Valid
// move("side"); // Error: Argument of type '"side"' is not assignable to parameter of type 'Direction'.

Buradaki `Direction` türü dört belirli dize değeriyle sınırlandırılmıştır ve bu sayede `move` fonksiyonunda yalnızca bu yönlerin kullanılabilmesi sağlanmıştır.

Tuple Türleri

Tuple tipleri, her bir elemanın farklı bir tipe sahip olabileceği sabit sayıda elemana sahip bir diziyi temsil eder. Tuple'lar, heterojen öğelerin sabit boyutlu koleksiyonlarını temsil etmek için kullanışlıdır.

// Tuple type example

let user: [string, number] = ["Alice", 30];

console.log(user[0]); // "Alice"
console.log(user[1]); // 30

// user = [30, "Alice"]; // Error: Type 'number' is not assignable to type 'string'.

`Kullanıcı` tuple'ı bir string ve onu takip eden bir sayıdan oluşur ve bu yapının korunması gerekir.

Koşullu Türler

Koşullu tipler, tiplerin koşullara göre belirlenmesine olanak tanır. Bir koşula göre bir tip veya diğerini seçmenin bir yolunu sağlarlar.

// Conditional type example

type IsString = T extends string ? "Yes" : "No";

type Test1 = IsString;  // "Yes"
type Test2 = IsString;  // "No"

Bu örnekte, `IsString` türü `T` türünün bir dize olup olmadığını kontrol eder. Eğer öyleyse `"Yes"`, aksi halde `"No"` döndürür.

Haritalanmış Türler

Eşlenen türler, var olan bir türün özelliklerini dönüştürerek yeni türler oluşturmaya olanak tanır. Bu, var olan türleri değiştirmek veya genişletmek için yararlıdır.

// Mapped type example

type ReadonlyPerson = {
  readonly [K in keyof Person]: Person[K];
};

const readonlyPerson: ReadonlyPerson = {
  name: "Alice",
  age: 30
};

// readonlyPerson.age = 31; // Error: Cannot assign to 'age' because it is a read-only property.

`ReadonlyPerson` türü, `Person` türünün tüm özelliklerini salt okunur yaparak onu dönüştürür.

Çözüm

TypeScript'in gelişmiş tipleri, karmaşık tip gereksinimlerini tanımlamak ve yönetmek için güçlü araçlar sağlar. Birleşim, kesişim, değişmez, ikili, koşullu ve eşlenmiş tipleri kullanarak, geliştiriciler daha sağlam ve sürdürülebilir uygulamalar oluşturabilir. Bu tipleri anlamak ve etkili bir şekilde uygulamak, TypeScript kodunun tip güvenliğini ve esnekliğini önemli ölçüde artırabilir.