Datentypen

TypeScript bietet eine Vielzahl von Datentypen, mit denen Sie Ihre Variablen und Funktionen genauer beschreiben können. Hier sind die grundlegenden Datentypen in TypeScript:

12.1 Boolean

Ein einfacher wahr/falsch-Wert. Es wird durch das Schlüsselwort boolean bezeichnet:

let isDone: boolean = false;

12.2 Number

Eine Zahl. Anders als in JavaScript, das separate Nummerntypen für Ganzzahlen, Fließkommazahlen und so weiter hat, hat TypeScript nur einen Zahlentyp. Es wird durch das Schlüsselwort number bezeichnet:

let decimal: number = 6;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;

12.3 String

Eine Zeichenkette von Zeichen, wie in JavaScript. Es wird durch das Schlüsselwort string bezeichnet:

let color: string = "blue";
color = 'red';

12.4 Array

Ein Array von Werten. Array-Typen können auf eine von zwei Arten angegeben werden: Durch das Anhängen von [] an den Typ der Elemente oder durch die Verwendung des generischen Array-Typs Array<elemType>:

let list1: number[] = [1, 2, 3];
let list2: Array<number> = [1, 2, 3];

12.5 Tuple

Ein Tupel ermöglicht es, einen Array zu definieren, bei dem der Typ der fixen Anzahl von Elementen bekannt ist, aber nicht unbedingt gleich sein muss:

let x: [string, number];
x = ["hello", 10]; // OK
x = [10, "hello"]; // Error

12.6 Enum

Ein Mittel zum Erstellen von benutzerfreundlicheren Namen für Sets von numerischen Werten:

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

12.7 Any

In TypeScript ist any ein spezieller Datentyp, der verwendet wird, wenn der tatsächliche Typ einer Variablen zur Zeit der Schreibens nicht bekannt ist oder wenn man die strengen Typenprüfungen von TypeScript umgehen möchte.

Eine Variable des Typs any kann jeden Wert haben und jede Operation darauf ist erlaubt. Das bedeutet, dass Sie keinen Typfehler bekommen werden, egal was Sie mit einer any Variablen tun. Hier sind einige Beispiele:

let anything: any = 5;
anything = "hello";
anything = true;
anything = [];
anything.foo.bar.baz = "qux"; // Kein Fehler

Während der any Typ sehr flexibel ist, beseitigt seine Verwendung viele der Vorteile von TypeScript. Da der any-Typ im Wesentlichen die strengen Typenprüfungen von TypeScript abschaltet, sollten Sie ihn mit Vorsicht und nur dann verwenden, wenn es wirklich notwendig ist.

Manchmal kann es sinnvoll sein, den any Typ zu verwenden, zum Beispiel wenn Sie mit Bibliotheken oder Frameworks arbeiten, die nicht typisiert sind, oder wenn Sie Daten von einer API erhalten, deren Format Sie nicht vollständig kennen. In den meisten Fällen sollten Sie jedoch versuchen, spezifischere Typen zu verwenden, um die Vorteile der statischen Typisierung von TypeScript voll auszunutzen.

12.8 Void

Ein weiterer spezieller Typ ist void, der das Gegenteil von any ist: Es ist der Absenz von einem Typ. Es wird oft als Rückgabetyp von Funktionen verwendet, die keinen Wert zurückgeben:

function warnUser(): void {
 console.log("This is my warning message");
}

12.9 Null und Undefined

null und undefined in TypeScript repräsentieren jeweils die JavaScript-Werte null und undefined. Sie werden oft als “Abwesenheits” -Typen betrachtet, da sie die Abwesenheit eines Wertes repräsentieren. Standardmäßig sind sie Untertypen aller anderen Typen, was bedeutet, dass Sie null und undefined einer Variablen zuweisen können, die zum Beispiel vom Typ number ist:

let num: number = null; // Kein Fehler
let str: string = undefined; // Kein Fehler

Allerdings gibt es eine Compileroption namens strictNullChecks, die, wenn aktiviert, null und undefined nur den Typen null bzw. undefined zuweisen lässt. Dies kann nützlich sein, um unbeabsichtigte Null-/Undefined-Zuweisungen zu verhindern.

// Fehler, wenn strictNullChecks aktiviert ist
let num: number = null; 
// Fehler, wenn strictNullChecks aktiviert ist
let str: string = undefined;

In den meisten Fällen sollten Sie versuchen, null und undefined in Ihrem Code zu vermeiden, indem Sie immer sicherstellen, dass Ihre Variablen einen Wert haben. In manchen Fällen, wie z.B. wenn Sie mit einer API interagieren, die null oder undefined zurückgeben kann, müssen Sie jedoch mit diesen Werten umgehen können.

12.10 Never

Der never-Typ stellt den Typ der Werte dar, die niemals vorkommen. Zum Beispiel ist never der Rückgabetyp für einen Funktionsausdruck oder eine Arrow Function, die immer einen Ausnahmefehler auslösen oder die niemals einen Endpunkt erreichen.

// Function returning never must not have a reachable end point
function error(message: string): never {
  throw new Error(message);
}

12.11 Object

Ein nicht-primitiver Typ, d.h., irgendetwas, das nicht number, string, boolean, symbol, null, oder undefined ist:

declare function create(o: object | null): void;

create({ prop: 0 }); // OK
create(null); // OK

Diese Datentypen geben Ihnen mehr Kontrolle über Ihren Code und ermöglichen es dem TypeScript-Compiler, Ihnen potenzielle Probleme zu signalisieren, bevor sie zur Laufzeit auftreten.

12.12 Aufgaben

12.13 Lösungen

let myString: string = "Hallo Welt";
let myNumber: number = 123;
let myBoolean: boolean = true;
let myObject: object = {name: "John", age: 23};
let myNull: null = null;
let myUndefined: undefined = undefined;
let myAny: any = "Irgendein Wert";

let myArray: number[] = [1, 2, 3];
myArray.push(4);  // myArray ist jetzt [1, 2, 3, 4]

let myTuple: [string, number] = ["Hallo", 123];

function myFunction(name: string, age: number): void {
    console.log(`Name: ${name}, Age: ${age}`);
}
myFunction("John", 23);

function checkType(input: any): void {
    console.log(typeof input);
}
checkType("Hallo");  // Output: string
checkType(123);  // Output: number

let myVar: string | number;
myVar = "Hallo";  // Zulässig
myVar = 123;  // Zulässig

function printArray(arr: any[]): void {
    console.log(arr);
}
printArray([1, "Zwei", true, {name: "John", age: 23}]);

enum Wochentag {
    Montag,
    Dienstag,
    Mittwoch,
    Donnerstag,
    Freitag,
    Samstag,
    Sonntag
}
console.log(Wochentag.Montag);  // Output: 0
console.log(Wochentag["Montag"]);  // Output: 0

12 Datentypen