imported>Siegbert v2: /* Weblinks */ phpblogger.net ist inzwischen offline und agiert als Spam-WL=> Archivversion

2026-04-04T14:17:24Z

Weblinks: phpblogger.net ist inzwischen offline und agiert als Spam-WL=> Archivversion

Neue Seite

Eine '''Rückruffunktion''' ({{EnS|Callback}}) bezeichnet in der Informatik eine [[Funktion (Programmierung)|Funktion]], die einer anderen Funktion, meist einer vorgefertigten Bibliotheks- oder Betriebssystemfunktion, als [[Parameter (Informatik)|Parameter]] übergeben und von dieser unter definierten Bedingungen mit definierten Argumenten aufgerufen wird. Dieses Vorgehen folgt dem [[Entwurfsmuster]] der ''[[Inversion of Control]]''.

Meistens erlaubt die vorgefertigte Funktion die Übergabe eines sog. Benutzerparameters <code>lpParameter</code>, der von ihr (neben anderen Argumenten) zur Rückruffunktion durchgereicht wird, damit letztere im Kontext des ursprünglichen Aufrufers Daten sowohl abgreifen wie ablegen kann.

== Rückruf im selben Ablauf ==
[[Datei:ProgramExecCallbackSimple-de.png|rahmenlos|hochkant=1.5|rechts]]
{{nowrap|Das Bild zeigt einen Aufruf einer Routine eines anderen Kontextes}} (Betriebssystemaufruf, anderes Softwaremodul). Diesem Aufruf wird eine Referenz auf die Rückrufroutine übergeben. Die aufgerufene Routine kann dann in ihrem Ablauf die Rückrufroutine aufrufen. Die Rückrufroutine legt letztlich Daten ab, die im weiteren Programmablauf nach Rückkehr des ursprünglichen Aufrufes verwendet werden können. In der englischen Literatur wird diese Form als ''blocking callback'' oder ''synchronous callback'' bezeichnet.

Der Vorteil dieser Technik besteht darin, dass der Zugriff auf die Daten im eigenen Kontext formuliert wird und/oder im Rückruf eine beliebige programmtechnische Aufbereitung erfolgen kann: Die Parameter und der Aufrufzeitpunkt werden im anderen Softwaremodul bestimmt, die Bestimmung, was im Rückruf ausgeführt wird, obliegt dem eigenen Softwaremodul.

Dadurch wird ermöglicht, Funktionen allgemein zu definieren und erst beim Aufrufen der Funktion durch Angabe der Rückruffunktion das Verhalten exakt zu bestimmen. Häufig bekommt eine Rückruffunktion gar keinen Namen, sondern wird als ''[[Anonyme Subroutine|anonyme Funktion]]'' direkt beim Aufruf definiert (siehe auch [[Lambda-Kalkül]]). Über Rückruffunktionen erreicht man eine [[lose Kopplung]] zwischen einzelnen Komponenten.

== Rückruf aus einem anderen Thread ==
[[Datei:Callback mit Thread-Interkommunikation.png|rahmenlos|hochkant=1.5|rechts]]
{{nowrap|Bei Angabe einer Rückruffunktion ist es der aufgerufenen Funktion}} überlassen, wann diese den Rückruf ausführt ([[Inversion of Control]]). Es ist möglich, dass der Rückruf zu einem späteren Zeitpunkt aus einem anderen [[Thread (Informatik)|Thread]] heraus erfolgt. Das nebenstehende Bild zeigt das Prinzip. Die Zuordnung der Rückrufroutine zum eigenen Kontext ist die Gleiche wie im obigen Schema. Da der Rückruf in einem anderen Thread erfolgen kann, sind aber zusätzlich die Bedingungen für eine Datenkonsistenz ([[Mutex]]) einzuhalten. In der englischen Literatur wird diese Form als ''deferred callback'' oder ''asynchronous callback'' bezeichnet.

Ein Beispiel dafür ist der Aufruf <code>SetTimer(hWnd, ident, milliseconds, callbackRoutine)</code> in der Windows-API. Der Aufruf <code>SetTimer(...)</code> ist ein kurzer Betriebssystemaufruf, der nur im Betriebssystem den Timer initialisiert. Die <code>callbackRoutine</code> wird erst dann aufgerufen, wenn die Zeit abgelaufen ist. Das geschieht in einem Thread des Betriebssystems unabhängig vom Ablauf nach dem Aufruf von <code>SetTimer(...)</code>. In der bereitzustellenden Rückrufroutine kann beliebiger Code ausgeführt werden. Es ist allerdings dabei zu beachten, dass die Rückrufroutine nur kurz und nicht blockierend sein darf. Sonst besteht die Gefahr, dass das gesamte Betriebssystem oder mindestens der aktuelle Prozess blockiert. Letztlich sollte die Rückrufroutine eigentlich nur Daten ablegen und nicht selbst komplexe Aktionen beinhalten. Insbesondere kann für eine [[Ereignis (Programmierung)|ereignisorientierte Programmierung]] eine Event-Instanz erzeugt und abgelegt werden, die weitere Abläufe steuert.

== Dauerhafte Rückrufroutine ==
Eine Rückrufroutine kann nur jeweils für einen Aufruf gelten. Die Rückrufroutine kann in Bezug zum Aufruf auch mehrmals gerufen werden, bis die zugehörige Aktion beendet ist, also zeitlich begrenzt.

Aber auch die dauerhafte Zuordnung einer Routine wird teilweise als ''callback routine'' bezeichnet, beispielsweise ThreadProc callback function:<ref>[http://msdn.microsoft.com/en-us/library/windows/desktop/ms686736(v=vs.85).aspx msdn.microsoft...]</ref> Bei der Anlage eines Threads über die Windows-API wird die Threadfunktion als ''callback function'' angegeben.

Die Zuordnung einer Ereignisbehandlungsroutine beispielsweise zu einem HTML-Element <code><button onclick="function()" /></code> oder zu einem [[Widget]] innerhalb einer Programmierung grafischer Benutzeroberflächen folgt demselben Schema, wird aber in diesem Zusammenhang gewöhnlich nicht als ''callback'', sondern als ''event handler'' bezeichnet.

== Einfache Rückruffunktion oder objektorientierter Rückruf ==
Die sogenannten ''callback function'' in der Windows-API sind jeweils einfache C-Funktionen. Die Windows-API wird als C-Schnittstelle bereitgestellt. In Foren gibt es häufig Fragen nach der Möglichkeit, C++-Funktionen zuzuordnen. Notwendig ist hier eine Kapselung des C++-Aufrufes in einer C-Funktion, die die Dateninstanz kennt.

Anders ist es in objektorientierten Ansätzen eines Rückrufes. Statt der Angabe eines Funktionszeigers wird die Referenz auf ein Datenobjekt für den Rückruf übergeben. Das Datenobjekt muss ein für den Rückruf bestimmtes [[Schnittstelle (Objektorientierung)|Interface]] realisieren. Das Interface enthält dann mehrere mögliche Rückruffunktionen in der [[Tabelle virtueller Methoden]] innerhalb der Dateninstanz und kennt gleichzeitig die notwendigen Daten für die Ausführung des Rückrufes. Das Grundschema ist genau das gleiche wie in den obigen Schemata gezeigt.

== Beispiele ==
Es soll eine Funktion <code>apply_to</code> geschrieben werden, die eine beliebige andere [[Funktion (Programmierung)|Funktion]] auf eine [[Liste (Datenstruktur)|Liste]] von Werten anwendet und eine Liste der Ergebnisse zurückgibt. Eine Umsetzung in [[Pseudocode]]:

function '''apply_to''' (''rückruffunktion'', ''werte''):
var ''ergebnis''; // Liste für die Ergebnisse
foreach ''w'' in ''werte'' do // für alle Werte ...
''e'' = ''rückruffunktion'' (''w''); // rufe die Rückruffunktion ...
''ergebnis[]'' = ''e''; // und hänge das Resultat an die Ergebnisliste an.
end;
return ''ergebnis'';
end apply_to;

Diese Funktion kann jetzt folgendermaßen verwendet werden:

function '''verdoppeln''' (''wert''): // dies ist eine Rückruffunktion
return ''wert''*2;
end verdoppeln;

function '''quadrat''' (''wert''): // dies ist eine andere Rückruffunktion
return ''wert''*''wert'';
end quadrat;

// Anwenden der Funktionen auf eine Liste:

''werte'' = (1, 2, 3, 4);

''doppelte_Werte'' = '''apply_to'''('''verdoppeln''', ''werte''); //ergibt (2, 4, 6, 8)
''quadrierte_Werte'' = '''apply_to'''('''quadrat''', ''werte''); //ergibt (1, 4, 9, 16)

Oder, kürzer, in [[Lambda-Kalkül|Lambda-Notation]]:

''werte'' = (1, 2, 3, 4);

''doppelte_Werte'' = '''apply_to'''(lambda ''x'': ''x''*2, ''werte''); //ergibt (2, 4, 6, 8)
''quadrierte_Werte'' = '''apply_to'''(lambda ''x'': ''x''*''x'', ''werte''); //ergibt (1, 4, 9, 16)

=== JavaScript ===
Rückrufe werden bei der Implementierung von [[Programmiersprache|Programmiersprachen]] wie [[JavaScript]] verwendet, einschließlich der Unterstützung von JavaScript-Funktionen als Rückrufe über js-ctypes und in Komponenten wie addEventListener.

Im folgenden Beispiel wird zunächst eine Funktionsberechnung mit einem für den Rückruf bestimmten [[Parameter (Informatik)|Parameter]] definiert: ''rueckruffunktion''. Dann wird eine [[Funktion (Programmierung)|Funktion]] definiert, die als Rückruf zur Berechnung verwendet werden kann: ''berechneSumme''. Für ''rueckruffunktion'' können andere Funktionen verwendet werden, z. B. ''berechneProdukt''. In diesem Beispiel wird ''berechne(...)'' zweimal aufgerufen, einmal mit ''berechneSumme'' als Rückruf und einmal mit ''berechneProdukt''. Die Funktionen geben das Summe bzw. Produkt die zurück, und die Warnung zeigt sie auf dem Bildschirm an.<syntaxhighlight lang="javascript">
function berechne(zahl1, zahl2, rueckruffunktion)
{
return rueckruffunktion(zahl1, zahl2);
}

function berechneSumme(zahl1, zahl2)
{
return zahl1 + zahl2;
}

function berechneProdukt(zahl1, zahl2)
{
return zahl1 * zahl2;
}

// Gibt 20, die Summe von 5 and 15, aus
alert(berechne(5, 15, berechneSumme));

// Gibt 75, das Produkt von 5 und 15, aus
alert(berechne(5, 15, berechneProdukt));
</syntaxhighlight>

JavaScript verfügt über etliche vordefinierte Instanzmethoden mit einer Rückruffunktion als Parameter, unter anderem <code>Array.prototype.every()</code>, <code>Array.prototype.filter()</code>, <code>Array.prototype.find()</code>, <code>Array.prototype.findIndex()</code>, <code>Array.prototype.findLast()</code>, <code>Array.prototype.findLastIndex()</code>, <code>Array.prototype.flatMap()</code>, <code>Array.prototype.forEach()</code>, <code>Array.prototype.map()</code>, <code>Array.prototype.reduce()</code>, <code>Array.prototype.reduceRight()</code>, <code>Array.prototype.some()</code>, <code>Array.prototype.sort()</code>, <code>Window.requestAnimationFrame()</code>, <code>Window.setInterval()</code>, <code>Window.setTimeout()</code>. Von diesen wird nachfolgend <code>Array.prototype.reduce()</code> exemplarisch herangezogen, um ein Array [[Iteration|iterativ]] auf ein einzelnes Ergebnis zu reduzieren, und dabei mittels einer [[JavaScript#Erzeugung|Pfeilfunktion]] konkretisiert, wie dies für ein Wertepaar geschehen soll (beispielsweise durch Anwendung einer Zeichenketten-, Rechen- oder anderweitigen Operation). Wird der [[Methode (Programmierung)|Methode]] zudem ein zweites [[Argument (Informatik)|Argument]] mitgegeben (wie etwa Null, eine leere [[Zeichenkette]] oder ein leeres [[Array (Datentyp)|Array]]), so wird es als initialer Startwert der [[Iteration]] verwendet, andernfalls das erste Element des Arrays. Der zugrundeliegende Algorithmus ist weiter unten im [[#PowerShell|PowerShell-Beispiel]] skizziert.
<syntaxhighlight lang="javascript">
function f(s) { console.log(s) }
const array = [2, 5, 1, 3]; // Erzeugt ein Array mit 4 Elementen => 2,5,1,3
f(array.reduce((a, b) => a + b)); // Berechnet Summe => 11
f(array.reduce((a, b) => a * b)); // Berechnet Produkt => 30
f(array.reduce((a, b) => a)); // Gibt erstes Element zurück => 2
f(array.reduce((a, b) => b)); // Gibt letztes Element zurück => 3
f(array.reduce((a, b) => Math.min(a, b))); // Bestimmt Minimum => 1
f(array.reduce((a, b) => Math.max(a, b))); // Bestimmt Maximum => 5
f(array.reduce((a, b) => `${a}${b}`)); // Bewirkt Konkatenation => '2513'
f(array.reduce((a, b) => a + b, '')); // Bewirkt Konkatenation => '2513'
f(array.reduce(a => a + 1, 0)); // Zählt Elemente => 4

// Der Rückgabewert kann durchaus wieder ein Array sein:

f(array.reduce((a, b) => (a.push(b), a), [])); // Kopie => 2,5,1,3
f(array.reduce((a, b) => (a.unshift(b), a), [])); // Umkehrung => 3,1,5,2
f(array.reduce((a, b) => (a.push(b * b), a), [])); // Quadrierung => 4,25,1,9
f(array.reduce((a, b) => (a.push(b + b), a), [])); // Verdopplung => 4,10,2,6
f(array.reduce((a, b) => (a.push(`${b}${b}`), a), [])); // Dopplung => '22','55','11','33'
f(array.reduce((a, b) => (b > 2 && a.push(b), a), [])); // Filterung (auf größer 2) => 5,3
</syntaxhighlight>

=== C# ===
<syntaxhighlight lang="c#">
public class Hauptklasse
{
static void Main(string[] args)
{
Nebenklasse objekt = new Nebenklasse();

// Ruft die Methode von Nebenklasse mit Rückruffunktion als Parameter auf
objekt.Aufrufmethode(Rueckruffunktion);
}

// Diese Rückruffunktion gibt den im Rückruf angegebenen Text aus
static void Rueckruffunktion(string text)
{
Console.WriteLine("Der Rückruf lautet:" + text);
}
}

public class Nebenklasse
{
// Diese Methode hat eine andere Methode als Parameter und ruft diese auf
public void Aufrufmethode(Action<string> rueckruf)
{
// Ruft die Methode Rueckruffunktion in Hauptklasse mit der der angegebenen Textnachricht aus
rueckruf("Ich komme sofort zurück.");
}
}
</syntaxhighlight>

=== PowerShell ===
In [[PowerShell]] lassen sich Skriptblöcke nicht nur in Cmdlets wie <code>Register-ScheduledJob</code>, <code>Set-ScheduledJob</code>, <code>Start-Job</code>, <code>Invoke-Command</code>, <code>ForEach-Object</code>, <code>Where-Object</code>, <code>Select-Object</code>, <code>Format-List</code> und <code>Format-Table</code> einsetzen, um (innerhalb einer [[Pipe (Informatik)|Pipeline]]) ausgeführt zu werden oder mittels ihnen berechnete Objekteigenschaften ({{enS|''calculated property''}}) zu bestimmen, sondern auch (parametrisiert) als [[Anonyme Funktion|anonyme Funktionen]] gebrauchen.

Nachfolgend ist die Funktion <code>Reduce-Array</code> ganz allgemein dazu in der Lage, ein [[Array (Datentyp)|Array]] auf einen einzigen Wert zu reduzieren. Wie dies konkret geschehen soll (beispielsweise per [[Konkatenation (Wort)|Konkatenation]], Summenbildung, Produktbildung oder Rückgabe des ersten, letzten, kleinsten oder größten Elements), wird mittels einer Rückruffunktion spezifiziert, die zwei Werte entgegennimmt und einen zurückliefert. Durch deren [[Iteration|iterative]] Anwendung lässt sich eine mehrelementige Eingabe letztlich zu einem einzelnen Ergebnis verdichten. Optional kann der Funktion <code>Reduce-Array</code> als weiteres Argument ein initialer Startwert mitgegeben werden, wie etwa Null, eine leere [[Zeichenkette]] oder ein leeres [[Array (Datentyp)|Array]].<ref>{{Internetquelle |url=http://mawe-web.de/powershell.html#callback |titel=Anonyme Funktionen und Rückruffunktionen |abruf=2025-03-06}}</ref>
<syntaxhighlight lang="powershell">
function Reduce-Array {
param ([Array]$Array = @(), [ScriptBlock]$Callback = {}, $Value)
[Int]$i = $null -eq $Value
if ($i -and $Array.Count) { # Wenn weder Initialwert übergeben noch Array leer, ...
$Value = $Array[0] # ... dann erstes Element als Initialwert verwenden
}
while ($i -lt $Array.Count) { # (Übrige) Elemente durchlaufen ...
$Value = &$Callback $Value $Array[$i++] # ... und jeweils Rückruffunktion anwenden
}
$Value
}
Reduce-Array 2,5,1,3 { param($x, $y) $x + $y } # Berechnet Summe => 11
Reduce-Array 2,5,1,3 { param($x, $y) $x * $y } # Berechnet Produkt => 30
Reduce-Array 2,5,1,3 { param($x, $y) $x } # Gibt erstes Element zurück => 2
Reduce-Array 2,5,1,3 { param($x, $y) $y } # Gibt letztes Element zurück => 3
Reduce-Array 2,5,1,3 { param($x, $y) [Math]::Min($x, $y) } # Bestimmt Minimum => 1
Reduce-Array 2,5,1,3 { param($x, $y) [Math]::Max($x, $y) } # Bestimmt Maximum => 5
Reduce-Array 2,5,1,3 { param($x, $y) [String]$x + $y } # Bewirkt Konkatenation => "2513"
Reduce-Array "2","5","1","3" { param($x, $y) $x + $y } # Bewirkt Konkatenation => "2513"
Reduce-Array 2,5,1,3 { param($x, $y) $x + $y } "" # Bewirkt Konkatenation => "2513"
Reduce-Array 2,5,1,3 { param($x) $x + 1 } 0 # Zählt Elemente => 4

# Der Rückgabewert kann durchaus wieder ein Array sein:

'Original => 2,5,1,3'
2,5,1,3 | ConvertTo-Json
'Kopie => 2,5,1,3'
Reduce-Array 2,5,1,3 { param($x, $y) @($x) + $y } | ConvertTo-Json
'Umkehrung => 3,1,5,2'
Reduce-Array 2,5,1,3 { param($x, $y) @($y) + $x } | ConvertTo-Json
'Quadrierung => 4,25,1,9'
Reduce-Array 2,5,1,3 { param($x, $y) @($x) + $y * $y } @() | ConvertTo-Json
'Verdopplung => 4,10,2,6'
Reduce-Array 2,5,1,3 { param($x, $y) @($x) + $y * 2 } @() | ConvertTo-Json
'Verdopplung => "22","55","11","33"'
Reduce-Array "2","5","1","3" { param($x, $y) @($x) + $y * 2 } @() | ConvertTo-Json
'Verdopplung => "22","55","11","33"'
Reduce-Array 2,5,1,3 { param($x, $y) @($x) + [String]$y * 2 } @() | ConvertTo-Json
'Filterung (auf Elemente größer 2) => 5,3'
Reduce-Array 2,5,1,3 { param($x, $y) @($x) + (@($y) -gt 2) } @() | ConvertTo-Json
</syntaxhighlight>

=== PHP ===
''[[PHP]]'' verfügt über vordefinierte Array-Funktionen, denen eine Rückruffunktion als [[Parameter (Informatik)|Argument]] übergeben werden kann, unter anderem <code>array_all()</code>, <code>array_any()</code>, <code>array_filter()</code>, <code>array_find()</code>, <code>array_map()</code>, <code>array_udiff()</code>, <code>array_uintersect()</code>, <code>array_walk()</code>, <code>uasort()</code>, <code>uksort()</code>, <code>usort()</code>. Dazu gehört auch <code>array_reduce()</code>, welche durch [[Iteration|iteratives]] Vorgehen ein Array auf ein einzelnes Ergebnis reduziert und deren Wirkungsweise nachfolgend demonstriert wird. Soll dabei nicht <code>null</code> als (neutraler) Anfangswert für die Iteration dienen, muss über einen optionalen dritten Parameter etwas anderes festgelegt werden, beispielsweise <code>0</code> für additive, <code>1</code> für multiplikative oder <code>""</code> für konkatenierende Operationen.
<syntaxhighlight lang="php">
<?php
$werte = array(2, 5, 1, 3); // Array mit 4 Elementen
$anzahl = function ($carry) { return $carry + 1; };
$summe = function ($carry, $item) { return $carry + $item; };
$produkt = function ($carry, $item) { return $carry * $item; };
$konkatenation = function ($carry, $item) { return $carry . $item; };
echo array_reduce($werte, $anzahl, 0), "\n"; // Zählt die Elemente => 4
echo array_reduce($werte, $summe), "\n"; // Summiert die Elemente => 11
echo array_reduce($werte, $produkt, 1), "\n"; // Multipliziert die Elemente => 30
echo array_reduce($werte, $konkatenation), "\n"; // Konkateniert die Elemente => "2513"
echo $konkatenation($konkatenation($konkatenation(2, 5), 1), 3), "\n"; // dto. => "2513"

// Der Rückgabewert kann durchaus wieder ein Array sein:

$kopie = function ($carry, $item) { array_push($carry, $item); return $carry; };
$umkehrung = function ($carry, $item) { array_unshift($carry, $item); return $carry; };
$verdopplung = function ($carry, $item) { array_push($carry, $item * 2); return $carry; };
$quadrierung = function ($carry, $item) { array_push($carry, $item ** 2); return $carry; };
function filterung($carry, $item) { $item > 2 && array_push($carry, $item); return $carry; }
function dump($var) { print_r($var) /* oder var_dump($var) oder var_export($var) */; }
dump(array_reduce($werte, $kopie, [])); // Kopie des Arrays => [2, 5, 1, 3]
dump(array_reduce($werte, $umkehrung, [])); // Umkehrung der Elemente => [3, 1, 5, 2]
dump(array_reduce($werte, $verdopplung, [])); // Verdopplung jedes Elements => [4, 10, 2, 6]
dump(array_reduce($werte, $quadrierung, [])); // Quadrierung jedes Elements => [4, 25, 1, 9]
dump(array_reduce($werte, "filterung", [])); // Filterung (auf Elemente größer 2) => [5, 3]
dump(filterung(filterung(filterung(filterung([], 2), 5), 1), 3)); // dto. => [5, 3]
?>
</syntaxhighlight>

== Siehe auch ==
* [[Hook (Informatik)]]
* [[Signal-Slot-Konzept]]

== Weblinks ==
* {{Webarchiv |url=http://www.phpblogger.net/2008/10/17/hook-und-callback-funktionen-teil-3/ |wayback=20081020051304 |text=Hook- und Callback-Funktionen mit PHP}} (deutsches Tutorial)
* [https://javascript.info/callbacks Einführung in Rückruffunktionen mit JavaScript]
* [https://www.geeksforgeeks.org/javascript-callbacks/ JavaScript | Callbacks]
* [https://docs.microsoft.com/en-us/dotnet/framework/interop/how-to-implement-callback-functions How to: Implement Callback Functions] (Microsoft Docs)

== Einzelnachweise ==
<references />

{{SORTIERUNG:Ruckruffunktion}}
[[Kategorie:Programmierung]]

Rückruffunktion - Versionsgeschichte

imported>Siegbert v2: /* Weblinks */ phpblogger.net ist inzwischen offline und agiert als Spam-WL=> Archivversion