TypeScript Tupel

Wir wissen, dass die Datentypen der Elemente in einem Array im Allgemeinen gleich sind (Arrays vom Typ any[] können unterschiedlich sein). Wenn die gespeicherten Elemente unterschiedliche Datentypen haben, müssen Sie Tupel verwenden.

Ein Tupel in TypeScript ist ein spezieller Array-Typ, der es ermöglicht, Elemente unterschiedlicher Typen im Array zu speichern. Im Gegensatz zu gewöhnlichen Arrays hat jedes Element in einem Tupel einen klaren Typ und eine klare Position. Tupel können in vielen Szenarien verwendet werden, um Datenstrukturen mit fester Länge und bekannten Elementtypen darzustellen.

Die Syntax zum Erstellen eines Tupels lautet wie folgt:

let tuple: [类型1, 类型2, 类型3, ...];

Beispiel

Ein Tupel deklarieren und initialisieren:

let mytuple: [number, string];
mytuple = [42,"Example"];

Im obigen Beispiel ist mytuple ein Tupel, das ein Element vom Typ number und ein Element vom Typ string enthält.

Zugriff auf Tupel

Auf Elemente in einem Tupel wird über Indizes zugegriffen. Der Index des ersten Elements ist 0, der des zweiten ist 1, und so weiter, der n-te ist n-1. Die Syntax ist wie folgt:

tuple_name[index]

Beispiel

Das folgende Beispiel definiert ein Tupel, das zwei Arten von Elementen enthält: Zahlen und Strings.

TypeScript

let mytuple: [number, string, boolean] = [42, "Example", true]; //Zugriff auf Elemente im Tupel let num = mytuple[0]; //Zugriff auf das erste Element, Wert ist 42, Typ ist number let str = mytuple[1]; //Zugriff auf das zweite Element, Wert ist "Example", Typ ist string let bool = mytuple[2]; //Zugriff auf das dritte Element, Wert ist true, Typ ist boolean console.log(num); //Ausgabe: 42 console.log(str); //Ausgabe: Example console.log(bool); //Ausgabe: true

Kompilieren Sie den obigen Code, um den folgenden JavaScript-Code zu erhalten:

JavaScript

var mytuple = [42, "Example", true]; //Zugriff auf Elemente im Tupel var num = mytuple[0]; //Zugriff auf das erste Element, Wert ist 42, Typ ist number var str = mytuple[1]; //Zugriff auf das zweite Element, Wert ist "Example", Typ ist string var bool = mytuple[2]; //Zugriff auf das dritte Element, Wert ist true, Typ ist boolean console.log(num); //Ausgabe: 42 console.log(str); //Ausgabe: Example console.log(bool); //Ausgabe: true

Das Ausgabeergebnis ist:

42
Example
true

Tupel-Operationen

Wir können die folgenden zwei Funktionen verwenden, um neue Elemente zu einem Tupel hinzuzufügen oder Elemente daraus zu entfernen:

  • push() fügt ein Element zum Tupel hinzu und hängt es am Ende an.

  • pop() entfernt ein Element (das letzte) aus dem Tupel und gibt das entfernte Element zurück.

Die push-Methode kann ein Element am Ende eines Tupels hinzufügen, und der Typ muss den im Tupel definierten Typbeschränkungen entsprechen. Wenn es die Typbeschränkungen des Tupels überschreitet, meldet TypeScript einen Fehler.

TypeScript

var tuple = [42, "Hello"]; //Füge ein Element hinzu, das dem Typ entspricht tuple.push("World"); //Gültig, weil das Tupel einen optionalen string-Typ definiert console.log(tuple); //Ausgabe: [42, "Hello", "World"]

Kompilieren Sie den obigen Code, um den folgenden JavaScript-Code zu erhalten:

JavaScript

var tuple = [42, "Hello"]; //Füge ein Element hinzu, das dem Typ entspricht tuple.push("World"); //Gültig, weil das Tupel einen optionalen string-Typ definiert console.log(tuple); //Ausgabe: [42, "Hello", "World"]

Das Ausgabeergebnis ist:

[ 42, 'Hello', 'World' ]

Die pop-Methode entfernt ein Element vom Ende eines Tupels und gibt dieses Element zurück. Der Typ des zurückgegebenen Elements wird basierend auf den definierten Typen des Tupels abgeleitet.

Beispiel

let tuple: [number, string, boolean] = [42, "Hello", wahr];

// Letztes Element entfernen
let lastElement = tuple.pop();

console.log(lastElement); // Ausgabe: true
console.log(tuple);       // Ausgabe: [42, "Hello"]

Aktualisieren von Tupeln

Tupel sind veränderbar, was bedeutet, dass wir Aktualisierungsoperationen an Tupeln durchführen können:

TypeScript

var mytuple = [42, "Example", "Taobao", "Google"]; //Ein Tupel erstellen console.log("Das erste Element des Tupels ist:" + mytuple[0]) //Tupel-Element aktualisieren mytuple[0] = 121 console.log("Das erste Element im Tupel wurde aktualisiert zu:"+ mytuple[0])

Kompilieren Sie den obigen Code, um den folgenden JavaScript-Code zu erhalten:

JavaScript

var mytuple = [42, "Example", "Taobao", "Google"]; //Ein Tupel erstellen console.log("Das erste Element des Tupels ist:" + mytuple[0]); //Tupel-Element aktualisieren mytuple[0] = 121; console.log("Das erste Element im Tupel wurde aktualisiert zu:" + mytuple[0]);

Das Ausgabeergebnis ist:

元组的第一个元素为:42
元组中的第一个元素更新为:121

Destrukturierung von Tupeln

Wir können Tupel-Elemente auch Variablen zuweisen, wie unten gezeigt:

TypeScript

let a: [number, string, boolean] = [42, "Hello", true];//Ein Tupel erstellen var [b,c] = a console.log( b ) console.log( c )

Kompilieren Sie den obigen Code, um den folgenden JavaScript-Code zu erhalten:

JavaScript

var a = [42, "Hello", true]; //Ein Tupel erstellen var b = a[0], c = a[1]; console.log(b); console.log(c);

Das Ausgabeergebnis ist:

42
Hello

Verwendung von beschrifteten Tupeln

TypeScript ermöglicht es außerdem, jedem Element in einem Tupel Labels hinzuzufügen, wodurch die Bedeutung des Tupels klarer wird:

let tuple: [id: number, name: string] = [1, "John"];

In diesem Beispiel sind id und name Labels des Tupels, was den Code lesbarer machen kann.


Praktische Anwendungen von Tupeln

Tupel werden häufig in Szenarien verwendet, in denen eine Funktion mehrere Werte zurückgibt oder Daten mit einer bestimmten festen Struktur dargestellt werden sollen, zum Beispiel:

Beispiel

function getUserInfo(): [number, string] {
    return [1, "John Doe"];
}

const [userId, userName] = getUserInfo();
console.log(userId);   // Ausgabe: 1
console.log(userName); // Ausgabe: John Doe

Typinferenz von Tupeln

TypeScript kann den Typ eines Tupels automatisch anhand der Elemente des Arrays ableiten:

let tuple = [42, "Hello"] as const; // 元组类型:[42, "Hello"]

Durch die as-const-Assertion behandelt TypeScript dieses Tupel als unveränderliches konstantes Tupel.


Tupel verketten

Tupel können mit der concat-Methode des Arrays verkettet werden, aber beachte, dass das Ergebnis nach der Verkettung ein gewöhnliches Array ist, kein Tupel.

Beispiel

let tuple1: [number, string] = [42, "Hello"];
let tuple2: [boolean, number] = [true, 100];

let result = tuple1.concat(tuple2); // Das Ergebnis ist ein Array: [42, "Hello", true, 100]
console.log(result); // Ausgabe: [42, "Hello", true, 100]

Slicing von Tupeln

Sie können die slice-Methode des Arrays verwenden, um Slicing-Operationen auf einem Tupel durchzuführen, wodurch ein neues Array zurückgegeben wird.

Beispiel

let tuple: [number, string, boolean] = [42, "Hello", wahr];

let sliced = tuple.slice(1); // Slicing ab Index 1
console.log(sliced); // Ausgabe: ["Hello", true]

Iterieren über Tupel

Sie können eine for...of-Schleife oder die forEach-Methode verwenden, um über die Elemente in einem Tupel zu iterieren.

Beispiel

let tuple: [number, string, boolean] = [42, "Hello", wahr];

// Verwendung einer for...of-Schleife
for (let item of tuple) {
    console.log(item);
}

// Verwendung der forEach-Methode
tuple.forEach(item => console.log(item));

Umwandlung in ein reguläres Array

Obwohl ein Tupel ein Array mit fester Länge und festen Typen ist, können Sie es über Methoden von Array.prototype in ein gewöhnliches Array umwandeln, um es weiterzuverarbeiten.

Beispiel

let tuple: [number, string, boolean] = [42, "Hello", wahr];

// In ein Array umwandeln und Array-Methoden verwenden
let array = Array.from(tuple);
array.push("New Element");

console.log(array); // Ausgabe: [42, "Hello", true, "New Element"]

Tupel erweitern

Mit dem Rest-Operator können Sie mehrere Tupel einfach zu einem neuen Tupel zusammenführen:

Beispiel

let tuple1: [number, string] = [42, "Hello"];
let tuple2: [boolean] = [true];

let extendedTuple: [number, string, ...typeof tuple2] = [42, "Hello", ...tuple2];

console.log(extendedTuple); // Ausgabe: [42, "Hello", true]
Andere Erweiterungen