TypeScript-Grundtypen

Grundtypen ermöglichen Entwicklern, die Struktur und Absicht von Daten genauer zu beschreiben.

Die in TypeScript enthaltenen Datentypen sind wie folgt:

TypeBeschreibungBeispiel
stringRepräsentiert Textdatenlet name: string = "Alice";
numberRepräsentiert Zahlen, einschließlich Ganzzahlen und Gleitkommazahlen.let age: number = 30;
booleanRepräsentiert einen booleschen Wert.trueoderfalselet isDone: boolean = true;
arrayRepräsentiert ein Array von Elementen desselben Typs.let list: number[] = [1, 2, 3];
tupleStellt ein Array mit bekannten Typen und Länge darlet person: [string, number] = ["Alice", 30];
enumDefiniert eine Menge benannter Konstantenenum Color { Red, Green, Blue };
anyBeliebiger Typ, ohne Typprüfunglet value: any = 42;
voidKein Rückgabewert (wird oft für Funktionen verwendet)function log(): void {}
nullStellt einen leeren Wert darlet empty: null = null;
undefinedStellt undefined darlet undef: undefined = undefined;
neverStellt keinen Rückgabewert darfunction error(): never { throw new Error("error"); }
objectStellt nicht-primitive Typen darlet obj: object = { name: "Alice" };
unionUnion-Typ, was bedeutet, dass er einer von mehreren Typen sein kann`let id: string
unknownUngewisser Typ, muss vor der Verwendung auf seinen Typ geprüft werdenlet value: unknown = "Hello";

Hinweis:TypeScript und JavaScript haben keinen Integer-Typ.

1. string

Stellt Textdaten dar; kann nur Strings speichern und wird üblicherweise zur Beschreibung von Textinformationen verwendet.

let message: string = "Hello, TypeScript!";

Template-Strings:TypeScript unterstütztTemplate-Strings, die Backticks verwenden`(denken Sie daran, keine einfachen Anführungszeichen '), um sie zu definieren, wodurch Variablen oder Ausdrücke in Strings eingefügt werden können. Sie sind ideal für mehrzeiligen Text und Variablenverkettung.

let name: string = "Alice";
let greeting: string = `Hello, ${name}! Welcome to TypeScript.`;
console.log(greeting); // 输出:Hello, Alice! Welcome to TypeScript.

2. number

TypeScript verwendet den Typ number, um alle Zahlen darzustellen, einschließlich Ganzzahlen und Gleitkommazahlen.

let age: number = 25;
let temperature: number = 36.5;

3. boolean

Stellt die logischen Werte true oder false dar und wird für Bedingungsprüfungen verwendet.

let isCompleted: boolean = false;

4. array

Es kann eine Gruppe von Elementen desselben Typs darstellen. Es kann auf zwei Arten ausgedrückt werden: type[] oder Array<type>.

let numbers: number[] = [1, 2, 3];
let names: Array<string> = ["Alice", "Bob"];

5. tuple

Stellt ein Array mit bekannter Anzahl und bekannten Typen von Elementen dar. Jedes Element kann einen anderen Typ haben; geeignet zur Darstellung von Daten mit einer festen Struktur.

let person: [string, number] = ["Alice", 25];

6. enum

Wird verwendet, um eine Menge benannter Konstanten zu definieren. Standardmäßig starten enum-Werte bei 0 und steigen an.

enum Color {
  Red,
  Green,
  Blue,
}
let favoriteColor: Color = Color.Green;

7. any

Er kann jeden Typ darstellen. Er eignet sich für Fälle, in denen der Datentyp ungewiss ist, sollte jedoch mit Vorsicht verwendet werden, weil any die Typprüfung umgeht.

let randomValue: any = 42;
randomValue = "hello";

Der any-Typ ist ein Datentyp, den TypeScript für Variablen verwendet, deren Typ während der Programmierung unklar ist. Er wird üblicherweise in den folgenden drei Situationen verwendet.

1. Wenn sich der Wert einer Variablen dynamisch ändert, z. B. durch Benutzereingaben, erlaubt der any-Typ diesen Variablen, die Typprüfung während der Kompilierungsphase zu überspringen. Der Beispielcode lautet wie folgt:

let x: any = 1;    // 数字类型
x = 'I am who I am';    // 字符串类型
x = false;    // 布尔类型

Beim Umschreiben vorhandenen Codes ermöglicht any, die Typprüfung während der Kompilierung selektiv einzuschließen oder zu entfernen. Der Beispielcode lautet wie folgt:

let x: any = 4;
x.ifItExists();    // 正确,ifItExists方法在运行时可能存在,但这里并不会检查
x.toFixed();    // 正确

Beim Definieren eines Arrays, das Daten verschiedener Typen speichert, lautet der Beispielcode wie folgt:

let arrayList: any[] = [1, false, 'fine'];
arrayList[1] = 100;

8. void

Wird für Funktionen ohne Rückgabewert verwendet. Bei der Deklaration einer Variablen bedeutet der void-Typ, dass ihr nur null oder undefined zugewiesen werden kann.

function logMessage(message: string): void {
  console.log(message);
}

9. null und undefined

null und undefined stehen jeweils für "leerer Wert" und "undefiniert". Standardmäßig sind sie Untertypen aller Typen, aber durch Setzen von strictNullChecks kann eine strikte Prüfung aktiviert werden.

let empty: null = null;
let notAssigned: undefined = undefined;

null

In JavaScript bedeutet null "nichts".

null ist ein spezieller Typ mit nur einem Wert. Er repräsentiert eine leere Objektreferenz.

Die Verwendung von typeof zum Erkennen von null gibt "object" zurück.

undefined

In JavaScript ist undefined eine Variable, der kein Wert zugewiesen wurde.

Der Aufruf von typeof für eine Variable ohne Wert gibt undefined zurück.

null und undefined sind Untertypen aller anderen Typen (einschließlich void) und können anderen Typen wie number zugewiesen werden. In diesem Fall wird der Typ nach der Zuweisung null oder undefined. Wenn jedoch in TypeScript die Funktion zur strikten Nullprüfung (--strictNullChecks) aktiviert ist, können null und undefined nur void oder ihren eigenen entsprechenden Typen zugewiesen werden. Beispielcode:

// 启用 --strictNullChecks
let x: number;
x = 1; // 编译正确
x = undefined;    // 编译错误
x = null;    // 编译错误

In dem obigen Beispiel kann die Variable x nur vom Typ number sein. Wenn ein Typ null oder undefined sein kann, können Sie | verwenden, um mehrere Typen zu unterstützen. Beispielcode:

// 启用 --strictNullChecks
let x: number | null | undefined;
x = 1; // 编译正确
x = undefined;    // 编译正确
x = null;    // 编译正确

Weitere Informationen finden Sie unter:JavaScript typeof, null und undefined

10. never

Stellt keinen Rückgabewert dar; wird üblicherweise für Funktionen verwendet, die Fehler auslösen oder in Endlosschleifen geraten, was bedeutet, dass die Funktion nie normal beendet wird.

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

never ist ein Untertyp aller anderen Typen (einschließlich null und undefined) und repräsentiert Werte, die nie auftreten. Das bedeutet, dass einer als Typ never deklarierten Variablen nur ein Wert vom Typ never zugewiesen werden kann. In Funktionen zeigt es sich üblicherweise als Auslösen einer Ausnahme oder als Nichterreichen eines Endpunkts (z. B. einer Endlosschleife). Beispielcode:

let x: never;
let y: number;

// 编译错误,数字类型不能转为 never 类型
x = 123;

// 运行正确,never 类型可以赋值给 never类型
x = (()=>{ throw new Error('exception')})();

// 运行正确,never 类型可以赋值给 数字类型
y = (()=>{ throw new Error('exception')})();

// 返回值为 never 的函数可以是抛出异常的情况
function error(message: string): never {
    throw new Error(message);
}

// 返回值为 never 的函数可以是无法被执行到的终止点的情况
function loop(): never {
    while (true) {}
}

11. object

Stellt nicht-primitive Werte dar, geeignet für komplexe Objektstrukturen.

let person: object = { name: "Alice", age: 30 };

12. Union-Typen

Stellt dar, dass eine Variable einen von mehreren Typen annehmen kann. Implementiert mit dem Symbol |.

let id: string | number;
id = "123";
id = 456;

13. unknown (unsicherer Typ)

Ähnlich wie any, aber strenger. Er muss typgeprüft werden, bevor er Variablen anderer Typen zugewiesen werden kann.

let value: unknown = "Hello";
if (typeof value === "string") {
  let message: string = value;
}

14. Typzusicherungen

Typzusicherungen ermöglichen es Entwicklern, dem Compiler explizit den Typ einer Variablen mitzuteilen; sie werden häufig verwendet, wenn der Typ nicht abgeleitet werden kann. Die as-Syntax oder die Winkelklammer-Syntax kann verwendet werden.

let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;

15. Literaltypen

Literaltypen erlauben es einer Variablen, nur bestimmte Werte anzunehmen, und werden zusammen mit Union-Typen verwendet, um bestimmte Zustände einer Variablen zu definieren.

let direction: "up" | "down" | "left" | "right";
direction = "up";

Durch diese Typen bietet TypeScript eine stärkere Typsicherheit und Codeprüfungsmöglichkeiten, wodurch Entwickler Daten und Absichten klarer und präziser ausdrücken können und Laufzeitfehler reduziert werden.


Beispiel

Das folgende Beispiel demonstriert die Definition und Verwendung der wichtigsten grundlegenden Typen in TypeScript und simuliert ein Benutzerobjekt sowie zugehörige Operationsfunktionen.

Beispiel

// Definiere einen Enum-Typ, um die Rolle des Benutzers darzustellen
enum Role {
  Admin,
  Benutzer,
  Guest,
}

// Verwende interface, um die Struktur des Benutzers zu definieren
interface User {
  id: number;               // number-Typ, wird verwendet, um den Benutzer eindeutig zu identifizieren
  username: string;         // string-Typ, der den Benutzernamen darstellt
  isActive: boolean;        // boolean-Typ, der angibt, ob der Benutzer aktiv ist
  role: Role;               // enum-Typ, wird verwendet, um die Benutzerrolle darzustellen
  hobbies: string[];        // Array-Typ, der die Hobbys des Benutzers speichert
  contactInfo: [string, number]; // Tupel-Typ, ein Tupel, das eine Telefonnummer enthält, im Format: [Vorwahl, Telefonnummer]
}

// Erstelle ein Benutzerobjekt, das der Struktur des User-Interface entspricht
const user: User = {
  id: 1,
  username: "Alice",
  isActive: true,
  role: Role.User,
  hobbies: ["Reading", "Gaming"],
  contactInfo: ["+1", 123456789],
};

// Definiere eine Funktion, die einen String zurückgibt, um Benutzerinformationen abzurufen
function getUserInfo(user: User): string {
  return `Benutzer ${user.username} ist ${user.isActive ? "aktiv" : "inaktiv"} mit der Rolle ${Role[user.role]}`;
}

// Verwende den void-Typ, um eine Funktion zu definieren, die gezielt Benutzerinformationen ausgibt
function printUserInfo(user: User): void {
  console.log(getUserInfo(user));
}

// Definiere einen Funktionsparameter vom Union-Typ, der eine Benutzer-ID (number) oder einen Benutzernamen (string) akzeptiert
function findUser(query: number | string): User | undefined {
  // Verwende typeof, um den Typ von query zu bestimmen
  if (typeof query === "number") {
    // Wenn es eine Zahl ist, finde den Benutzer anhand der ID
    return query === user.id ? user : undefined;
  } else if (typeof query === "string") {
    // Wenn es ein String ist, finde den Benutzer anhand des Benutzernamens
    return query === user.username ? user : undefined;
  }
  return undefined;
}

// Definiere eine Funktion mit dem Typ never, um ungewöhnliche Situationen im Programm zu behandeln
function throwError(message: string): never {
  throw new Error(message);
}

// Verwende den Typ any, um Daten mit unbekanntem Typ zu behandeln
let unknownData: any = "Dies ist ein String";
unknownData = 42; // Erneut einer Zahl zuweisen, der Typ ist any

// Verwende den Typ unknown, um unsichere Daten zu behandeln, was sicherer ist
let someData: unknown = "Mögliche Daten";
if (typeof someData === "string") {
  console.log(`Länge der Daten: ${(someData as string).length}`);
}

// Jede Funktion aufrufen und testen
printUserInfo(user);                    // Benutzerinformationen ausgeben
console.log(findUser(1));               // Benutzer anhand der ID finden
console.log(findUser("Alice"));         // Benutzer anhand des Benutzernamens finden

// Variablen mit den Typen null und undefined
let emptyValue: null = null;
let uninitializedValue: undefined = undefined;

Erklärung:

  • Enum-Typ (Role): Wird verwendet, um benannte Konstanten für Benutzerrollen zu definierenAdmin、UserundGuest。
  • Interface (User): definiertUserdie Struktur eines Objekts, einschließlichid、username、isActiveEigenschaften wie ..., die ... veranschaulichenstring、number、boolean、arrayundtupledie Verwendung von Typen.
  • FunktiongetUserInfo: gibt eine Beschreibung des Benutzers zurück, wobei String-Interpolation zusammen mitenum。
  • FunktionprintUserInfo: der Typ istvoid, weil es nur Informationen ausgibt und keinen Wert zurückgibt.
  • Union-Typ (number | string): verwendet fürfindUserder Parameter der Funktion, der Zahlen oder Strings akzeptieren kann.
  • nevertype:throwErrorDie Funktion wirft einen Fehler und kehrt nicht normal zurück, daher verwendet sieneverTyp.
  • anytype: demonstriert, wie man eine Variable deklariert, die jeden Typ akzeptieren kann.
  • unknowntype: ähnlich wieany, aber sicherer; im Beispiel wird eine Typüberprüfung vor der Typzusicherung durchgeführt.
  • nullundundefined: demonstriert die Verwendung von Nullwerten.
Weitere Erweiterungen