Implementierung eines leichten Result-Typs in TypeScript

Die Fehlerbehandlung für asynchrone Operationen wird oft mit try-catch geschrieben, aber der Ort, an dem Exceptions auftreten, und der Ort, an dem sie behandelt werden, neigen dazu, auseinanderzudriften. Mit dem Result-Typ-Pattern können Sie Erfolg und Misserfolg explizit als Rückgabewerte trennen.

Voraussetzung: Konvertierung zum Error-Typ

Ein Helper, um unbekannte Fehler zuverlässig in den Error-Typ zu konvertieren.

export function toError(error: unknown): Error {
  if (error instanceof Error) return error;
  return new Error(error as never);
}

Definition des Result-Typs

interface Failure {
  data: undefined;
  error: Error;
}

interface Success<T> {
  data: T;
  error: undefined;
}

type Result<T> = Success<T> | Failure;

Beispielimplementierung des fetch-Wrappers

import { toError } from './toError.js'

export async function fetcher<T>(
  url: RequestInfo,
  init?: RequestInit
): Promise<Result<T>> {
  const UNDEF = undefined;

  // Wenn fetch fehlschlägt (Netzwerkfehler usw.)
  const response = await fetch(url, init).catch(toError);
  if (response instanceof Error) {
    return { data: UNDEF, error: response };
  }

  // HTTP-Fehlerantworten
  if (!response.ok) {
    return {
      data: UNDEF,
      error: new Error(`HTTP ${response.status}: ${response.statusText}`)
    };
  }

  // Erfolg
  const data = await response.json();
  return { data, error: UNDEF };
}

Verwendungsbeispiel

const result = await fetcher<User>("/api/user/123");

if (result.error) {
  console.error("Abruf fehlgeschlagen:", result.error.message);
  return;
}

// Wenn result.error undefined ist, leitet TypeScript result.data als T ab
console.log(result.data.name);

Vorteile und Überlegungen

Vorteile:

• Erfolg und Misserfolg werden durch den Rückgabetyp klar
• Weniger try-catch-Blöcke verbessern die Lesbarkeit
• Fehlerbehandlung kann erzwungen werden (Auslassung verursacht Typfehler)

Überlegungen:

• Wenn der ECMAScript Safe Assignment Operator-Vorschlag standardisiert wird, könnte ähnliche integrierte Funktionalität verfügbar werden
• Nicht so vollständig wie die spracheigenen Result-Typen von Go oder Rust
• Detaillierte Fehlerbehandlung wie Validierungsfehler erfordert separate Implementierung

Die Implementierung ist einfach, aber effektiv, wenn Sie in kleinen Projekten typsicher mit Fehlern umgehen möchten.