php mit Adi Prinz

Funktionsreferenz

Eine Liste der PHP Funktionen finden sie hier:

php.net

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:

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.

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();
?>

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);
?>

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

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

<?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>";
?>

<?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);
?>

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();
?>

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;
?>