TypeScript Tür Koruyucuları

Tür koruyucuları, geliştiricilerin bir değişkenin türünü daraltmak için çalışma zamanı denetimleri gerçekleştirmesine olanak tanıyan TypeScript'teki güçlü bir özelliktir. Bu, daha kesin tür bilgisi sağlar ve daha güvenli ve daha öngörülebilir koda yol açar. Bu makale, tür koruyucularının ne olduğunu ve bunların etkili bir şekilde nasıl kullanılacağını inceler.

Tip Koruyucular Nelerdir?

Tür koruyucuları, çalışma zamanı denetimleri gerçekleştiren ve TypeScript'in bir değişken için daha belirli bir tür çıkarmasına olanak tanıyan ifadelerdir. Özellikle birleşik türlerle uğraşırken farklı türler arasında ayrım yapmaya yardımcı olurlar. Tür koruyucuları, aşağıdakiler de dahil olmak üzere çeşitli teknikler kullanılarak uygulanabilir:

• Kullanıcı tanımlı tür tahminleri
• Tür iddiaları
• Örnek kontrolleri
• typeof operatörünü kullanma
• in operatörünü kullanma

Kullanıcı Tarafından Tanımlanan Tür Tahminleri

Kullanıcı tanımlı tür tahminleri, bir boolean değeri döndüren ve kontrol edilen değişkenin türünü belirten özel bir dönüş türüne sahip olan işlevlerdir. Bunları nasıl oluşturacağınız ve kullanacağınız aşağıda açıklanmıştır:

function isString(value: any): value is string {
  return typeof value === 'string';
}

function printString(value: any) {
  if (isString(value)) {
    console.log(value.toUpperCase()); // TypeScript knows value is a string here
  } else {
    console.log('Not a string');
  }
}

Yukarıdaki örnekte, isString, TypeScript'in value öğesinin if bloğu içinde bir dize olduğunu anlamasına yardımcı olan kullanıcı tanımlı bir tür yordamıdır.

Tür İddiaları

Tür iddiaları TypeScript'e bir değişkeni belirli bir tür olarak ele almasını söyler. Bu yöntem bir çalışma zamanı denetimi gerçekleştirmez ancak TypeScript derleyicisini tür hakkında bilgilendirir. Örneğin:

function printLength(value: any) {
  console.log((value as string).length); // Assert value is a string
}

Bu örnekte, value as string ifadesi TypeScript'e, çalışma zamanı denetimi gerçekleştirmeden value ifadesinin bir dize olduğunu varsaymasını söyler.

Örnek Kontrolleri

Örnek denetimleri, bir nesnenin belirli bir sınıfın örneği olup olmadığını belirlemek için kullanılır. Bu, sınıflarla çalışırken türleri daraltmak için yararlıdır:

class Dog {
  bark() { console.log('Woof'); }
}

class Cat {
  meow() { console.log('Meow'); }
}

function speak(animal: Dog | Cat) {
  if (animal instanceof Dog) {
    animal.bark(); // TypeScript knows animal is a Dog here
  } else {
    animal.meow(); // TypeScript knows animal is a Cat here
  }
}

Bu örnekte, instanceof operatörü TypeScript'in sınıfına bağlı olarak animal türünü çıkarmasına yardımcı olur.

typeof Operatörünün Kullanımı

typeof operatörü, string, number ve boolean: gibi ilkel türleri kontrol etmek için kullanılabilir.

function processValue(value: string | number) {
  if (typeof value === 'string') {
    console.log(value.toUpperCase()); // TypeScript knows value is a string here
  } else {
    console.log(value.toFixed(2)); // TypeScript knows value is a number here
  }
}

Burada, typeof, value değerinin bir string mi yoksa bir number mi olduğunu kontrol etmek ve türü buna göre daraltmak için kullanılır.

in Operatörünün Kullanımı

in operatörü bir nesnede bir özelliğin varlığını kontrol eder. Bu, ortak özellikleri paylaşan türler arasında ayrım yapmak için yararlıdır:

interface Bird {
  fly: () => void;
}

interface Fish {
  swim: () => void;
}

function move(creature: Bird | Fish) {
  if ('fly' in creature) {
    creature.fly(); // TypeScript knows creature is a Bird here
  } else {
    creature.swim(); // TypeScript knows creature is a Fish here
  }
}

Bu örnekte, in operatörü TypeScript'in bir yöntemin varlığına dayanarak creature'in bir Bird mi yoksa Fish mi olduğunu belirlemesine yardımcı olur.

Çözüm

TypeScript tür koruyucuları, türlerle esnek ve güvenli bir şekilde çalışmak için olmazsa olmaz araçlardır. Daha hassas tür denetimine olanak tanırlar ve farklı senaryolarda doğru türün kullanıldığından emin olarak çalışma zamanı hatalarını önleyebilirler. Tür koruyucularını anlamak ve etkili bir şekilde kullanmak, daha sağlam ve sürdürülebilir TypeScript koduna yol açabilir.