TypeScript Academy · Lektion

Intrinsische String-Manipulationstypen

Verwenden Sie Uppercase, Lowercase, Capitalize und Uncapitalize.

Intrinsische String-Manipulationstypen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Integrierte String-Transformationen

TypeScript bietet vier intrinsische String-Manipulationstypen: Uppercase, Lowercase, Capitalize und Uncapitalize. Sie transformieren String-Literaltypen zur Compile-Zeit, ohne Laufzeitkosten zu verursachen.

Uppercase

Uppercase<S> wandelt jedes Zeichen eines String-Literaltyps in Großschreibung um. Das Literal 'hello' wird zum Typ 'HELLO'.

type Loud = Uppercase<"hello"> // "HELLO"
const x: Loud = "HELLO"
console.log(x)

Lowercase

Lowercase<S> bewirkt das Gegenteil und wandelt jedes Zeichen in Kleinschreibung um. 'HELLO' wird zu 'hello'.

type Quiet = Lowercase<"HELLO"> // "hello"
const x: Quiet = "hello"
console.log(x)

Capitalize

Capitalize<S> schreibt nur das erste Zeichen groß und lässt den Rest unverändert. 'name' wird zu 'Name'.

type Title = Capitalize<"name"> // "Name"
const x: Title = "Name"
console.log(x)

Uncapitalize

Uncapitalize<S> schreibt nur das erste Zeichen klein. 'Name' wird zu 'name' – praktisch, um Schlüssel von PascalCase in camelCase umzuwandeln.

type Camel = Uncapitalize<"Name"> // "name"
const x: Camel = "name"
console.log(x)

Eine Union transformieren

Wenden Sie einen intrinsischen Typ auf eine Union an, transformiert er jedes Mitglied. Uppercase von 'a' | 'b' ergibt 'A' | 'B'.

type Keys = "id" | "name"
type Upper = Uppercase<Keys> // "ID" | "NAME"
const k: Upper = "ID"
console.log(k)

Mit Template-Literalen kombinieren

Am leistungsfähigsten sind die intrinsischen Typen innerhalb von Template-Literaltypen. Eine Vorlage, die vor Capitalize eines Feldes das Präfix get setzt, erzeugt Getternamen, etwa für das Feld name.

type Field = "name" | "age"
// template: get + Capitalize<Field> => "getName" | "getAge"
const g: "getName" | "getAge" = "getName"
console.log(g)

Schlüsselnamen in gemappten Typen erzeugen

Bei der Neuzuordnung von Schlüsseln eines gemappten Typs erzeugen intrinsische Typen transformierte Eigenschaftsnamen – beispielsweise, indem sie jede Eigenschaft in einen großgeschriebenen Handler-Schlüssel umwandeln.

type Events = "click" | "drag"
// { [E in Events as on + Capitalize<E>]: () => void }
// produces keys onClick and onDrag
const handlers: { onClick: () => void } = { onClick: () => {} }
console.log(typeof handlers.onClick)

Intrinsische Typen verketten

Sie können intrinsische Typen verschachteln, um Transformationen zusammenzusetzen – beispielsweise Capitalize auf einen Lowercase-String anwenden, um die Groß- und Kleinschreibung zu normalisieren.

type Normalized = Capitalize<Lowercase<"hELLO">> // "Hello"
const x: Normalized = "Hello"
console.log(x)

Nur zur Compile-Zeit

Diese Typen existieren nicht zur Laufzeit. Um einen tatsächlichen String-Wert zu transformieren, rufen Sie weiterhin Methoden wie toUpperCase() auf; die intrinsischen Typen beeinflussen ausschließlich die statischen Typen.

function shout<S extends string>(s: S): Uppercase<S> {
  return s.toUpperCase() as Uppercase<S>
}
console.log(shout("hi")) // HI, typed as "HI"

Praktische Anwendungen

Verwenden Sie die intrinsischen Typen, um konstante Namen, Event-Schlüssel sowie Getter- und Setter-Namen abzuleiten und die Groß- und Kleinschreibung von Literal-typisierten Konfigurationsschlüsseln zu normalisieren – alles vom Compiler überprüft.

type Action = "add" | "remove"
type ActionType = Uppercase<Action> // "ADD" | "REMOVE"
const a: ActionType = "ADD"
console.log(a)

Kurze Überprüfung

Testen Sie Ihr Verständnis der intrinsischen Stringtypen.

Zusammenfassung

Die intrinsischen Typen Uppercase, Lowercase, Capitalize und Uncapitalize transformieren String-Literaltypen zur Compile-Zeit, verteilen die Transformation über Unions und lassen sich mit Template-Literal- und gemappten Typen kombinieren, um Schlüssel- und Handler-Namen zu erzeugen. Sie haben kein Laufzeitverhalten – verwenden Sie für Transformationen zur Laufzeit echte String-Methoden, während diese Typen die statischen Typen formen.

Häufig gestellte Fragen

Ist die Lektion „Intrinsische String-Manipulationstypen“ kostenlos?

Ja — der vollständige Text von „Intrinsische String-Manipulationstypen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Intrinsische String-Manipulationstypen“?

Verwenden Sie Uppercase, Lowercase, Capitalize und Uncapitalize. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Intrinsische String-Manipulationstypen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu TypeScript Academy