Funktionen

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.

Funktion mit Parametern

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.

Vorhandensein einer Funktion überprüfen
function_exists()

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

Funktion und Rückgabewert
return

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

Funktionstyp & Rückgabewert

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

Brutto, Netto, Mehrwertsteuer

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
function brutto($betrag,$MwSt){
$betrag=doubleval($betrag);
$MwSt=doubleval($MwSt);
if($betrag > 0 && $MwSt > 0){
return $betrag +($betrag*$MwSt/100);
}
else{
return false;
}
}
/* Hier beginnt der Aufruf der Funktion */
$wert=brutto(200,7);
if($wert==true){
echo $wert;
}
else{
echo "falsche Parametereingabe";
}
?>
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";
?>
   
So eine Brutto Funktion lässt sich gut in einem Shop einsetzen, auch eine Mehrwertsteuer Funktion kann man auf ähnliche Weise erstellen. Neben den Variablennamen muss nur noch die Berechnungs-Formel etwas abgeändert werden.
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);

?>

Übergabe als Wert
call by value

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

Übergabe als Referenz
call by reference

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

Funktionen & Variablen

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.

static Variable

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

global Variable

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.

lokale Variablen
Lokale Variablen werden innerhalb einer Funktion definiert und haben außerhalb der Funktion keine Gültigkeit.
globale Variablen
Globale Variablen werden außerhalb von Funktionen definiert. Eine Variable gleichen Namens innerhalb der Funktion ist eine andere Variable. Möchte man globale Variablen auch innerhalb einer Funktion nutzen, setzt man das Schlüsselwort global vor den Variablen namen global $x
superglobale Variablen
Superglobale Variablen sind PHP Systemvariablen, wie beispielsweise das assoziative Feld $POST_, welches die Werte auch Formularen zur Verfügung stellt.
statische Variablen
Der Wert von lokalen Variablen in einer Funktion, wird nach dem Funktionsaufruf gelöscht. Man kann jedoch mit dem Schlüsselwort static vor dem Variablenname eine statisch Variable erzeugen, deren Wert nachd em Funktionsaufruf nicht gelöscht wird. Stattdessen behält sie ihren Wert für einen neuen Funktionsaufruf.

Variable Funktion

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
$Var ="test";
$Var();
?>
Halli Hallo <?php
function saghallo(){
echo "Halli Hallo";
}
$Var ="saghallo";
$Var();
?>
Hollderahihi <?php
function sag($Was){
echo $Was;
}
$Var ="sag";
$Var("Hollderahihi");
?>

Argumentübergabe
weitere Techniken

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.

Arrays als Argumente

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

}
$Daten = array("Walter", "Anton", "Hubert");
arrayargument($Daten);
?>
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);
?>

Unterschiedliche Anzahl von Argumenten

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
function nocheintest (){
echo "schon wieder Hallo";
}
nocheintest(123, "Guten Tag")
?>

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
function testumtest (){
$Argumente = func_get_args();
foreach ($Argumente as $Element){
echo $Element, "<br>";
}
}
testumtest(123, "Guten Tag")
?>
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>";;
}

}
testtest("Tritra", "Trulala", "der Kasperle sagt", "Guten Tag")
?>

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.

Default Argumente
Argumente mit vorbelegten Werten

Hier werden die Argumente einer Funktion mit Werten vorbelegt. Beachte die folgenden Funktionsaufrufe. Werden beim Funktionsaufruf Argumente übergeben, werden die Werte überschrieben.

<?php
function testo ($Wert1=123, $Wert2=570, $Wert3=468){
echo $Wert1,"<br>";
echo $Wert2,"<br>";
echo $Wert3;
}
?>
123
570
468 		<?php
testo();
?>
780
570
468 		<?php
testo(780);
?>
Guten Tag
666
du Nase 		<?php
testo("Guten Tag", 666, "du Nase");
?>

Array als Rückgabewert
mehrere Werte mittels return zurückgeben

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
function testreturn (){
$Daten[] = 123;
$Daten[] = 456;
$Daten[] = 789;
return $Daten;
}

$Werte = testreturn();

foreach ($Werte as $Element){
echo $Element, "<br>";
}
?>

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
function testreturn2 (){
$Daten[0] = 123;
$Daten[1] = 456;
return $Daten;
}

$Werte = testreturn2();

echo $Werte[0];
echo $Werte[1];
?>

 

 

Webdesign / PHP / mySQL / Dreamweaver MX Tipps
Copyright © Michael Albers
www.pastorpixel.de