TypeScript'teki Fayda Türleri

Bu makale, TypeScript'teki fayda türlerini açıklamaktadır.

YouTube Video

TypeScript'teki Fayda Türleri

TypeScript fayda türleri, mevcut türlere dayalı olarak yeni türler oluşturmak için kullanışlı araçlardır. Bu, daha esnek tür tanımları sağlar ve kodun yeniden kullanılabilirliğini artırır. Burada, sık kullanılan fayda türlerini ayrıntılı olarak açıklayacağız ve her birini örnek kodla nasıl kullanılacağını tartışacağız.

Partial<T>

Partial<T>, bir nesne türündeki tüm özellikleri isteğe bağlı hale getirir (undefined değerini kabul eder). Orijinal türün yalnızca bazı özelliklerini kullanmak istediğinizde faydalıdır.

 1interface User {
 2  id: number;
 3  name: string;
 4  age: number;
 5}
 6
 7function updateUser(user: Partial<User>) {
 8  console.log(user);
 9}
10
11updateUser({ name: "Alice" }); // Updates only 'name'

• Yukarıdaki örnekte, Partial<User> kullanımı User türündeki tüm özellikleri isteğe bağlı hale getirir. Bu nedenle, updateUser fonksiyonunda yalnızca özelliklerin bir alt kümesini geçirebilirsiniz.

Required<T>

Required<T>, isteğe bağlı olanlar da dahil olmak üzere tüm özellikleri gerekli hale getirir. İsteğe bağlı özellikleri gerekli hale dönüştürmek istediğinizde kullanılır.

 1interface User {
 2  id: number;
 3  name?: string;
 4  age?: number;
 5}
 6
 7function createUser(user: Required<User>) {
 8  console.log(user);
 9}
10
11// createUser({ id: 1 }); // Error: 'name' and 'age' are required
12createUser({ id: 1, name: "Alice", age: 25 });

• Required<User> kullanarak, name ve age gibi özellikler gerekli olarak değerlendirilir.

Readonly<T>

Readonly<T>, bir nesnedeki tüm özellikleri salt okunur hale getirir. Bu, nesnenin değerlerinin değiştirilmesini önler.

 1interface User {
 2  id: number;
 3  name: string;
 4}
 5
 6const user: Readonly<User> = {
 7  id: 1,
 8  name: "Alice"
 9};
10
11// user.id = 2; // Error: 'id' is read-only
12console.log(user);

• Readonly<T> kullanarak bir nesnenin özelliklerini değiştirilmeye karşı koruyabilirsiniz. Geliştirme sırasında verilerin yanlışlıkla değiştirilmesini önlemek istediğiniz zaman etkilidir.

Record<K, T>

Record<K, T>, belirtilen anahtar ve değer türleriyle bir harita türü oluşturur. K, anahtarlar için türdür (string veya number gibi) ve T değerler için türdür.

 1type Roles = "admin" | "user" | "guest";
 2interface ReadWritePermissions {
 3  read: boolean;
 4  write: boolean;
 5}
 6
 7const rolePermissions: Record<Roles, ReadWritePermissions> = {
 8  admin: { read: true, write: true },
 9  user: { read: true, write: false },
10  guest: { read: false, write: false },
11};
12
13console.log(rolePermissions);

• Record<K, T>, anahtar-değer çiftlerini tanımlamak istediğinizde faydalıdır. Yukarıdaki örnekte izinler, kullanıcı rolleri temelinde tanımlanmıştır.

Pick<T, K>

Pick<T, K>, bir nesne türünden yalnızca belirtilen özellikleri çıkarır. Yalnızca gerekli özellikleri çıkararak yeni bir tür oluşturabilirsiniz.

 1interface User {
 2  id: number;
 3  name: string;
 4  age: number;
 5}
 6
 7type UserSummary = Pick<User, "id" | "name">;
 8
 9const summary: UserSummary = {
10  id: 1,
11  name: "Alice"
12};
13
14console.log(summary);

• Pick<T, K> kullanarak bir nesne türünden belirli özellikleri çıkarabilir ve bunları yeni bir tür olarak değerlendirebilirsiniz. Örneğin, yukarıdaki örnekte yalnızca id ve name çıkarılmıştır.

Omit<T, K>

Omit<T, K> bir nesne türünden belirtilen özellikleri hariç tutar. Bu, Pick işleminin tersidir.

 1interface User {
 2  id: number;
 3  name: string;
 4  age: number;
 5  email: string;
 6}
 7
 8type UserWithoutEmail = Omit<User, "email">;
 9
10const userWithoutEmail: UserWithoutEmail = {
11  id: 1,
12  name: "Alice",
13  age: 25
14};
15
16console.log(userWithoutEmail);

• Omit<T, K> kullanarak belirtilen özellikleri hariç tutarak yeni bir tür oluşturabilirsiniz. Yukarıdaki örnekte, email özelliği hariç tutulmuştur.

Exclude<T, U>

Exclude<T, U>, U türünü birleşim türü T'den çıkararak yeni bir tür oluşturur. Belirli bir türü kaldırmak istediğinizde kullanılır.

1type Status = "active" | "inactive" | "pending";
2type ExcludedStatus = Exclude<Status, "pending">;
3
4const userStatus: ExcludedStatus = "active"; // "pending" is excluded, so it cannot be chosen
5console.log(userStatus);

• Exclude<T, U> kullanarak, bir birleşim türündeki gereksiz türleri kaldırabilirsiniz. Yukarıdaki örnekte, "pending" hariç tutulduğu için yalnızca "active" veya "inactive" seçilebilir.

Extract<T, U>

Extract<T, U>, birleşim türü T içinde U türüyle eşleşen kısımları çıkarır. Yalnızca belirli bir türü çıkarmak istediğinizde faydalıdır.

1type Status = "active" | "inactive" | "pending";
2type ActiveStatus = Extract<Status, "active" | "pending">;
3
4const userStatus: ActiveStatus = "active"; // "inactive" cannot be chosen
5console.log(userStatus);

• Extract<T, U>, Exclude işleminin tersini yapar. Yukarıdaki örnekte yalnızca "active" ve "pending" seçilebilir.

NonNullable<T>

NonNullable<T>, null ve undefined hariç bir tür oluşturur. Bu değerleri opsiyonel türlerden hariç tutmak istediğinizde faydalıdır.

1type UserName = string | null | undefined;
2type ValidUserName = NonNullable<UserName>;
3
4const userName: ValidUserName = "Alice"; // null and undefined cannot be chosen
5console.log(userName);

• NonNullable<T>, null ve undefined değerlerini hariç tutar ve bir değerin mevcut olmasını garanti eder.

Sonuç

TypeScript yardımcı türleri, tür tanımlarını daha özlü ve esnek hale getirmek için güçlü araçlardır. Partial, Required, Readonly, Record gibi temel yardımcı türleri anlamak ve uygun şekilde kullanmak, kodun tekrar kullanılabilirliğini ve bakımını artırabilir. Bu türlerin ustalıkla kullanılması, daha dayanıklı ve güvenli tür tanımlarını mümkün kılar, bu da verimli bir geliştirme süreci sağlar.

TypeScript'in keyof Operatörü

TypeScript'in keyof operatörü, bir nesne türünün tüm özellik adlarını almak için kullanılır. Bu operatörü kullanarak, bir nesne türünün anahtarlarını birlik türü (union type) olarak elde edebilirsiniz. Bu, tür güvenli (type-safe) kod yazmak için son derece yararlıdır.

Temel Kullanım

1interface Person {
2    name: string;
3    age: number;
4    email: string;
5}
6
7// Use keyof to get the property names of Person
8type PersonKeys = keyof Person; // "name" | "age" | "email"

Örnek Kullanım

Fonksiyon Argümanlarında Kullanımı

keyof operatörünü, belirli bir nesnenin özelliklerine dayanan türlere sahip bir fonksiyon tanımlamak için kullanabilirsiniz.

 1function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
 2    return obj[key];
 3}
 4
 5const person: Person = { name: "Alice", age: 30, email: "alice@example.com" };
 6const userName = getProperty(person, "name"); // type is string
 7const age = getProperty(person, "age");   // type is number
 8
 9console.log("Name:", userName);
10console.log("Age:", age);

• Bu fonksiyon, belirtilen anahtara göre bir nesneden bir özelliği tür güvenli bir şekilde alır.

Tür Kısıtlamalarını Geliştirme

keyof kullanarak, bir fonksiyona geçirilen anahtarların derleme zamanında doğrulanmasını sağlayabilirsiniz.

1// Passing an invalid property name results in an error
2const invalid = getProperty(person, "invalidKey"); // Error

• Bu kod, var olmayan bir özellik adı belirtmenin derleme zamanında hataya yol açacağını göstermektedir.

Özet

• keyof operatörü, bir nesne türüne ait tüm özellik adlarını almak için kullanılır.
• Özellik adlarını bir birlik türü (union type) olarak elde edebilir ve tür güvenli (type-safe) kod sağlayabilirsiniz.
• Bunu fonksiyon argümanlarında kullanarak, fonksiyonun yalnızca geçerli özellik adlarını kabul etmesini sağlayabilirsiniz.

Bu şekilde, keyof operatörü TypeScript'te tür güvenliğini artırır ve daha sağlam kod yazmanıza yardımcı olur.

Yukarıdaki makaleyi, YouTube kanalımızda Visual Studio Code'u kullanarak takip edebilirsiniz. Lütfen YouTube kanalını da kontrol edin.

YouTube Video