TypeScript Academy · Lektion

unknown und any verstehen

Erfahren Sie, warum unknown die typsichere Alternative zu any ist.

unknown und any verstehen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Zwei oberste Typen

TypeScript besitzt zwei Typen, die jeden Wert aufnehmen können: any und unknown. Sie sehen ähnlich aus, verhalten sich aber sehr unterschiedlich. Den richtigen Typ auszuwählen, ist eine zentrale Fähigkeit für typsicheren Code.

let a: any = 5;
let u: unknown = 5;
console.log(a, u);

any deaktiviert die Typprüfung

any ist ein Ausweg, der die Typprüfung für diesen Wert deaktiviert. Sie können auf jede Eigenschaft zugreifen oder den Wert wie eine Funktion aufrufen – der Compiler bleibt still, selbst wenn der Code zur Laufzeit abstürzen würde.

const a: any = 'hello';
console.log(a.toUpperCase()); // OK
// a.doesNotExist(); // no compile error, but crashes at runtime

unknown zwingt Sie zur Prüfung

unknown akzeptiert ebenfalls jeden Wert, aber Sie können ihn erst verwenden, wenn Sie nachgewiesen haben, um welchen Typ es sich handelt. Der Compiler blockiert den Zugriff auf Eigenschaften und Funktionsaufrufe, bis Sie den Typ eingegrenzt haben.

const u: unknown = 'hello';
// console.log(u.toUpperCase()); // Error: u is unknown
console.log(typeof u);

unknown mit typeof eingrenzen

Eine typeof-Prüfung grenzt unknown innerhalb des Blocks auf einen konkreten Typ ein. Nach dieser Eingrenzung stehen alle Methoden dieses Typs sicher zur Verfügung.

function shout(value: unknown): string {
  if (typeof value === 'string') {
    return value.toUpperCase(); // safe here
  }
  return 'not a string';
}
console.log(shout('hi'), shout(42));

Warum unknown sicherer ist

unknown steht für ehrliche Ungewissheit: „Ich weiß noch nicht, was das ist.“ Dadurch werden Sie gezwungen, den Wert vor der Verwendung zu validieren, und Fehler werden bereits zur Kompilierungszeit erkannt. any verbirgt die Ungewissheit und die Fehler dagegen einfach.

function len(value: unknown): number {
  if (typeof value === 'string') return value.length;
  if (Array.isArray(value)) return value.length;
  return 0;
}
console.log(len('abc'), len([1, 2]), len(99));

unknown zuweisen und von unknown zuweisen

Jeder Wert kann unknown zugewiesen werden. unknown kann jedoch nur unknown oder any zugewiesen werden – ohne Eingrenzung keinen spezifischen Typen. Diese Asymmetrie sorgt für Sicherheit.

let u: unknown = 10;
u = 'now a string';
u = true;
const anyVal: any = u; // allowed
console.log(anyVal);
// const s: string = u; // Error

any breitet sich in Ihrem Code aus

Eine gefährliche Eigenschaft von any ist, dass sich der Typ ausbreitet. Sobald ein Wert den Typ any hat, wird auch alles, was daraus abgeleitet wird, stillschweigend zu any und untergräbt so die Typsicherheit im gesamten Programm.

const a: any = { count: 5 };
const total = a.count + 10; // total is any
const flag = total.whatever; // still any, no error
console.log(total);

unknown hält das Risiko unter Kontrolle

Bei unknown bleibt die Ungewissheit auf ihren ursprünglichen Wert beschränkt. Sie müssen den Typ an jeder Grenze explizit eingrenzen, sodass unsichere Operationen nicht an andere Stellen gelangen können. Das Risiko bleibt dort, wo es hingehört.

const u: unknown = { count: 5 };
if (typeof u === 'object' && u !== null && 'count' in u) {
  console.log('Has count property');
}

API- und JSON-Grenzen typisieren

Externe Daten – JSON, Netzwerkantworten und Benutzereingaben – bieten keinerlei Garantien. Wenn Sie sie als unknown statt als any typisieren, erzwingt das eine Validierung, bevor Sie den Daten vertrauen. Das ist die sichere Standardeinstellung.

function parse(text: string): unknown {
  return JSON.parse(text);
}
const data = parse('{"id":1}');
if (typeof data === 'object' && data !== null) {
  console.log('Got an object');
}

Wann any vertretbar ist

any kann gelegentlich pragmatisch sein – bei schnellen Prototypen, einer schrittweisen Migration von JavaScript oder der Zusammenarbeit mit untypisierten Bibliotheken. Betrachten Sie es jedoch als vorübergehende Markierung, nicht als Gewohnheit. Bevorzugen Sie unknown, wann immer es möglich ist.

// Migration placeholder, to be typed later
let legacy: any = getLegacyValue();
function getLegacyValue() { return { x: 1 }; }
console.log(legacy.x);

Ein praktischer Vergleich

Direkt gegenübergestellt: Die any-Variante wird kompiliert, kann aber abstürzen; die unknown-Variante verweigert die Kompilierung des unsicheren Zugriffs. Der Compiler erfüllt seine Aufgabe und schützt Sie.

const a: any = 42;
console.log(a.toFixed(2)); // OK by luck

const u: unknown = 42;
if (typeof u === 'number') {
  console.log(u.toFixed(2)); // checked, safe
}

Kurzer Test

Testen Sie Ihr Verständnis von unknown und any.

Zusammenfassung: unknown und any

Die wichtigsten Punkte:

any deaktiviert die Typprüfung und breitet sich über abgeleitete Werte aus.
unknown akzeptiert jeden Wert, blockiert seine Verwendung aber, bis Sie ihn eingrenzen.
Verwenden Sie unknown für externe Daten wie JSON, APIs und Benutzereingaben, um eine Validierung zu erzwingen.
Reservieren Sie any für Migrationen oder die Zusammenarbeit mit untypisierten Bibliotheken – als vorübergehende Markierung.

Als Nächstes untersuchen wir den leeren Typ: never.

function safeLen(v: unknown): number {
  return typeof v === 'string' ? v.length : 0;
}
console.log(safeLen('hello'), safeLen(123));

Häufig gestellte Fragen

Ist die Lektion „unknown und any verstehen“ kostenlos?

Ja — der vollständige Text von „unknown und any verstehen“ 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 „unknown und any verstehen“?

Erfahren Sie, warum unknown die typsichere Alternative zu any ist. 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 1 von 4.

Wie lange dauert die Lektion „unknown und any verstehen“?

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