Funktionen

Funktionen braucht man, um Unterprogramme zu definieren, die immer wieder aufgerufen werden können. Der Vorteil ist eine kürzere und übersichtilichere Programmiersprache.
function functionsname(Argumente) {
Anweisungen;
Anweisungen;
}
Eine Funktion beginnt mit dem Schlüsselwort function gefolt von einem selbstvergebenen Namen. In den folgenden Klammern kann man eine beliebige Anzahl von Argumenten oder Paramentern mit Kommata getrennt einfügen (dazu später mehr). Es folgen geschweifte Klammern, in welchen, eingeschlossen, verschiedenen Anweisungen aufgeführt werden können. Die Anweisungen stehen jeweils in einer Zeile und werden mit Strichpunkt getrennt.
Die Argumente oder Parameter einer Funktion sind aktuelle Variablen. Das heisst hier werden beim Aufruf der Funktion Werte zugewiesen, die dann verarbeitet werden. Ausserhalb der Funktion haben diese Variablen normalerweise keine Gültigkeit

hallo <?php
function test($wert){
echo $wert;
}
test ("hallo");
?>

Im obigen Beispiel wird zuerst eine Funktion mit Parameter definiert. Anschliessend wird diese Funktion aufgerufen funktionsname(Argument); Hier bekommt das Argument einen Wert zugewiesen, welcher dann in der Anweisung der Funktion verarbeitet wird echo $wert;

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 richtige Funnktion braucht noch einen Rückgabewert, den man in Ausdrücken verwenden 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 zwar mehrere return Anweisungen in einer Funktion unterbringen, die auch unterschiedliche Typen haben können, aber davon sollte man Abstand nehmen. 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 and $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 zweiten Aufruf mittels echo ihren ursprünglichen Wert beibehalten hat. In vielen anderen Programmiersprachen, hätte $wert den Wert der Variablen $argument übernommen. In PHP jedoch nicht, da aktuelle und formale Variablen unabhängig sind, selbst wenn sie gleiche Namen haben, also selbst wenn in diesem Beispiel die Variable $argument auch $wert heissen würde.
Man nennt das auch Call by value, das heisst die Funktion soll nur über ihren Rückgabewert auf den Programm Code wirken. Alle funktionsinternen Anweisungen wirken nur innerhalb der Funktion. So treten keine Seiteneffekte auf, das heisst, Variablen ausserhalb der Funktion, gleichen Namens werden nicht unbeabsichtigt verändert.

3
5 		<?php
$wert =5;
function test6($argmuent){
$argument=3;
return $argument;
}
echo test6($wert);
echo "<br>";
echo $wert;
?>

Übergabe als Referenz
call by reference

Will man jedoch, dass die Aufrufvariable in der Funktion verändert wird, so dass die ausserhalb gelegene, formale Variable auf die gleiche Speicheradresse, wie die funktionsinterne Variable verweist, so muss man ein & vor das Argument der Funktion setzen. Die Änderung der Variable $parameter 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.

3
3 		<?php
$wert =5;
function test7(&$parameter){
$parameter=3;
return $parameter;
}
echo test7($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.
(++$Var siehe Variable)

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

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.

Datumsfunktionen

Es gibt zwar eine Menge Datumsfunktionen in PHP, doch kann man damit nicht alle anfallenden Probleme lösen. Deswegen gibt es hier einige benutzerdefinierten Funktionen für die Verarbeitung von Datumswerten

Datumsdifferenz berechnen

Die folgende Funktion dient dazu aus 2 Datumswerten, die beispielsweise aus Formulareingaben stammen könnten, die Datumsdifferenz in Tagen auszurechnen. Es sind 2 Schreibweisen möglich
"01.02.05" oder "01.02.2005" Statt der Punkte könnten auch andere Trennzeichen wie beispielsweise Kommata verwendet werden.

function DatumsDiff($Start,$Ende) {
$Tag1=(int) substr($Start, 0,2);
$Monat1=(int) substr($Start, 3, 2);
$Jahr1=(int) substr($Start, 6, 4);
$Tag2=(int) substr($Ende, 0, 2);
$Monat2=(int) substr($Ende, 3, 2);
$Jahr2=(int) substr($Ende, 6, 4);

if (checkdate($Monat1, $Tag1, $Jahr1)and checkdate($Monat2, $Tag2, $Jahr2))
{
$Datum1=mktime(0,0,0,$Monat1, $Tag1, $Jahr1);
$Datum2=mktime(0,0,0,$Monat2, $Tag2, $Jahr2);

$Diff=(Integer) (($Datum1-$Datum2)/3600/24);
return $Diff;
}
else{
return -1;
}
}
204 <?php
echo DatumsDiff("02.05.05", "10.10.04");
?>

Zu Beginn der Funktion werden die beiden Argumente $Start und $Ende mittels substr() in ihre Bestandteile zerlegt. Der Wert wird als Ganzzahl (int) ausgegeben.
In der folgenden if Struktur wird daraus wieder ein Datum erzeugt und mittels checkdate() überprüft, ob es sich um sinnvolle Datumseingaben handelt. Ist das nicht der Fall tritt else in Kraft und der Wert -1 wird ausgegeben.
Mit mktime wird von jedem Datum jeweils ein Zeitstempel erzeugt und in den Variablen $Datum1 und $Datum2 abgelegt. Dann wird $Datum2 von $Datum1 subtrahiert. Da wir durch diese Subtraktion einen Wert in Sekunden erhalten, wird dieser Wert noch durch 3600 geteilt, um Stunden zu erhalten und anschließend durch 24 geteilt, um Tage zu erhalten.

Im zweiten Abschnitt wird die Funktion aufgerufen und mit echo ausgegeben. Hier wäre auch eine Formulareingabe denkbar.

Berechnung eines neuen Datums
Fälligkeitstermin

hier wird ein neues Datum nach Ablauf einer bestimmten Frist ausgegeben (Fälligkeitsdatum). Das lässt sich beispielsweise einsetzen um das Datum einer Zahlungsforderung zu bestimmen, oder um ein Datum auszugeben, an dem eine Ware spätestens eintreffen wird etc. Da diese Frist oft vom aktuellen Datum aus errechnet werden soll, ist es in dieser Funktion möglich, das erste Argument $Heute freizulassen. Im zweiten Argument $Frist muss die Anzahl der Tage eingegeben werden.

<?php

function Faelligkeit($Heute,$Frist) {
if (trim($Heute)==""){
$Heute=date("d.m.y");
}
$Tag= (int) substr($Heute, 0, 2);
$Monat= (int) substr($Heute, 3, 2);
$Jahr= (int) substr($Heute, 6, 4);

if(checkdate($Monat, $Tag, $Jahr)){
$Datum= mktime(0, 0, 0, $Monat, $Tag, $Jahr);
$Datum_neu= date("d.m.y", $Datum+($Frist*3600*24));
return $Datum_neu;
}
else{
return -1;
}
}

?>
05.06.12 <?php
echo Faelligkeit ("",14);
?>
06.03.05 <?php
echo Faelligkeit ("20.02.05",14);
?>

In der ersten if Struktur der Funktion wird geprüft, ob das erste Argument $Heute einen Leerstring enthält (eventuelle Leerzeichen werden vorher mittels trim() entfernt). Enhält $Heute einen Leerstring, bekommt $Heute das aktuelle Systemdatum zugewiesen, mittels date("d.m.y"), in der deutschen Reihenfolge Tag, Monat, Jahr. Unabhängig davon, ob $Heute durch eine Eingabe oder durch das aktuelle Datum bestimmt wurde, wird $Heute mittels substr() in seine Bestandteile zerlegt und den Variablen $Tag, $Monat, $ Jahr übergeben.
In der folgenden if Struktur wird daraus wieder ein Datum erzeugt und mittels checkdate() überprüft, ob es sich um eine sinnvolle Datumseingabe handelt. Ist das nicht der Fall tritt else in Kraft und der Wert -1 wird ausgegeben.
Mit mktime wird ein Zeitstempel von $Heute der Variablen $Datum übergeben. Anschließend wird in $Datum_neu die $Frist hinzugezählt und das neue Datum mittels return ausgegeben.
Siehe dazu unter Datum: In der date() Funktion kann man als zweites Argument ein eigenes Datum mit mktime() eingeben. In diesem Fall: $Datum+($Frist*3600*24)
Da das Argument $Frist in Tagen vorgegeben wird, müssen daraus noch Sekunden erzeugt werden: Tage*3600*24.

Es folgen 2 mögliche Funktionsaufrufe. Im ersten Beispiel enthält das erste Argument $Heute einen Leerstring und es tritt dadurch das aktuelle Systemdatum in Kraft. Im zweiten Beispiel, wird $Heute ein bestimmtes Datum vorgegeben, hierbei müssen Tage und Monate zweistellig eingegeben werden.

Deutsche Wochentage

Es folgt eine Funktion, die das Datum mit einem deutschen Wochentag ausgibt, als Argument $Datum wird ein gültiger Datumssting erwartet, die Trennzeichen sind frei wählbar
"01.10.05"
"30/10/2005"
oder die date Funktion mit der deutschenFormatangabe Tag.Monat.Jahr
date("d.m.y")

<?php

function Wochentag($Datum) {
$Tage = array ("Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag");
if(is_string($Datum)){
$Tag = (int) substr($Datum, 0, 2);
$Monat = (int) substr($Datum, 3, 2);
$Jahr = (int) substr($Datum, 6, 4);
if(checkdate($Monat, $Tag, $Jahr)){
$Datum = mktime(0, 0, 0, $Monat, $Tag, $Jahr);

$Tag = date("w", $Datum);
$Datum_komplett=$Tage[$Tag].", ". date("d.m.y", $Datum);
return $Datum_komplett;
}
else{
return-1;
}
}
}

?>
Montag, 17.10.05 <?php
echo Wochentag ("17.10.05");
?>
Montag, 17.10.05 <?php
echo Wochentag ("17.10.2005");
?>
Dienstag, 22.05.12 <?php
echo Wochentag (date("d.m.y"));
?>

Zu Anfang der Funktion Wochentag wird ein Array gebildet, dessen Elemente die deutschen Wochentage bilden. In der folgenden If Struktur wird überprüft, ob das Argument $Datum überhaupt ein string ist. Ist das nicht der Fall, wird gleich eine Fehlermeldung ausgegeben.
Der folgende Teil wurde schon in den beiden vorigen Funktionen erklärt. (siehe oben)

$Tag = date("w", $Datum);
Hier wird mittels der date Funktion ein numerischer Wert für den Wochentag ermittelt, beginnend bei 0 für Sonntag.
$Tage[$Tag]
Dieser Wert wird dann als Index des zu Anfang gebildeten arrays $Tage übergeben.
In $Datum_komplett wird noch das eingebene Datum durch Kommata getrennt an den Wochentag angehängt
$Datum_komplett=$Tage[$Tag].", ". date("d.m.y", $Datum);
siehe date Funktion
Zum Ende wird $Datum_komplett mit return zurückgegeben.

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

 

weiter

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