Funktionen in PHP

Funktionen dienen dem Zusammenfassen mehrerer Befehle zu einem Aufruf. Dadurch werden Programme lesbarer, weil klar ist, wozu ein Befehlsblock dient. PHP kennt mehr als Tausend eingebaute Funktionen, jede Erweiterung (Extension) von PHP bringt noch weitere Funktionen mit. Viele Funktionen wie z.B. die String- und Variablen-Funktionen sind bereits in jeder PHP-Version enthalten. Für die Scripte meiner Webseiten sollte auf jeden Fall die GD-Extension und MySQLi installiert sein. Wenn sie, so wie ich, eine aktuelle Version von XAMPP installiert haben, soll das kein Problem sein. Geben sie den folgenden PHP-Code auf einer Seite ein, und schauen sie sich die Konfiguration ihrer PHP-Installation an.

<?php
phpinfo();
?>

Funktionsreferenz

Eine Liste der PHP Funktionen finden sie hier:

php.net

Eigene Funktionen

Wie jede Programmiersprache bietet auch PHP die Möglichkeit, eigene Funktion zu erstellen. Diee Syntax Lautet:

function functionName() {
code to be executed;
}

Die Funktion beginnt immer mit dem Schlüsselwert function , gefolgt von einem benutzerdefinierten Namen und dem Parameter (). Der Funktionsblock wird in geschweiften Klammern eingeschlossen. Für Funktionsnamen gelten in PHP die gleichen Regeln wie für andere Bezeichner. Ein gültiger Funktionsname beginnt mit einem Buchstaben oder Unterstrich gefolgt von einer beliebigen Anzahl von Buchstaben, Ziffern und Unterstrichen. Der Funktionsaufruf wird mit Funktionsnamen und Parametern geschrieben.

<?php
function foo() {
print "Hallo Welt!";
}
foo();
?>

Rückgabe mit return

Der Befehl return enthält als Parameter den Rückgabewert. Dies kann ein Ausdruck oder eine einzelne Variable sein. An welcher Stelle innerhalb der Funktion Sie return einsetzen, spielt keine Rolle. Auch die mehrfache Notation ist zulässig – hier wird nach dem Motto "Wer zuerst kommt, malt zu erst" verfahren und die Funktion wird sofort verlassen. Aus Gründen sauberer Programmierung sollten Sie jedoch return nur einmal an Ende einer Funktion einsetzen.

<?php
function foo() {
$a = 5 * 5;
return $a;
}
print foo();
?>

Rückgabewerte

Der optionale Befehl return liefert Werte zurück. Es können Variablen jeden Typs zurückgegeben werden, auch Listen oder Objekte. Der Befehl return beendet sofort die Funktion, und die Kontrolle wird wieder an die aufrufende Zeile zurückgegeben.

Rückgabe mehrerer Werte

Eine PHP-Funktion kann immer nur einen Wert zurückgeben. Mit der list-Funktion kann jedoch ein einzelner Wert aus einem Array ermittelt werden.

<?php
function myFunc() {
return array(10, 20, 30);
}
list ($eins, $zwei, $drei) = myFunc();
print $zwei;
?>

Eine komplexe Funktion sollte nicht nur den üblichen Rückgabewert erzeugen, sondern bei Bedarf auch noch einen Fehlercode. Dieser Fehlercode wird ebenfalls in einer return-Anweisung definiert. Kann die Funktion die erwartete Operation nicht ausführen, soll sie stattdessen den Fehlercode liefern. Der Entwickler ist dann in der Lage, den Rückgabewert in einer if-Abfrage auszuwerten und für die Programmsteuerung zu nutzen. Das folgende Beispiel erfüllt diese Anforderung:

<?php
function bruttoberechnen($betrag, $mwst) {
if ($betrag > 0 && $mwst > 0) {
return $betrag + ($betrag * $mwst / 100);
} else {
return -1;
}}

$res = bruttoberechnen (100, 0); // -1

if ($res > -1) {
echo $res;
} else {
echo "Falsche Argumente!";
}
?>

Späte Bindung in PHP

In PHP kann eine Funktion an jeder beliebigen Stelle des Skripts definiert werden. Der PHP-Interpreter verarbeitet als Erstes sämtliche Funktionsdefinitionen und anschließend die anderen Bestandteile des Skripts.

<?php
print foo();

function foo() {
$a = 5 * 5;
return $a;
}
?>

Prüfen der Funktions-Existenz

Mit der Funktion function_exists() kann man überprüfen, ob eine Funktion vorhanden ist. Wenn die Funktion existiert, gibt function_exists() true, sonst false zurück.

<?php
function foo() {
$a = 5 * 5;
return $a;
}

if ( function_exists('foo')) {
print "Funktion existiert!";
} else {
print "Funktion existiert nicht!";
}
?>

Verschachtelte Funktionen

Funktionen in PHP können auch verschachtelt werden. Dabei ist zu beachten, dass die innere Funktion (child-Function) erst bekannt ist, wenn die äußere Funktion ( parent-Function) einmal aufgerufen wurde.

<?php
function foo() {
  function baz() {
  print "Hallo Welt!";
  }
}

foo();
echo baz();
?>

Funktionsargumente

Die Übergabe von Argumenten an die Funktion, die dann dort Parametern entsprechen, kann auf unterschiedliche Art und Weise erfolgen. Im einfachsten Fall geben Sie Variablennamen an. Der Aufruf der Funktion kann dann erfolgen, indem Werte eingesetzt werden.

<?php
function myName($firstName, $lastName) {
print "Mein Name ist " . $firstName . " " . $lastName;
}

myName("Adi", "Prinz");
?>

Variablen Scope

Variablen in PHP können global, local oder static sein. Variablen innerhalb einer Funktion sind local und somit von Aussen nicht Sichtbar. Die Variablennamen können also gleich sein, da Variablen innerhalb einer Funktion lokal sind und nicht im Konflikt mit den globalen Variablen stehen.

$firstName = "Adi";
$lastName = "Prinz";

function myName($firstName, $lastName) {
print "Mein Name ist " . $firstName . " " . $lastName;
}

myName($firstName, $lastName);
?>

Static Variablen

Nachdem eine Funktion ausgeführt wurde, werden alle lokalen Variablen der Funktion wieder gelöscht. Manchmal möchte man eine lokale Variable nicht gelöscht haben, sonder ihr Wert soll für spätere Verwendung gespeichert werden. Um zu erreichen, dass ein Variablenwert innerhalb einer Funktion gespeichert wird, muss diese explizit mithilfe des Schlüsselworts static bekannt gemacht werden.

<?php
function myFunc() {
static $x = 0;
print $x . "<br>";
$x++;
}

myFunc();
myFunc();
myFunc();
?>

Zuweisung by reference

Etwas ähnliches erreicht man, wenn die Parametervariable eine Wertezuweisung "by reference" erhält. Im Beispiel bekommt die Variable $wert einen Zeiger auf die globale Variable $x, die veränderbar ist.

<?php
function myFunc(&$wert) {
$wert *= 2;
print "neuer Wert: " .  $wert . "<br>";
}

$x = 15;
myFunc($x);
myFunc($x);
myFunc($x);
?>

Standardwert für Argumente

Wenn Argumente nicht definiert sind können PHP-Funktionen auch Vorgabewerte als Standard speichern. Der Vorgabewert muss ein konstanter Ausdruck sein, darf also keine Variable oder ein Element einer Klasse sein. Bitte beachten Sie, dass alle Vorgabewerte rechts von den Nicht-Vorgabeparametern stehen müssen – sonst wird es nicht funktionieren.

<?php
function myName ($firstName, $lastName = "Prinz") {
$fullName = $firstName . " " . $lastName;
print "Mein Name ist " .  $fullName;
}

myName("Adi");
print  "<br>";
myName("Adi", "Müller");
?>

Arrays als Argumente

Argumente können auch Arrays sein. Die Anzahl der Array-Elemente kann mit der Funktion count ermittelt werden. Eine for-Schleife findet Array-Werte, wie viele dies sind, spielt nun keine Rolle mehr.

<?php
$personen = array("Julia","Adi","Gabi");

function formatieren($tag,$argumente) {
$res = "";
$anzahlargs = count($argumente);
for ($i = 0; $i < $anzahlargs; $i++) {
$res .= "<".$tag.">".$argumente[$i]."</".$tag.">";
}
return $res;
}

echo formatieren("i",$personen) . "<br>";
echo formatieren("b",$personen) . "<br>";
?>

Variable Argumentliste

In PHP sind auch variable Argumentlisten zulässig. Das trifft zu, wenn Parameter vorher nicht bekannt sind. Folgende, interne Funktionen kommen dabei zum Einsatz;

  • func_num_args – Diese Funktion gibt die Anzahl der Parameter zurück.
  • func_get_arg – Hiermit ermitteln Sie einen konkreten Parameter, die Auswahl erfolgt durch eine Nummer.
  • func_get_args – Diese Funktion gibt ein Array mit den Parametern zurück.
<?php
function myNumargs() {
$anzahlargs = func_num_args();
print "Anzahl der Argumente: $anzahlargs";
}
myNumargs(10, 20, 30);
print "<br>";

function myGetarg() {
$anzahlargs = func_num_args();
print "Anzahl der Argumente: " . $anzahlargs . "<br>";;
if ($anzahlargs >= 2) {
print "Das 2. Argument ist: " . func_get_arg (1);
}
}
myGetarg(10, 20, 30, 40, 50);
print "<br>";

function myGetargS() {
$anzahlargs = func_num_args();
$arg_liste = func_get_args();
for ($i = 0; $i < $anzahlargs; $i++) {
print "Argument $i ist: " . $arg_liste[$i] . "<br>";;
}
}
myGetargS(10, 20, 30, 40, 50);
?>

Weitere Funktionsdeklarationen

Funktionen sind ein mächtiges Werkzeug in PHP. Über das Thema Funktionen werden ganze Bücher geschrieben, am besten lernt man den Umgang mit Funktionen an praktischen Beispielen. Ein paar Möglichkeiten der Funktionsdeklarationen habe ich hier noch parat.

Dynamische Funktionen erzeugen

Sie möchten eine Funktion anlegen und definieren, während das Skript vom PHP-Interpreter abgearbeitet wird. Hierfür stellt Ihnen PHP die Funktion create_function() zur Verfügung.

<?php
$add = create_function('$a,$b', 'return $a+$b;');
print $add(20,5);
?>

Der erste Parameter für create_function() ist ein String, welcher die Argumente der Funktion enthält, und der zweite ist der Anweisungsblock. Die Verwendung von create_function() ist außerordentlich langsam. Sie sollten daher eine Funktion vorab definieren und nur in Ausnahmefällen auf create_function() zurückgreifen.

Bedingte Funktionen

Wenn eine Funktion nur unter bestimmten Bedingungen definiert wird, muss die Definition dieser Funktion noch vor deren Aufruf abgearbeitet werden.

<?php
$signal = true;

if ($signal) {
function myFunc()
{
echo "Ich existiere!";
}}

myFunc();
?>

Verschachtelte Funktionen

Im folgenden Beispiel wird eine Funktion myFamily() definiert. Sie enthält zwei weitere Funktionen myName() und myWifeName(). Beide child-Funktionen werden noch in der parent-Funktion aufgerufen.

<?php
function myFamily() {
function myName() {
echo "Adi Prinz<br>";
}
function myWifeName() {
echo "Gabi Prinz";
}
myName();
myWifeName();
}

myFamily();
?>

Variablenfunktionen

PHP unterstützt das Konzept der Variablenfunktionen. Wenn Sie an das Ende einer Variablen Klammern hängen, versucht PHP eine Funktion aufzurufen, deren Name der aktuelle Wert der Variablen ist.

<?php
function foo()
{
echo "Hallo Welt!";
}

function bar($arg)
{
echo $arg;
}

$func = 'foo';
$func();        // Dies ruft foo() auf
print "<br>";
$func = 'bar';
$func('Hallo Adi!');  // Dies ruft bar() auf
?>

Rekursive Funktionen

Dies ist eine Funktion, die sich selbst aufruft. Hierbei besteht die Gefahr, sogenannte Endlosschleifen bzw. Endlosrekursionen zu programmieren, welche die Performance des jeweiligen Systems äußerst negativ beeinflussen. Sie müssen also einen Weg vorsehen, diese Rekursion zu beenden. Die folgende Funktion setzeZaehler() zählt rekursiv bis 10. Die statische Variable $zaehler wird benutzt, um die Rekursion zu beenden.

<?php
function setzeZaehler() {
static $zaehler = 0;

$zaehler++;
echo $zaehler;
if ($zaehler < 10) {
setzeZaehler();
}
}
setzeZaehler();
?>

PASSING BY

Bei der Wertzuweisung von Variablen unterscheidet PHP zwischen:

<?php
$a = "Hallo Welt!";
$b = $a;
?>

In diesem Beispiel wurde der Variablen $b der Wert von $a zugewiesen. Es existieren nun zwei Variablen, die aktuell den selben Wert haben, aber beide Variablen sind voneinader unabhängig und können jederzeit verändert werden.

<?php
$a = "Hallo Welt!";
$b = $a;
$a = "Irgendwas";
echo $b;
?>

Diese Art der Zuweisung wird auch als pass by value bezeichnet, das ist auch Standard in PHP. Anders verhalten sich Variablenzuweisungen by reference, wie das folgende Beispiel zeigt. Dabei wird der Variablen $b der Wert von $a zugewiesen und der Variablen $a wird ein &-Zeichen vorangestellt.

<?php
$a = "Hallo Welt!";
$b = &$a;
$a = "Irgendwas";
echo $b;
?>

Es existieren jetzt ebenfalls zwei Variablen, aber beide Variablen zeigen auf denselben Speicher. Bei der Änderung einer der beiden Variablen wird der Wert des Speichers geändert. Da beide Variablen auf denselben Speicher zugreifen, wird der Wert beider Variablen geändert. Das nennt man pass by reference.

Funktionsparameter by reference

Eine weitere Einsatzmöglichkeit von Referenzen ist die Übergabe von Parametern an eine Funktion mit pass-by-reference. Hierbei beziehen sich der lokale Variablenname und der Variablenname der aufrufenden Instanz auf denselben Variableninhalt.

<?php
function ausgabe(&$var) {
  return ++$var;
}

$zahl=5;
echo ausgabe($zahl);
echo "<br>";
echo $zahl;
?>