PHP/Benutzerdefinierte Funktionen

Funktionen sind kleine Programmabschnitte oder Module. die PHP-Code enthalten. Benutzerdefinierte Funktionen werden ebenso wie die eingebauten Funktionen aus anderen Funktionen oder der "Stammebene" des Skripts heraus aufgerufen. Funktionen können Werte zurückgeben, beispielsweise das Ergebnis einer Berechnung. Werte sind alles, was in VVariablen gespeichert werden kann, also auch komplexe Gebilde wie Arrays oder Objekte.

Funktionsdefinition

Benutzerdefinierte Funktionen werden durch das Schlüsselwort "function" eingeleitet. Die Syntax kann wie folgt aussehen. Der Funktionskopf besteht aus dem Namen der Funktion (hier "meinefunktion") und in runden Klammern einer Auflistung der erwarteten Parameter. Diese Werte werden der Funktion beim Aufruf übergeben. Ein Zwang zur Übergabe von Werten besteht aber nicht; wenn keine Werte benötigt werden, wird einfach ein leeres Klammernpaar geschrieben.

function meinefunktion($parameter1, $parameter2, ...) { ## Hier werden Befehle ausgeführt return $rueckgabe; }

Der Befehl "return()" enthält als Parameter den Rückgabewert. Das kann ein Ausdruck oder eine einzelne Varaible sein. An welcher Stelle innerhalb der Funktion "return" eingesetzt wird ist gleichgültig. Auch die mehrfache Notation ist zulässig - dabei wird nach dem Grundsatz "wer zuerst kommt, mahlt zuerst" verfahren und die Funktion wird sofort verlassen. Aus Gründen sauberer Programmierung sollte "return" aber pro Funktion nur einmal und nur am Ende eingesetzt werden.

In PHP werden die Funktionen erst nach dem Abarbeiten des Skripts im Parser gebunden. "Gebunden" bedeutet in diesem Zusammenhang den zeitpunkt, wann die Adresse der übersetzten Funktion im Speicher ermittelt und zum Aufruf bereitgestellt wird. Es ist deshalb gleichgültig, wann Funktionen definiert werden.

Funktionsargumente

Die Übergabe von Argumenten an eine Funktion (die dann dort Parametern entsprechen) kann auf verschiedene Weise erfolgen. Im einfachsten Fall wird der Variablenname angegeben. Der Aufruf der Funktion kann dann erfolgen, indem Werte eingesetzt werden. Beim Aufruf können natürlich auch Variablen eingesetzt werden; die Variablennamen können dabei gleich sein, da Variablen innerhalb einer Funktion nicht im Konflikt mit den globalen Variablen stehen.

<?php function print_value($name, $ort) { echo "$name wohnt in $ort.<br />\n"; } print_value("Max Müller", "Berlin"); $name = "Max Müller"; $ort = "Berlin"; print_value($name, $ort); ?>

Max Müller wohnt in Berlin. Max Müller wohnt in Berlin.

Verhalten lokaler und globaler Variablen beim Funktionsaufruf.

<?php function print_value($name, $ort) { echo "$name wohnt in $ort.<br />\n"; $name = "Neuer Name"; $ort = "Neuer Ort"; } $name = "Max Müller"; $ort = "Berlin"; print_value($name, $ort); print_value($name, $ort); ?>

Max Müller wohnt in Berlin. Max Müller wohnt in Berlin.

Manchmal ist die Veränderung der Variablen erwünscht. So schreibt etwa folgende Funktion sämtliche in HTML übergebenen Werte fett. Der Name der Variable ist dabei gleichgültig - entscheidend ist die Kennzeichnung der Argumente mit "&". In diesem Fall wird der globalen Variable der neue Wert zugewiesen. Diese Vorgehensweise wird als Parameterübergabe durch Referenz (ByRef) bezeichnet. Der normale Weg ist die Parameterübergabe von Werten (ByVal), Änderungen wirken sich dann nicht auf die Quelle aus.

<?php function make_b(&$html) { $html = "<b>$html</b>"; } $ausgabe = "Test"; echo "$ausgabe<br />\n"; make_b($ausgabe); echo "$ausgabe<br />\n"; ?>

Test Test

Das Beispiel mag umständlich erscheinen, die folgende Zeile ist zwar kompakter, jedoch falsch. Syntaktisch ist sie zwar richtig, doch gibt die Beispielfunktion "make_b" nichts zurück - sie ändert nur eine übergebene Variable. Der Befehl "echo" erwartet aber Werte, die er an den Webbrowser senden kann; an die eingeschlossene Variable "$ausgabe" kommt er nicht heran. Diese wird zwar geändert, das Ergebnis aber quasi verworfen.

echo make_b($ausgabe);

Wird die Anwendung dennoch in dieser Form benötigt, so wird "return" eingesetzt.

function make_b($html) { return "<b>$html</b>"; }

Eine Funktion kann normalerweise nur einen Wert zurückgeben. Sind aber mehrere referenzierte Argumente vorhanden, so kann jeder Wert direkt geändert werden und so ausserhalb der Funktion wirksam werden. Als Wert wird auch ein Array akzeptiert. Im folgenden Abschnitt wird gezeigt, wie mehrere Werte mit Hilfe von Arrays zurückgegeben werden können und wie Argumente übergeben werden, deren Anzahl zum Entwurfszeitpunkt nicht bekannt ist.

Optionale Parameter kommen in PHP zum Einsatz, um variable Argumentelisten nachzuahmen. Allgemein können einzelne Argumente beim Aufruf weggelassen werden. In diesem Fall wird die betreffende Variable nicht initialisiert. Um zusätzliche Tests zu vermeiden und Laufzeitfehler innerhalb der Funktion nicht zu provozieren, kann jedes Argument mit einem Standardwert belegt werden. Dazu wird der Funktionskopf um eine Zuweisung erweitert.

function print_value($name = "Name", $ort = "Ort")

Eleganter ist die Verwendung von Konstanten.

define("NONAME", "Kein Name"); ... function print_value($name = NONAME, $ort = "Ort")

Der Umgang mit optionalen Parametern ist einfach, solange die Anwendung in der gezeigten Form erfolgt. Es können aber auch einige Parameter mit Standardwerten belegt werden und andere nicht.

function print_value($name, $ort = "Ort")

Der umgekehrte Fall führt allerdings zu einem Laufzeitfehler. Das folgende Beispiel funktioniert nur, wenn tatsächlich beide Parameter übergeben werden.

function print_value($name = "Name", $ort)

Der folgende Aufruf ist deshalb nicht möglich, denn woher soll PHP wissen, dass der zweite Parameter gemeint ist?

print_value("Berlin");

Optionale Parameter müssen also im Funktionskopf immer rechts stehen und von rechts her auflösbar sein.

Variable Argumentelisten

Die Anzahl der Argumente kann mit Hilfe von Arrayfunktionen bestimmt werden.

Das folgende Beispiel zeigt die Funktion "many_html", welche eine variable Anzahl von Elementen übernimmt und formatiert zurückgibt. Die Anzahl der Argumente kann leicht mit der Funktion "count" ermittelt werden. Für die Übergabe wird das Array mit der Funktion "array" aus Einzelwerten erzeugt; wieviele das sind, ist nun gleichgültig.

<?php function many_html($tag, $argv) { $argc = count($argv); for ($i = 0; $i < $argc; $i++) { $result .= "<" . $tag . ">" . $argv[$i] . "</" . $tag . "> "; } return $result; } $wert = array("Dies", "ist", "ein", "Test"); echo "Fett: " . many_html("b", $wert); echo "<br />\n"; echo "Kursiv: " . many_html("i", array("Dies", "ist", "ein", "Test")); echo "<br />\n"; ?>

Dies ist ein Test Dies ist ein Test

PHP kennt auch variable Argumentelisten, die bei internen Funktion verwendet werden. So ermittelt etwa die Funktion "max" den maximalen Wert einer beliebigen langen Liste von Argumenten. Eine Definition ist dabei nicht nötig - wie könnte man auch eine Anzahl von Argumenten nennen, die man nicht kennt. Es gibt deswegen besondere Funktionen, mit denen der Parameterblock untersucht werden kann.

Funktion	Beschreibung
func_num_args	Gibt die Anzahl der Parameter zurück.
func_get_arg	Ermittelt einen konkreten Parameter; die Auswahl erfolgt durch eine Nummer.
func_get_args	Gibt ein Array mit den Parametern zurück.

Das folgende Beispiel implementiert zwei Funktionen, die beliebig viele Parameter akzeptieren. Realisiert wird eine mathematische Funktion zur Berechnung der Summe und des Durchschnitts.

<?php ## Berechnung der Summe function sum($array) { ## Die Funktion "sum" wird mit einem Array versorgt, das zu einer ## Zeichenkette zusammengefasst wird; Trennzeichen ist das Pluszeichen. $string = join("+", $array); ## Der Befehl "eval" behandelt eine Zeichenkette als PHP-Code und ## führt ihn aus. ## Damit wird die Summe berechnet und der Variable "$sum" zugewiesen. eval("\$sum = $string;"); ## Die Variable "$sum" wird als Rückgabewert verwendet. return $sum; } ## Berechnung des Durchschnittswerts function average() { ## Die mit "sum" ermittelte Summe wird durch die von "func_num_args" ## ermittelteAnzahl der Werte geteilt return sum(func_get_args()) / func_num_args(); } echo average(13, 12, 7, 8, 23); ?>

12.6

Im vorigen Beispiel waren keine Parameterangaben im Kopf der Funktionsdeklaration notwendig. Werden dennoch Parameter angegeben, so werden diese Argumente dem Anfang der Liste zugewiesen. Unabhängig davon werden alle Werte von den Parameterfunktionen verwaltet.

<?php function num($first) { ## Aneinanderhängen des ersten und des vierten ("3") Parameters echo $first . func_get_arg(3); } num(2, 3, 4, 5); ?>

25

Rückgabe mehrerer Werte

Zwar ist die Rückgabe mehrerer Werte durch eine Funktion nicht vorgesehen. Da es aber sonst keine Beschränkung des Typs gibt - sowohl Arrays als auch Objekte sind erlaubt -, bietet sich neben der Übergabe von Variablen als Referenz mit vorangestelltem "&"-Zeichen folgendes Vorgehen zur Übergabe mehrerer Werte an.

Als Rückgabewert kann auch ein Array eingesetzt werden. Die Auflösung wird mit "list" vorgenommen. Dabei ist zu beachten, dass das Array numerische Indizes haben muss. Im Beispiel werden keine Indizes verwendet und deshalb erzeugt PHP intern welche - und zwar die benötigten numerischen.

Dieses Beispiel funktioniert nicht wie vorgesehen...

<?php function make_b(&$html) { $html = array("<b>", $html, "</b>"); } $html = "Test"; make_b($html); list($opentag, $html, $closetag) = $html; echo "Test formatiert: " . $opentag . $html . $closetag; ?>

Test formatiert: TTest

Rückgabe eines Funktionswertes

Allgemein wird das Schlüsselwort "return" eingesetzt, um die Funktion zur Rückgabe eines Wertes zu veranlassen. Nach "return" wird die Funktion verlassen, nachfolgender Code wird nicht ausgeführt. Normalerweise ist die Anweisung deshalb der letzte Befehl einer Funktion; andernfalls muss mit "if" oder "switch" gearbeitet werden.

Auch für die Rückgabe gibt es eine besondere Form: die Rückgabe per Referenz. Normalerweise werden die Daten als Wert zurückgegeben. Wenn eine Funktion eine sehr grosse Datenmenge erzeugt (z. B. ein array), kann es sinnvoll sein, statt der Kopie aller Daten nur einen Zeiger zu übertragen. PHP5 fertigt erst dann eine wirkliche Kopie an, wenn ein Schreibvorgang auf die Variablen stattfindet. Solange nur lesend zugegriffen wird ist das gleichgültig. Das Verfahren ist aber bis zu diesem Zeitpunkt schneller als die erzwungene Anfertigung einer Kopie beim Schreibzugriff.

Ein Einsatzfall ist der schreibende Zugriff auf Teile eines grösseren Datenfelds. Um etwa Arraywerte bequem zu verändern, kann der Zugriff über eine Referenz organisiert werden. Im folgenden Beispiel erfolgt die Deklaration an zwei Stellen. Zum einen wird dem Funktionsnamen das "&"-Zeichen vorangestellt. Zum anderen wird bei der Übergabe des Rückgabewertes eine Referenzzuweisung benutzt. Bestimmend ist dabei der Aufruf des Wertes. Hier wird dafür gesorgt, dass tatsächlich mit dem Original gearbeitet wird.

<?php $array = array("W1", "W2", "W3", "W4", "W5", "W6"); function &GetReference($index) { global $array; if ($index < count($array)) return $array[$index]; else return $array[0]; } echo "Index 3 ist vorher: {$array[3]}<br />\n"; ## Referenzzuweisung zur Übergabe des Rückgabewertes $element =& GetReference(3); $element = "X3"; echo "Index 3 ist nachher: {$array[3]}<br />"; ?>

Index 3 ist vorher: W4 Index 3 ist nachher: X3

Von der Verhaltensweise gibt es eine Ausnahme. Der Befehl "unset", der normalerweise Variablen löscht, entfernt die Referenz selbst und löscht nicht das Original.

unset($element);

Nach der Ausführung dieser Zeile im Rahmen des obigen Skripts ist die Variable "$element" und die Referenz auf das ausgewählte Arrayelement entfernt. Das Element im Array selbst (im Beispiel "$array[3]") bleibt dagegen erhalten. Um dieses zu löschen, muss ein direkter Aufruf erfolgen.

unset($array[3]);

Eine Funktion ruft sich selbst auf: Rekursion

PHP5 erlaubt rekursive Funktionsaufrufe, bei denen eine Funktion sich selber aufruft. Das wird etwa benötigt, um verschachtelte Strukturen auszugeben. Dabei kann es sich um Verzeichnisse oder Menüführungen handeln. Das folgende Beispiel stellt Arrays in Arrays dar und der Funktion ist es gleichgültig, wieviele Verschachtelungsebenen verwendet werden. Die Funktion ist zusätzlich mit der Anzeige der Verschachtelungstiefe durch Einrückung versehen. Das Array "$arrayCheck" dient nur der Demonstration. Damit die Einrückung bei jedem Aufruf der Funktion erhalten bleibt, wird die Variable "$shift", in der die Tiefe gespeichert wird, statisch gesetzt ("static").

<?php function array_show($array) { static $shift = 1; foreach($array as $key => $value) { ## Prüfung, ob der gelieferte Wert noch ein Array ist - das ## ist dann ein verschachteltes Array if (is_array($key)) { ## Im positiven Fall wird die Tiefe erhöht $shift++; ## Funktion ruft sich mit dem Teilarray selbst auf array_show($key); } else { ## Schlüssel werden in Fettschrift mit "--"-Zeichen dargestellt echo str_repeat("--&nbsp;", $shift); echo "<b>$key</b>"; echo "<br />\n"; } if (is_array($value)) { $shift++; array_show($value); } else { ## Werte werden in Normalschrift mit "=="-Zeichen dargestellt echo str_repeat("==&nbsp;", $shift) . $value; echo "<br />\n"; } } ## Verminderung der Tiefe $shift > 1 ? $shift-- : $shift = 1; } $arrayCheck = array("key1" => "value1", "key2" => "value2", array(1,2,3), "keyX" => array(33 => 66, 66 => 99), 4, array("M" => "m", "N" => "n", array("Z1", array("Z2" => "Z3"), "Z4"), ) ); echo "&lt;pre&gt;"; array_show($arrayCheck); echo "&lt;/pre&gt;"; ?>

-- key1 == value1 -- key2 == value2 -- 0 -- -- 0 == == 1 -- -- 1 == == 2 -- -- 2 == == 3 -- keyX -- -- 33 == == 66 -- -- 66 == == 99 -- 1 == 4 -- 2 -- -- M == == m -- -- N == == n -- -- 0 -- -- -- 0 == == == Z1 -- -- -- 1 -- -- -- -- Z2 == == == == Z3 -- -- -- 2 == == == Z4

Erweiterte Syntax

Bei einer anderen Form des Funktionsaufrufs kann die Funktion über eine Referenz aufgerufen werden, wobei der Inhalt einer Variablen den Funktionsnamen bestimmt.

<?php function firstfunction() { echo "Eine spannende Funktion...<br />\n"; return TRUE; } function secondfunction() { echo "Eine zweite spannende Funktion...<br />\n"; return TRUE; } $fname = "first"; $sname = "second"; $ftype = "function"; $dynfunction = $fname.$ftype; $ok = $dynfunction(); $secondfunction = $sname.$ftype; $ok = ${'secondfunction'}(); ?>

In vereinfachter Syntax sieht der Aufruf wie folgt aus.

$funktionsname = "myfunction"; $funktionsname(Parameter);

Das entspricht dem folgenden Aufruf.

myfunction(Parameter);

Solche Konstruktionen werden oft für sogenannte Wrapper verwendet. Das sind Programme, die einen universellen Funktionsaufruf einer von Bedingungen abhängigen Auswahl besonderer Funktionen zuweisen. Manche Prüfprogramme für Kreditkartennummern arbeiten damit. Nachdem eine Funktion den Typ der Karte erkannt hat, erfolgt eine Verzweigung auf einen der vielen möglichen Alogorithmen. Statt umfangreicher "switch"-Bäume bleibt es bei einem Aufruf mit variablem Namen.

Besondere Hilfsfunktionen zu Funktionen

Die Funktion "create_function" dient dazu, eine Funktion vollständig während der Laufzeit zu erstellen, etwa wenn erst nach einer bestimmten Benutzereingabe der Funktionskörper zusammengesetzt werden kann. Der erste Parameter nimmt dabei die Argumenteliste auf, der zweite liefert den gesamten Funktionskörper. Hier solltre also zum einen ein Rückgabewert bestimmt werden (dazu wird meist "return" genommen), zum andern muss die Syntax den Regeln von PHP entsprechen, was besonders bei Strichpunkten zu beachten ist.

<?php $a = 2; switch ($a) { case 1: $f = create_function ('$x', 'return $x * $x;'); break; case 2: $f = create_function ('$x, $y', 'return $x*$x+$y*$y;'); break; case 3: $f = create_function ('$x, $y, $z', 'return $x*$x+$y*$y+$z*$z;'); break; } $z1 = 3; $z2 = 7; $z3 = 11; switch ($a) { case 1: echo $f($z1); break; case 2: echo $f($z1, $z2); break; case 3: echo $f($z1, $z2, $z3); break; } ?>

58

Die Ausgabe ("58") ist bescheiden. Abhängig von der Anzahl der Parameter (hier: "$a = 2") wird die Funktion mit zwei Parametern erzeugt. Sie gibt die Summe der Quadrate der Argumente zurück. Der zweite "switch"-Block ruft dann die passende Funktion auf. Aus 3² + 7² wird dann 58.

Die Funktion "call_user_func" hilft weiter, wenn ein Funktionsaufruf parametrisiert werden muss. Diese Funktion ruft eine benutzerdefinierte Funktion auf, wobei die Parameter einzeln übergeben werden. "functionname" ist dabei der Name einer Funktion als Zeichenkette. Die Parameter werden wie üblich ausgegegeben.

mixed call_user_func(string <functionname> [, mixed <parameter> [, mixed ...]])

Die Funktion "call_user_func_array" ruft eine benutzerdefinierte Funktion auf, die Parameter werden als Arrays übergeben. "functionname" ist dabei der Name einer Funktion als Zeichenkette. Die Parameter werden in einem Array übergeben.

array call_user_func_array(string <functionname>, array <parameter>)

Ein Beispiel zeigt die Verwendung.

<?php function test($x1, $x2, $x3) { echo "<b>x1:</b> $x1, <b>x2:</b> $x2, <b>x3:</b> $x3"; } $function = "test"; $a = array("Wert 1", 2, "Die Drei"); call_user_func_array($function, $a); ?>

x1: Wert 1, x2: 2, x3: Die Drei

Tips zur Fehlersuche

Die Funktion "get_defined_functions" gibt ein Array mit den deklarierten Funktionsnamen zurück. Dies ist nützlich, wenn in Skripten der Überblick verloren gegangen ist oder fremde Skripte analysiert werden. Das folgende Skript zeigt die Anzahl der in der aktuellen Installation verfügbaren eingebauten Funktionen an. Die konkrete Zahl hängt von den eingebauten Modulen ab; in der Grundausstattung sind es knapp unter 1'000. Danach folgt eine Liste der benutzerdefinierten Funktionen. Das Array enthält zwei Elemente mit den Schlüsseln "internal" und "user". In jedem befindet sich ein indiziertes Array mit der Liste der Funktionsnamen.

<?php function MyFunction($a, $b) { echo "a enthält $a, b enthält $b<br />\n"; } $functions = get_defined_functions(); echo "<p>Dieses PHP 5.0 enthält " . count($functions['internal']) . " Funktionen.</p>\n"; print_r($functions['user']); ?>

Dieses PHP 5.0 enthält 1304 Funktionen. Array ( [0] => myfunction )

Schreiben kompatibler Skripte

Die Funktion "function_exists" bietet sich an, wenn untersucht werden soll, ob eine Funktion existiert. Wird Software geschrieben, die auch auf älteren PHP-Versionen laufen soll, so empfiehlt sich folgendes Vorgehen:

• Beschaffung oder Entwicklung von Funktionen, die neuere PHP-Funktionen nachbilden.
• Prüfung, ob in der vom Kunden eingesetzten Version die Funktion bereits existiert. Ist das der Fall, so wird die eingebaute, andernfalls die eigene Funktion genutzt.

Eingebaute Funktionen laufen natürlich schneller, Anwender älterer Versionen nehmen also Laufzeitnachteile in Kauf. Aber immerhin funktioniert das eigene Programm überhaupt, was von Vorteil sein kann.

Bei der Abfrage von Namen aus Bibliotheken muss beachtet werden, dass die Funktionen zwar in einigen Fällen existieren, aber nicht funktionieren. Das trifft etwa für die GD-Bibliothek (Erstellen von Grafiken) zu, wo die verschiedenen Bildausgabefunktionen für GIF, PNG oder JPEG immer vorhanden sind, auch wenn die Unterstützung für GIF nicht wirklich vorhanden ist. Eine Prüfung, ob GD überhaupt aktiviert wurde, sieht folgendermassen aus.

<?php if(function_exists("imagetypes")) echo "GD ist vorhanden"; else echo "GD ist nicht vorhanden"; ?>

GD ist nicht vorhanden

Überwachung des Verarbeitungszyklus

Die eher exotische Funktion "register_tick_function" wird im Zusammenhang mit der Sprachanweisung "declare" eingesetzt. Damit kann eine Funktion benannt werden, die bei jedem Programmschritt oder einem Vielfachen davon ausgeführt wird. Die Arbeitsweise basiert auf sogenannten Ticks; das sind die Zeitpunkte, zu denen eine Basisanweisung ausgeführt wird. Neben der Fehlersuche kann damit auch der Verlauf von Code überwacht werden. Beispielsweise lassen sich so längere Codeabschnitte dazu bringen, Informationen an den Benutzer auszugeben.

Das folgende Beispiel zeigt eine Anwendung, bei der ein künstlich langsam ablaufender Code über die Tickfunktion Zeichen an den Webbrowser sendet. Es enthält eine Besonderheit: ein Verwaltungsprogramm, das gleichzeitig den Code und die Ausgabe anzeigt. Dieses basiert auf der Manipulation des Ausgabepuffers. Um dessen Wirkung aufzuheben und ungepufferte Ausgaben zu senden, wurde die Funktion "ob_implicit_flush" verwendet. Das hat nichts mit den Ticks zu tun, sondern zeigt nur den Zusammenhang mit einer besonderen Umgebung.

<?php ## Funktion "SendDot", die mit jedem Tick aufgerufen werden soll function SendDot($init = FALSE) { if ($init) { echo "Beginn der Ausgabe "; } else { echo "."; } ob_end_flush(); } ## Um die auszugebenden Punkte sichtbar zu machen, wird der Puffer ## nach jeder Ausgabe geleert ob_implicit_flush (TRUE); SendDot(TRUE); ## Mit "register tick_function" wird mitgeteilt, dass die Funktion ## "SendDot" beim Auftreten von Ticks aufgerufen werden soll register_tick_function("SendDot"); $y = 0; ## Bestimmung des Codeabschnitts, für den dies gilt, sowie des ## Multiplikators. Hier wird jedes ("ticks=1") registriert. declare (ticks=1) { ## Die Schleife tut nichts sinnvolles, ausser Zeit zu verbrauchen for ($i = 0; $i < 10; $i++) { $y = sqrt($i * $i); sleep(1); } } echo "<br />\nFertig!"; ?>

Beginn der Ausgabe ................................ Fertig!