Primitive Typen in TypeScript

TypeScript hat dieselben primitiven Typen wie JavaScript, aber mit statischer Typisierung. In diesem Kapitel lernst du alle grundlegenden Typen kennen.

String

Für Textdaten:

let name: string = "Max";
let greeting: string = 'Hallo Welt';
let template: string = `Willkommen, ${name}!`;

// String-Methoden funktionieren mit TypeScript:
let upper: string = name.toUpperCase();
let length: number = name.length;

Number

Für alle Zahlen (Integer und Float):

let age: number = 25;
let price: number = 19.99;
let hex: number = 0xff;
let binary: number = 0b1010;
let octal: number = 0o744;

// Mathematische Operationen:
let sum: number = 10 + 5;
let product: number = 4 * 3;

JavaScript/TypeScript unterscheidet nicht zwischen Integer und Float - alles ist number.

Boolean

Für Wahrheitswerte:

let isActive: boolean = true;
let isCompleted: boolean = false;

// Aus Vergleichen:
let isAdult: boolean = age >= 18;
let isEmpty: boolean = name.length === 0;

Null und Undefined

Zwei spezielle Typen für “kein Wert”:

let nothing: null = null;
let notDefined: undefined = undefined;

// In der Praxis oft mit anderen Typen kombiniert:
let possibleName: string | null = null;
possibleName = "Max";  // Später zugewiesen

Unterschied

• undefined: Variable wurde deklariert, aber nicht initialisiert
• null: Explizit “kein Wert”

let a: string | undefined;
console.log(a);  // undefined

let b: string | null = null;
console.log(b);  // null

BigInt

Für sehr große Ganzzahlen (größer als Number.MAX_SAFE_INTEGER):

let bigNumber: bigint = 9007199254740991n;
let anotherBig: bigint = BigInt(9007199254740991);

// Operationen nur mit anderen BigInts:
let sum: bigint = bigNumber + 1n;

Symbol

Einzigartige Identifier:

let sym1: symbol = Symbol("key");
let sym2: symbol = Symbol("key");

// Jedes Symbol ist einzigartig:
console.log(sym1 === sym2);  // false

Literal Types

Typen können auf spezifische Werte beschränkt werden:

// String Literal
let direction: "north" | "south" | "east" | "west";
direction = "north";  // OK
direction = "up";     // Fehler!

// Number Literal
let diceRoll: 1 | 2 | 3 | 4 | 5 | 6;
diceRoll = 3;   // OK
diceRoll = 7;   // Fehler!

// Boolean Literal
let alwaysTrue: true = true;

Type Inference bei Primitiven

TypeScript erkennt den Typ automatisch:

let name = "Max";      // Typ: string
let age = 25;          // Typ: number
let active = true;     // Typ: boolean

// Bei const wird der Literal-Typ verwendet:
const status = "active";  // Typ: "active" (nicht string!)
const count = 42;         // Typ: 42 (nicht number!)

Const Assertions

Mit as const wird der engste mögliche Typ verwendet:

let status = "active" as const;  // Typ: "active"

// Praktisch für Objekte:
const config = {
    name: "App",
    version: 1
} as const;
// Typ: { readonly name: "App"; readonly version: 1; }

Template Literal Types

TypeScript unterstützt auch Template Literal Types:

type Color = "red" | "blue" | "green";
type Size = "small" | "large";

// Kombiniert zu:
type ColoredSize = `${Color}-${Size}`;
// "red-small" | "red-large" | "blue-small" | "blue-large" | ...

let variant: ColoredSize = "red-small";  // OK
let wrong: ColoredSize = "yellow-small"; // Fehler!

Praktische Beispiele

Funktion mit primitiven Typen

function createUser(
    name: string,
    age: number,
    isAdmin: boolean
): string {
    const role = isAdmin ? "Administrator" : "Benutzer";
    return `${name} (${age}) - ${role}`;
}

const info = createUser("Max", 25, false);
console.log(info);  // "Max (25) - Benutzer"

Status-Management

type Status = "idle" | "loading" | "success" | "error";

let currentStatus: Status = "idle";

function setLoading(): void {
    currentStatus = "loading";
}

function setSuccess(): void {
    currentStatus = "success";
}

function handleStatus(status: Status): string {
    switch (status) {
        case "idle":
            return "Warte auf Aktion...";
        case "loading":
            return "Lade...";
        case "success":
            return "Erfolgreich!";
        case "error":
            return "Fehler aufgetreten";
    }
}

Validierung

function isValidAge(age: number): boolean {
    return age >= 0 && age <= 150;
}

function isValidEmail(email: string): boolean {
    return email.includes("@") && email.includes(".");
}

function validateUser(
    name: string,
    age: number,
    email: string
): boolean {
    if (name.length < 2) return false;
    if (!isValidAge(age)) return false;
    if (!isValidEmail(email)) return false;
    return true;
}

Zusammenfassung

Die primitiven Typen in TypeScript:

Typ	Beschreibung	Beispiel
string	Text	"Hallo"
number	Zahlen	42, 3.14
boolean	Wahrheitswerte	true, false
null	Explizit kein Wert	null
undefined	Nicht definiert	undefined
bigint	Große Ganzzahlen	9007199254740991n
symbol	Einzigartige ID	Symbol("key")

Best Practices:

• Nutze Type Inference wo möglich
• Verwende Literal Types für bekannte Werte
• Vermeide null und undefined wo möglich, oder handle sie explizit

Im nächsten Kapitel lernst du Arrays und Tuples kennen!