TypeScript Academy · Lektion

Der Typ void in Funktionen

Erfahren Sie, wie sich void an Rückgabepositionen von Funktionen von undefined unterscheidet.

Der Typ void in Funktionen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Der Rückgabetyp void

void beschreibt eine Funktion, die keinen nützlichen Wert zurückgibt. Die Funktion wird trotzdem abgeschlossen, erzeugt aber lediglich kein Ergebnis, das Sie verwenden sollten. Es ist der Typ von Funktionen, die wegen ihrer Seiteneffekte aufgerufen werden.

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

Abgeleitetes void

Wenn eine Funktion keine return-Anweisung (oder nur ein allein stehendes return;) enthält, leitet TypeScript automatisch void ab. Sie müssen den Typ nur selten ausdrücklich angeben, auch wenn dies die Absicht dokumentiert.

function greet(name: string) {
  console.log('Hi ' + name);
  // no return -> inferred void
}
greet('Ada');

void vs undefined

Die beiden Typen sind verwandt, aber nicht identisch. Eine void-Funktion kann tatsächlich undefined zurückgeben oder auch nicht, und Sie sollten sich nicht auf ihren Rückgabewert verlassen. Eine Funktion mit dem Rückgabetyp undefined muss diesen Wert ausdrücklich zurückgeben.

function a(): void { /* returns nothing useful */ }
function b(): undefined { return undefined; }
console.log(a(), b());

Ein void-Ergebnis sollte nicht verwendet werden

Der Laufzeitwert eines void-Aufrufs ist undefined, aber das Typsystem rät davon ab, ihn zu verwenden. Betrachten Sie void als „diesen Rückgabewert ignorieren“.

function save(): void {
  console.log('saved');
}
const result = save(); // result has type void
console.log(result); // undefined at runtime

void in Callback-Typen

Eine subtile, aber leistungsfähige Regel: Ein Callback, dessen Rückgabetyp void ist, kann auch durch eine Funktion erfüllt werden, die einen beliebigen Wert zurückgibt. Der zusätzliche Rückgabewert wird einfach ignoriert.

type Handler = () => void;

const h: Handler = () => 42; // returns number, still fine
h();
console.log('Returned value is ignored by callers');

Warum diese Regel existiert

Diese Flexibilität ermöglicht es, Funktionen wie arr.push (die eine Zahl zurückgibt) als void-Callbacks zu übergeben. Der Aufrufer hat zugesichert, den Rückgabewert nicht zu verwenden, daher ist jeder Rückgabewert unproblematisch.

const items: number[] = [];
const nums = [1, 2, 3];
nums.forEach((n) => items.push(n)); // push returns number, ok
console.log(items);

Kontextabhängiges void in Array-Methoden

forEach erwartet einen Callback, der void zurückgibt. Deshalb können Sie einen einzeiligen Arrow-Ausdruck schreiben, der nebenbei einen Wert zurückgibt, ohne dass ein Fehler entsteht – der kontextabhängige void-Typ fängt ihn ab.

const result: string[] = [];
['a', 'b'].forEach((x) => result.push(x.toUpperCase()));
console.log(result);

Eine häufige Verwechslung

Die void-Callback-Regel gilt für den Callback-Typ, nicht für Funktionen, deren eigener annotierter Rückgabetyp void ist. Eine Funktion, die wörtlich als (): void deklariert ist, kann weiterhin kein return value; mit einem Wert ungleich undefined enthalten.

function f(): void {
  return; // ok
  // return 5; // Error: 5 not assignable to void
}
f();
console.log('declared void cannot return a value');

void-Parameter sind ungewöhnlich

Obwohl selten, kann void in fortgeschrittenen Generics als Parametertyp auftreten. Im alltäglichen Code sehen Sie es fast immer als Rückgabetyp, der „kein sinnvolles Ergebnis“ signalisiert.

type Listener = (event: string) => void;

const onClick: Listener = (e) => console.log('Event:', e);
onClick('click');

void mit Promises

Asynchrone Funktionen geben häufig Promise<void> zurück, wenn sie eine Aufgabe ausführen, aber ohne Wert aufgelöst werden. Dieses Muster entspricht dem synchronen void für asynchronen Code.

async function sync(): Promise<void> {
  console.log('syncing...');
  // resolves with no value
}
sync().then(() => console.log('done'));

void bewusst wählen

Annotieren Sie void, wenn Sie vermitteln möchten, dass eine Funktion wegen ihrer Seiteneffekte existiert und Aufrufer nicht von einem Rückgabewert abhängen dürfen. Das verdeutlicht die Absicht und ermöglicht es Ihnen, die flexible Callback-Regel zu nutzen.

function notify(msg: string): void {
  console.log('NOTIFY:', msg);
}
const handlers: Array<(m: string) => void> = [notify];
handlers.forEach((fn) => fn('ping'));

Schnelltest

Testen Sie Ihr Verständnis des Typs void.

Zusammenfassung: void

Sie haben gelernt, dass void:

Funktionen kennzeichnet, die keinen nützlichen Wert zurückgeben.
sich von undefined unterscheidet: void-Ergebnisse sollten nicht verwendet werden.
als Callback-Typ Funktionen akzeptiert, die einen beliebigen Wert zurückgeben (der von den Aufrufern ignoriert wird).
die saubere Verwendung von Methoden wie push innerhalb von forEach ermöglicht.

Als Nächstes fügen wir alles zusammen: die sichere Verarbeitung von unknown.

const tasks: Array<() => void> = [
  () => console.log('task 1'),
  () => console.log('task 2')
];
tasks.forEach((t) => t());

Häufig gestellte Fragen

Ist die Lektion „Der Typ void in Funktionen“ kostenlos?

Ja — der vollständige Text von „Der Typ void in Funktionen“ 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 „Der Typ void in Funktionen“?

Erfahren Sie, wie sich void an Rückgabepositionen von Funktionen von undefined unterscheidet. 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 3 von 4.

Wie lange dauert die Lektion „Der Typ void in Funktionen“?

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