Funktionen braucht man, um Unterprogramme zu definieren, die immer wieder aufgerufen werden können. Vorteile sind eine kürzere und übersichtlichere Programmiersprache. Funktionen können einen oder mehrere Parameter haben.
function funktionsname()
{
Anweisungen;
Anweisungen;
}
Aufruf der Funktion
funktionsname()
Eine Funktion beginnt
mit dem Schlüsselwort function
gefolgt von einem selbstvergebenen Namen. Hier gelten die gleichen Regeln wie bei Variablennamen, nur dass Funktionsnamen kein Dollarzeichen am Anfang haben.
Es folgt ein Anweisungsblock in geschweiften Klammern, in welchen, eingeschlossen, verschiedenen Anweisungen aufgeführt werden können. Die Anweisungen stehen jeweils in einer Zeile und werden mit Strichpunkt getrennt.
Wenn man die Funktion aufruft, werden die Anweisungen ausgeführt. Der Aufruf der Funktion erfolgt über den Funktionsnamen und der Klammer.
In den Klammern nach dem Funktionsnamen kann man eine
beliebige Anzahl von Parametern mit Kommata getrennt einfügen
(dazu später mehr).
Die Parameter einer Funktion sind Variablen, die innerhalb der Funktion genutzt werden. Das heisst
hier werden beim Aufruf der Funktion Werte zugewiesen, die dann in der Funktion verarbeitet werden.
Ausserhalb der Funktion haben diese Variablen normalerweise
keine Gültigkeit. Die Werte, die man den Parametern zuweist nennt man Argumente. Die beiden Begriffe werden häufig verwechselt.
hallo | <?php function test($wert){ echo $wert; } test ("hallo"); ?> |
Im obigen Beispiel wird zuerst eine Funktion mit dem Namen test mit einem Parameter $wert definiert. Anschliessend
wird diese Funktion aufgerufen test("hallo");
Hier bekommt der Parameter einen Wert zugewiesen, welcher dann in der Anweisung
der Funktion verarbeitet wird echo $wert;
Den zugewiesenen Wert nennt man Argument. Das Argument ist der Wert des Parameters.
Wenn man mehrere Parameter mit Komma getrennt setzt, muss man die Argumente in gleicher Reihenfolge mit Komma getrennt einfügen.
Mittels function_exists() kann man vor Aufruf einer Funktion überprüfen, ob die Funktion überhaupt vorhanden ist. Es wird der Wert true zurückgegeben.
Yippi | <?php if (function_exists("test")){ test("Yippi"); } ?> |
Eine Funktion kann einen Rückgabewert liefern, den man in Ausdrücken
verwenden kann oder den man einer Variablen zuweisen kann. Dazu verwendet man das Schlüsselwort return
.Funktionen, die keinen Rückgabewert liefern nennt man Prozeduren.
Hallo | <?php function test1 (){ return "Hallo"; } echo test1(); ?> |
selber Hallo | <?php function test2 ($wert){ return $wert; } echo test2("selber Hallo"); ?> |
HALLO | <?php echo strtoupper(test1()); ?> |
Eine Funktion kann wie ein Operand z.B. eine Variable in Ausdrücken verwendet
werden. Der Datentyp wird vom Rückgabewert bestimmt.z.B.
return 123, wäre der Typ Integer.
Man kann mehrere return Anweisungen in einer Funktion unterbringen, die auch
unterschiedliche Typen haben können.
Sobald eine return Anweisung erreicht wird, wird die Funktion beendet. Im folgenden
Beispiel wird je nach Parameterwert eine der beiden return Anweisungen ausgeführt.(
if else)
20 | <?php function zahltest($wert){ if($wert<20){ return $wert; } else{ return 20; } } echo zahltest(50); ?> |
Eine weitere Möglichkeit eine Funktion anzulegen, ist neben dem Rückgabewert noch einen Fehlercode zu definieren. Das In einer if-Struktur wird bei falschen Parametereingaben ein anderer Rückgabewert zugewiesen. In einer zweiten if-Struktur beim Aufruf der Funktion, wird der Rückgabewert überrprüft und beim Fehler-Rückgabewert ein entsprechender Hinweistext ausgegeben. Im zweiten Beispiel wurde auf diese Überprüfung verzichtet.
214 | <?php |
Der Gesamtpreis inkl. 16% MwSt ist: 626.4 EUR | <?php $netto=54; $anzahl = 10; echo " Der Gesamtpreis inkl. 16% MwSt ist: "; echo brutto(54,16)*$anzahl; echo " EUR"; ?> |
Mehrwertsteuer: 240 | <?php function MwSt($netto,$MwSt){ $netto=doubleval($netto); $MwSt=doubleval($MwSt); if($netto>0 and $MwSt>0){ return $netto*$MwSt/100; } else{ return false; } } /* Hier beginnt der Aufruf der Funktion */ echo "Mehrwertsteuer: ",MwSt(1500,16); ?> |
Das interessante an folgendem Beispiel, ist die Tatsache, dass die Variable $wert beim Aufruf mittels echo ihren ursprünglichen Wert beibehalten hat. Wenn man Javascript kennt ist das nicht weiter verwunderlich. Wenn man eine Variable irgendwo zuweist, wird nicht ein Verweis auf die Variable übergeben, sondern lediglich der Wert zugewiesen. Siehe das nächste Thema call by reference
3 5 |
<?php $wert =5; function callV($xyz){ $xyz=3; return $xyz; } echo callV($wert);//3 echo "<br>"; echo $wert;//5 ?> |
Will man eine Referenz auf die Variable setzen, so dass die außerhalb gelegene, formale Variable auf die gleiche Speicheradresse, wie die funktionsinterne Variable verweist, so muss man ein & vor den Variablennamen setzen. Die Änderung der Variable $xyz wirkt sich nun auf die Variable $wert ausserhalb der Funktion aus. Das nennt man auch call by reference, jedoch ist diese Vorgehensweise eher die Ausnahme. Das hat eigentlich nichts mit Funktionen zu tun, sondern man kann generell eine Referenz auf eine Variable setzen.
3 3 |
<?php $wert =5; function callR(&$xyz){ $xyz=3; return $xyz; } echo callR($wert); echo "<br>"; echo $wert; ?> |
Argumente, Parameter oder Variablen innerhalb der Funktion haben ausserhalb keine Gültigkeit und werden nach Abarbeitung der Funktion gelöscht. Jedoch können in Funktionen auch globale Variablen benutzt werden. Ausserdem kann man verhindern, dass eine Variable nach Beendigung der Funktion gelöscht wird.
Eine static
Variable wird, nachdem die Funktion abgearbeitet ist, nicht gelöscht.
Im Gegensatz zur globalen Variablen kann man sie ausserhalb zwar nicht aufrufen,
jedoch bleibt ihr Wert für einen erneuten Funktionsaufruf erhalten. Wäre es keine static Variable wäre ihr Wert bei jedem Funktionsauf 1 und würde sich nicht erhöhen.
++$Var siehe increment
1 2 3 |
<?php function zaehler() { static $Var; return ++$Var; } echo zaehler(); echo "<br>"; echo zaehler(); echo "<br>"; echo zaehler(); ?> |
Hat man eine Variable innerhalb der Funktion, die den gleichen Namen hat, wie
eine Variable ausserhalb der Funktion, so hat man 2 Variablen die nichts miteinander zu tun haben. Das wurde
schon in den Erklärungen oben unter Call by value deutlich.
Es gibt jedoch die Möglichkeit die Variable innerhalb der Funktion als global
zu deklarieren, so dass man sie im gesamten Script aufrufen kann. Dazu setzt man das Schüsselwort global
davor.
6 4 |
<?php $werta=4; function testa() { $werta=6; return $werta; } echo testa(); echo "<br>"; echo $werta; ?> |
6 6 |
<?php $wertb=4; function testb() { global $wertb; $wertb=6; return $wertb; } echo testb(); echo "<br>"; echo $wertb; ?> |
Vergleiche die beiden Funktionen. In der ersten haben wir 2 Variablen gleichen Namens, innerhalb und ausserhalb der Funktion: $werta. Im letzten Beispiel wird die Variable innerhalb der Funktion in eine globale Variable umgewandelt, so dass wir nur eine Varible namens $wertb haben, die innerhalb der Funktion geändert werden kann.
global $x
In PHP wird das Konzept der variablen Funktionen unterstützt. Wenn man eine Variable mit Funktionsklammern aufruft, versucht PHP ein Funktion zu starten,wobei der Wert der Variablen als Funktionsname interpretiert wird. Wie man am dritten Beispiel sieht, kann man sogar Argumente übergeben. Der Vorteil dieser Konstruktion liegt darin, dass man Funktionsnamen in Variablen speichern kann.
<?php |
|
Halli Hallo | <?php function saghallo(){ echo "Halli Hallo"; } $Var ="saghallo"; $Var(); ?> |
Hollderahihi | <?php function sag($Was){ echo $Was; } $Var ="sag"; $Var("Hollderahihi"); ?> |
Manchmal ist es sinnvoll, dass die Anzahl der Argumente einer Funktion variabel ist. Dazu gibt es 2 Möglichkeiten erstens: Arrays und zweitens: die explizite Zulassung von unterschiedlich vielen Argumenten.
Im folgenden Beispiel sieht man, dass beim Aufruf der Funktion das Array $Daten wie eine Variable (ohne eckige Klammern) übergeben wird. Die erste Funktion hat noch einen Schönheitsfehler, da nur 3 Elemente des Arrays angezeigt werden. Im zweiten Beispiel wird das Problem durch die foreach Schleife gelöst. In der Funktion kann man alle Techniken der Arrayverabeitung nutzen. Auch assoziative Arrays sind als Argumente möglich.
Walter Anton Hubert |
<?php function arrayargument ($Werte){ echo $Werte[0], "<br>"; echo $Werte[1], "<br>"; echo $Werte[2]; } |
Birgit Sandra Claudia Manuela Christel |
<?php function arrayargumente ($Werte){ foreach ($Werte as $Element){ echo $Element, "<br>"; } } $Daten = array("Birgit", "Sandra", "Claudia", "Manuela", "Christel"); arrayargumente($Daten); ?> |
Ab PHP4 kann man auch eine variable Anzahl von Argumenten übergeben. Dazu wird die Funktion ohne Argument definiert. Wie man im ersten Beispiel sieht, wird die Funktion ausgeführt, aber die vergebenen Argumente werden beim Funktionsaufruf einfach ignoriert.
schon wieder Hallo | <?php |
Damit diese Argumente übergeben werden, muss man spezielle Funktionen innerhalb der Funktion benutzen.
Funktion | Bedeutung |
func_num_args() | ermittelt die Anzahl der übergebenen Argumente |
func_get_arg() | Wert eines bestimmten Arguments wird gliefert, Indexwert wird als Parameter benötigt |
func_get_args() | Lieferung eins Arrays mit den übergebenen Argumenten |
Im folgenden Beispiel werden die Argumente mittels func_get_args ausgewertet und mittels foreach Schleife ausgegeben.
123 Guten Tag |
<?php |
Tritra Trulala der Kasperle sagt Guten Tag |
<?php function testtest (){ $Anzahl = func_num_args(); for ($n=0; $n<$Anzahl; $n++){ echo func_get_arg($n), "<br>";; } } |
Im vorigen Beispiel wird der Variablen $Anzahl die Anzahl der Argumente übergeben, welche dann in der for-Schleife die Anzahl der Schleifendurchläufe bestimmt. Die Funktion func_get_arg() benötigt als Parameter den jeweiligen Indexwert des gewünschten Arguments, beginnend bei 0 für das erste Argument.
Hier werden die Argumente einer Funktion mit Werten vorbelegt. Beachte die folgenden Funktionsaufrufe. Werden beim Funktionsaufruf Argumente übergeben, werden die Werte überschrieben.
<?php |
|
123 570 468 |
<?php testo(); ?> |
780 570 468 |
<?php testo(780); ?> |
Guten Tag 666 du Nase |
<?php testo("Guten Tag", 666, "du Nase"); ?> |
Eine Funktion kann mittels return nur einen Wert zurückgeben. Da es sich hierbei aber auch um ein Array handeln kann, umgeht man diese Beschränkung der Rückgabewerte.
123 456 789 |
<?php |
Beim Funktionsaufruf wird die Funktion einer Variablen als Wert zugewiesen.
$Werte = testreturn();
Dadurch wird die Variable zu einem Array, deren Werte hier in einer foreach Schleife ausgegeben werden.
Im folgenden wird auf eine foreach Schleife verzichtet.
123456 | <?php $Werte = testreturn2(); echo $Werte[0]; |
Webdesign / PHP / mySQL / Dreamweaver MX Tipps
Copyright © Michael Albers
www.pastorpixel.de