Antwort.

In TypeScript werden Arrays auf zwei Hauptarten beschrieben: typ[] und Array<typ>. Für Arrays mit Elementen unterschiedlicher Typen werden vereinheitlichte Typen (union types) oder Tupel (tuples) verwendet, die es ermöglichen, eine feste Menge von Elementen unterschiedlicher Typen und Anzahl zu beschreiben.

Deklarationen von Arrays:

let numbers: number[] = [1, 2, 3];
let strings: Array<string> = ['a', 'b', 'c'];

Array mit Elementen verschiedener Typen:

let mixed: (string | number)[] = [1, 'a', 2];

Tupel (tuples):

let tuple: [string, number, boolean] = ['hello', 42, true];

Mit Tupeln lässt sich einfacher arbeiten, wenn eine feste Struktur erwartet wird (zum Beispiel mehrere unterschiedliche Werte aus einer Funktion zurückzugeben), während mit Arrays – wenn die Anzahl und der Typ der Elemente gemischt oder im Voraus unbekannt sein können.

Fangfrage.

Kann man nach der Definition eines Tupels der Länge N mit push Elemente hinzufügen? Wie beeinflusst das die Typisierung?

Antwort: Ja, in ein Tupel kann man pushen – der Compiler erlaubt dies, obwohl es die Annahme der begrenzten Länge des Tupels verletzt. Die Typen der neuen Elemente werden auf die Vereinigung aller möglichen Typen der Tupel-Elemente abgeleitet:

let tuple: [number, string] = [42, 'foo'];
tuple.push(true); // OK! tuple jetzt: [number, string, boolean], aber der Typ wurde nicht aktualisiert, keine Fehler!
console.log(tuple); // [42, 'foo', true]

Deshalb muss man die Arbeit mit Tupeln und ihre Änderbarkeit manuell kontrollieren oder sie als readonly definieren.

Beispiele für reale Fehler aufgrund von Unkenntnis der Feinheiten des Themas.

Geschichte

Ein Entwickler definierte eine Funktion, die ein Tupel [number, string] zurückgibt, begann jedoch, Elemente über push hinzuzufügen. Dies führte zu einer Desynchronisation der Typen: Der nachfolgende Code erwartete genau zwei Elemente mit bestimmten Typen, erhielt jedoch ein Array variabler Länge, was zur Laufzeitfehler beim Entpacken von Werten und beim Zugriff auf nicht vorhandene Indizes führte.

Geschichte

Für die Speicherung eines Arrays mit Werten unterschiedlicher Typen wurde ein Array any[] verwendet, in der Annahme, dass es sich um eine universelle Lösung handele. Infolgedessen hörte TypeScript auf, die Richtigkeit der Typen zu überprüfen, und die Logik der Anwendung begann "kaputt zu gehen" aufgrund falscher Typumwandlungen, die keine Kompilierungsfehler verursachten.

Geschichte

In einem Projekt wurde das Array entweder durch typ[] oder durch Array<typ> beschrieben – aber an einigen Stellen wurde die Schreibweise let arr: any[] (um "mit allem zu arbeiten") toleriert. Dadurch traten unkontrollierte Umwandlungen auf, die Funktion akzeptierte jedes Array, was zu Laufzeitfehlern führte, wenn versucht wurde, inkorrekte Methoden für Elemente unterschiedlicher Typen aufzurufen.