TypeScript never Tipi: Kapsamlı Kontroller ve never ile void

never, hiç değeri olmayan tiptir. Dönüş tipi never olan bir fonksiyon asla normal şekilde dönmez: hata fırlatır ya da sonsuza kadar çalışır. never tipindeki bir değişken çalışamayacak kodu işaretler ve kapsamlı (exhaustive) kontrolleri mümkün kılan da budur.

function fail(message: string): never {
  throw new Error(message);
}

function parsePort(text: string): number {
  const n = Number(text);
  if (Number.isInteger(n) && n > 0 && n < 65536) return n;
  return fail(`invalid port: ${text}`); // never is assignable to number
}

console.log(parsePort("8080")); // 8080

try {
  parsePort("http");
} catch (e) {
  console.log((e as Error).message); // invalid port: http
}

return fail(...), number döndüren bir fonksiyonda derlenir, çünkü never her tipe atanabilir: never tipinde bir değer asla gerçekten ortaya çıkamaz.

Hiç Dönmeyen Fonksiyonlar

İki tür fonksiyon asla sonuna ulaşmaz: her zaman hata fırlatan ve sonsuz döngü içeren. Derleyici bu iddiayı kontrol eder. Sonuna ulaşılabilen never notasyonlu bir fonksiyon TS2534 hatasıdır, A function returning 'never' cannot have a reachable end point.

function fail(message: string): never {
  throw new Error(message);
}

function runForever(): never {
  while (true) {
    // poll, serve requests...
  }
}

Çıkarım sözdizimine göre değişir. Yalnızca hata fırlatan bir function declaration void döndüren olarak çıkarılır; yalnızca hata fırlatan bir arrow function veya function expression ise never olarak çıkarılır:

function f1() { throw new Error("x"); }       // () => void
const f2 = () => { throw new Error("x"); };   // () => never

Daraltma, bir çağrıyı yalnızca çağrılan adın never döndüren açık bir tipi olduğunda çıkmaz sokak olarak ele alır: yukarıdaki fail gibi : never notasyonlu bir function declaration ya da tip notasyonlu bir değişken, const fail: (m: string) => never = (m) => { throw new Error(m); }. Çıkarılmış bir never sayılmaz; yalnızca arrow'un notasyonlu olduğu, değişkenin ise olmadığı const fail = (m: string): never => ... de sayılmaz.

never ile void

Pratik fark daraltmada görünür. if (!user) fail("no user") sonrasında derleyici, sonraki satırda user değerinin tanımlı olduğunu yalnızca fail bir never döndürüyorsa bilir. void dönüşünde çalışmanın devam edebileceğini varsayar.

never ile Kapsamlı Kontroller

Bir union üzerindeki switch ifadesinin her case dalı değeri daraltır. Her üye ele alındığında default içinde kalan şey never olur. Onu bir never değişkenine atamak, "her durumu ele aldım" iddiasını derleyicinin doğruladığı bir şeye dönüştürür:

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.side ** 2;
    default: {
      const unhandled: never = shape; // shape is never here
      throw new Error(`unknown shape: ${JSON.stringify(unhandled)}`);
    }
  }
}

console.log(area({ kind: "square", side: 3 })); // 9
console.log(area({ kind: "circle", radius: 1 }).toFixed(4)); // 3.1416

Şimdi union'a bir case eklemeden üçüncü bir üye ekleyin:

// This does not compile: "triangle" is not handled
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number }
  | { kind: "triangle"; base: number; height: number };

function assertNever(value: never): never {
  throw new Error(`Unhandled value: ${JSON.stringify(value)}`);
}

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.side ** 2;
    default:
      return assertNever(shape);
  }
}

console.log(area({ kind: "square", side: 3 }));

index.ts(18,26): error TS2345: Argument of type '{ kind: "triangle"; base: number; height: number; }' is not assignable to parameter of type 'never'.

Hata, unuttuğunuz üyeyi adıyla söyler. case "triangle": return (shape.base * shape.height) / 2; ekleyin, kod yeniden derlenir. assertNever yardımcısı aynı kontrolün yeniden kullanılabilir biçimidir ve throw ifadesi çalışma zamanında da önemlidir: JSON'dan ya da eski bir istemciden gelen veriler, tiplerin imkansız dediği bir kind içerebilir. Bu kalıp discriminated union'ların omurgasıdır.

never'a Kadar Daraltmak

Aynı şey yalnızca switch ile değil, her daraltmada olur. Her olasılık elendiğinde değişkenin tipi never olur:

function describe(x: string | number | boolean): string {
  if (typeof x === "string") return `string "${x}"`;
  if (typeof x === "number") return `number ${x}`;
  if (typeof x === "boolean") return `boolean ${x}`;
  const nothing: never = x; // every option handled
  return nothing;
}

console.log(describe("a")); // string "a"
console.log(describe(2));   // number 2
console.log(describe(true)); // boolean true

Daha sonra parametreyi string | number | boolean | bigint olarak genişletirseniz const nothing: never = x satırı hata verir ve güncellenmesi gereken fonksiyonu gösterir.

never Union'larda Kaybolur

never boş değer kümesidir, bu yüzden onu bir union'a eklemek hiçbir şeyi değiştirmez: string | never sadece string olur. Conditional tipler union'ları bu şekilde filtreler. never döndüren bir dal o üyeyi kaldırır:

type OnlyStrings<T> = T extends string ? T : never;

type Mixed = "a" | "b" | 1 | 2 | true;
type Letters = OnlyStrings<Mixed>; // "a" | "b"

const ok: Letters = "a";
// @ts-expect-error: Type '1' is not assignable to type 'Letters'.
const bad: Letters = 1;

console.log(ok);

Yerleşik Exclude<T, U> ve Extract<T, U> tam olarak böyle çalışır. Bir intersection'da ise tersidir: string & never sonucu never olur.

İmkansız Tipler never Olur

Hiçbir değerin karşılayamayacağı bir intersection never tipine indirgenir:

type A = string & number;                   // never
type B = { kind: "a" } & { kind: "b" };     // never

Bir B değerinin özelliğini okumak nedeni bildirir: Property 'kind' does not exist on type 'never'. The intersection 'B' was reduced to 'never' because property 'kind' has conflicting types in some constituents. Oluşturduğunuz bir tip never çıkarsa, birbiriyle çelişen iki parça arayın.

never, unknown ve any

unknown tip hiyerarşisinin tepesi, never ise dibidir. any hiyerarşinin hiç parçası değildir: kontrolleri kapatır.