TypeScript'te İleri Düzey Generic Tipler

Generic'ler, birden fazla veri tipiyle çalışan esnek ve yeniden kullanılabilir fonksiyonlar ve tipler oluşturmanıza olanak tanır. Bu bölüm, generic'leri yardımcı tipler ve kısıtlamalarla birleştiren ileri teknikleri keşfeder.

`keyof` ve `Pick`, `Exclude` gibi yardımcı tiplerle generic'leri kullanarak, nesne tiplerini dinamik şekilde işleyebilen güçlü yardımcılar oluşturabilirsiniz. Bu, kodunuzu sağlam ve sürdürülebilir tutar.

Generic ile Bir Özelliğin Değerini Almak

const getValue = <T extends object,>(obj: T, property: keyof T): T[keyof T] => {
    return obj[property];
  }
  
  const person = { name: "Alice", age: 30, active: true };
  console.log(getValue(person, 'age')); // Output: 30
  console.log(getValue(person, 'name')); // Output: Alice

Bu fonksiyon, bir nesne ve anahtar alır; ardından generic kısıtlamalar sayesinde tam tip güvenliği ile karşılık gelen özelliğin değerini döndürür.

Bir Nesneden Tek Özelliği Kaldırmak

type MyOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
  
  // Remove a single property from object type and value
  const deleteValue = <T extends object, K extends keyof T>(obj: T, property: K): MyOmit<T, K> => {
    const { [property]: _, ...rest } = obj;
    return rest;
  };
  
  const obj = { name: "Alice", age: 30, manager: "Bob" };
  const withoutManager = deleteValue(obj, "manager");
  console.log(withoutManager); // Output: { name: "Alice", age: 30 }

Özel bir `MyOmit` tipi kullanarak, belirtilen özelliği içermeyen yeni bir nesne döndüren yardımcı bir fonksiyon oluşturuyoruz. Dönüş tipinde de bu değişiklik yansıtılır.

Bir Nesneden Birden Fazla Özelliği Kaldırmak

// Remove multiple properties from object
  const deleteValues = <T extends object, K extends (keyof T)[]>(obj: T, properties: K): MyOmit<T, K[number]> => {
    const result = { ...obj };
    properties.forEach(prop => {
      delete result[prop];
    });
    return result;
  };
  
  const originalObj = { name: "Alice", age: 30, manager: "Bob", active: true };
  const reducedObj = deleteValues(originalObj, ['name', 'age']);
  console.log(reducedObj); // Output: { manager: "Bob", active: true }

Önceki örneği genişleterek, bu sefer birden fazla anahtarı kaldırıyoruz. Anahtarlar dizi olarak veriliyor ve dönüş tipi tüm bu anahtarları hariç tutacak şekilde dinamik olarak oluşturuluyor.

Bir Özelliğin Değerini Güvenli Şekilde Güncellemek

// Example: Generic function to update a property value safely
  const updateValue = <T extends object, K extends keyof T>(obj: T, key: K, value: T[K]): T => {
    return { ...obj, [key]: value };
  };
  
  const user = { id: 1, username: "user1", isAdmin: false };
  const updatedUser = updateValue(user, "isAdmin", true);
  console.log(updatedUser); // Output: { id: 1, username: "user1", isAdmin: true }

Bir nesne üzerindeki belirli bir özelliği, yeni değeriyle tip uyumlu olacak şekilde güncelleyen generic fonksiyon.

Nesne Anahtarları ve Değerleri Üzerinde Map İşlemi

// Generic function to map over object keys and values
  function mapObject<T extends object, R>(obj: T, fn: (key: keyof T, value: T[keyof T]) => R): R[] {
    return (Object.keys(obj) as (keyof T)[]).map(key => fn(key, obj[key]));
  }
  
  const data = { a: 1, b: 2, c: 3 };
  const result = mapObject(data, (key, value) => `${key}: ${value * 2}`);
  console.log(result); // Output: ["a: 2", "b: 4", "c: 6"]

Bu yardımcı fonksiyon, generic kullanarak bir nesnenin anahtar ve değerleri üzerinde gezinir, her çift için bir geri çağırma fonksiyonu uygular ve eşlenen sonuçları bir dizi olarak döndürür.