11 Die Top-Typen any und unknown

In TypeScript sind any und unknown Typen, die alle Werte enthalten. In diesem Kapitel untersuchen wir, was sie sind und wofür sie verwendet werden können.

11.1 Die beiden Top-Typen von TypeScript

any und unknown sind sogenannte Top-Typen in TypeScript. Zitiert von Wikipedia

Der Top-Typ [...] ist der universelle Typ, manchmal auch als universeller Supertyp bezeichnet, da alle anderen Typen in einem gegebenen Typsystem Subtypen sind [...]. In den meisten Fällen ist es der Typ, der jeden möglichen [Wert] im interessierenden Typsystem enthält.

Das heißt, wenn man Typen als Mengen von Werten betrachtet (weitere Informationen zu Typen finden Sie unter [Inhalt nicht enthalten]), dann sind any und unknown Mengen, die alle Werte enthalten. Am Rande sei erwähnt, dass TypeScript auch den Bottom-Typ never hat, der die leere Menge ist.

11.2 Der Top-Typ any

Wenn ein Wert den Typ any hat, können wir alles damit tun

function func(value: any) {
  // Only allowed for numbers, but they are a subtype of `any`
  5 * value;

  // Normally the type signature of `value` must contain .propName
  value.propName;

  // Normally only allowed for Arrays and types with index signatures
  value[123];
}

Jeder Typ ist zuweisbar an den Typ any

let storageLocation: any;

storageLocation = null;
storageLocation = true;
storageLocation = {};

Der Typ any ist zuweisbar an jeden Typ

function func(value: any) {
  const a: null = value;
  const b: boolean = value;
  const c: object = value;
}

Mit any verlieren wir jeglichen Schutz, der uns normalerweise durch das statische Typsystem von TypeScript gegeben wird. Daher sollte er nur als letzter Ausweg verwendet werden, wenn wir keine spezifischeren Typen oder unknown verwenden können.

11.2.1 Beispiel: JSON.parse()

Das Ergebnis von JSON.parse() hängt von dynamischen Eingaben ab, weshalb der Rückgabetyp any ist (ich habe den Parameter reviver in der Signatur weggelassen)

JSON.parse(text: string): any;

JSON.parse() wurde zu TypeScript hinzugefügt, bevor der Typ unknown existierte. Andernfalls wäre sein Rückgabetyp wahrscheinlich unknown.

11.2.2 Beispiel: String()

Die Funktion String(), die beliebige Werte in Strings konvertiert, hat die folgende Typensignatur

interface StringConstructor {
  (value?: any): string; // call signature
  // ···
}

11.3 Der Top-Typ unknown

Der Typ unknown ist eine typsichere Version des Typs any. Wann immer Sie daran denken, any zu verwenden, versuchen Sie zuerst unknown zu verwenden.

Während any alles erlaubt, ist unknown viel restriktiver.

Bevor wir beliebige Operationen auf Werten vom Typ unknown durchführen können, müssen wir ihre Typen zuerst durch Folgendes einschränken:

• Typ-Assertionen:

  function func(value: unknown) {
    // @ts-expect-error: Object is of type 'unknown'.
    value.toFixed(2);
  
    // Type assertion:
    (value as number).toFixed(2); // OK
  }

• Gleichheit

  function func(value: unknown) {
    // @ts-expect-error: Object is of type 'unknown'.
    value * 5;
  
    if (value === 123) { // equality
      // %inferred-type: 123
      value;
  
      value * 5; // OK
    }
  }

• Typ-Guards:

  function func(value: unknown) {
    // @ts-expect-error: Object is of type 'unknown'.
    value.length;
  
    if (typeof value === 'string') { // type guard
      // %inferred-type: string
      value;
  
      value.length; // OK
    }
  }

• Assertionsfunktionen:

  function func(value: unknown) {
    // @ts-expect-error: Object is of type 'unknown'.
    value.test('abc');
  
    assertIsRegExp(value);
  
    // %inferred-type: RegExp
    value;
  
    value.test('abc'); // OK
  }
  
  /** An assertion function */
  function assertIsRegExp(arg: unknown): asserts arg is RegExp {
    if (! (arg instanceof RegExp)) {
      throw new TypeError('Not a RegExp: ' + arg);
    }
  }