TypeScript Ünlem İşareti: Non-Null Assertion (!) Operatörü

Bir ifadeden sonra gelen ünlem işareti, value!, non-null assertion operatörüdür. Tipten null ve undefined tiplerini çıkarır, böylece bir number | undefined bir number olarak kullanılabilir. Bu derleyiciye verilen bir sözdür, bir kontrol değildir: çalışma zamanında hiçbir şey olmaz.

const prices = new Map<string, number>([
  ["tea", 2.5],
  ["coffee", 3.2],
]);

const tea = prices.get("tea");         // number | undefined
const coffee = prices.get("coffee")!;  // number

console.log(coffee.toFixed(2)); // 3.20
console.log(tea!.toFixed(2));   // 2.50: ! works on any expression

! olmadan tea.toFixed(2), TS18048 hatasıdır: 'tea' is possibly 'undefined'. ! ile kod derlenir, çünkü derleyiciye anahtarın var olduğunu söylediniz.

x! Çalışma Zamanında Ne Yapar: Hiçbir Şey

! çıktıdan silinir. prices.get("coffee")! için derlenmiş JavaScript sadece prices.get("coffee") olur. Assertion yanlışsa hata daha sonra, eksik değerin ilk kullanıldığı yerde ortaya çıkar:

const prices = new Map<string, number>([["tea", 2.5]]);

try {
  const juice = prices.get("juice")!; // compiles: the ! silences the check
  console.log(juice.toFixed(2));      // TypeError at runtime
} catch (e) {
  console.log((e as Error).message);
}

Program Cannot read properties of undefined (reading 'toFixed') yazdırır. Çökme ! işaretinden sonraki satırda olur; gerçek kodda çok daha uzakta olabilir: undefined bir nesnede saklanıp başka bir dosyada patlayabilir. ! işaretini riskli yapan bu mesafedir.

Kesin Atama: let x!: T

Aynı sembolün bir bildirimde ilişkili bir anlamı vardır. TypeScript bir değişkenin okunmadan önce atanıp atanmadığını izler ve başka bir fonksiyonun içinde yapılan bir atamayı takip edemez:

// This does not compile: TypeScript cannot see the assignment inside init()
let config: { port: number };

function init() {
  config = { port: 8080 };
}

init();
console.log(config.port);

index.ts(9,13): error TS2454: Variable 'config' is used before being assigned.

let config!: { port: number }; bir kesin atama assertion'ıdır: "bu, her okumadan önce atanacak". Hatayı düzeltir, x! ile aynı püf noktasıyla: init() bir gün atlanırsa okuma undefined alır. Kodu yeniden yapılandırmak genellikle daha iyidir; örneğin init nesneyi döndürecek şekilde const config = init();.

Sınıf Özellikleri: prop!: T

strictPropertyInitialization (strict kapsamında) açıkken her sınıf özelliği, bildiriminde ya da constructor içinde başlatılmalıdır. Aksi halde TS2564 alırsınız: Property 'socket' has no initializer and is not definitely assigned in the constructor. Bir özellik daha sonra bir metot veya bir framework tarafından ayarlanıyorsa prop!: T derleyiciye onu kabul etmesini söyler:

class Connection {
  url: string;
  socket!: { send(msg: string): string }; // set in open(), not in the constructor

  constructor(url: string) {
    this.url = url;
  }

  open() {
    this.socket = { send: (msg) => `sent "${msg}" to ${this.url}` };
  }
}

const c = new Connection("ws://example.com");
console.log(c.socket);            // undefined: declared but not set yet
c.open();
console.log(c.socket.send("hi")); // sent "hi" to ws://example.com

İlk console.log boşluğu gösteriyor: tip socket özelliğinin her zaman var olduğunu söylüyor, ama open() öncesinde undefined. O noktada c.socket.send çağırmak derlenir ve hata fırlatır. Özellik gerçekten eksik olabiliyorsa onu socket?: ... olarak tanımlayıp kontrol edin ya da nesneyi constructor içinde oluşturun. prop! kullanımının standart pratik olduğu ana yer, bir özelliği oluşturma sonrasında dolduran bir framework'tür: Angular'ın @ViewChild(...) child!: ChildDirective ifadesi (ngAfterViewInit çalışmadan önce ayarlanır) ya da sütunlarını kütüphanenin bir satırı yüklerken doldurduğu ORM entity sınıfları (MikroORM'un dokümantasyonu @Property() title!: string yazar).

Daha Güvenli Alternatifler

Çoğu ! işareti, derleyicinin kontrol ettiği bir şeyle ya da doğru yerde yüksek sesle başarısız olan bir kontrolle değiştirilebilir:

function must<T>(value: T | null | undefined, what: string): T {
  if (value == null) throw new Error(`missing ${what}`);
  return value;
}

function assertDefined<T>(value: T, what: string): asserts value is NonNullable<T> {
  if (value == null) throw new Error(`missing ${what}`);
}

const env = new Map([["PORT", "8080"]]);

const port = must(env.get("PORT"), "PORT"); // string
console.log(Number(port) + 1);              // 8081

const host = env.get("HOST");
try {
  assertDefined(host, "HOST");
  console.log(host.toUpperCase()); // host is string after the assertion
} catch (e) {
  console.log((e as Error).message); // missing HOST
}

İki yardımcı da ! gibi tipi daraltır, ama yanlış bir varsayım başka bir yerde bir TypeError yerine anında missing HOST üretir. assertDefined bir assertion fonksiyonudur (asserts value is ...): çağrıdan sonra derleyici host değerini bir string olarak ele alır. Daha fazla kalıp type guard'lar sayfasında.

Diğer Ünlem İşaretleri

! bulunduğu yere göre farklı anlamlar taşır:

Yalnızca ilk ikisi derleme zamanında silinir. !value ve !!value çalışma zamanında çalışır ve bir boolean döndürür.