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.

Default Parameter mit Standardwert

Man kann die Parameter mit Standardwerten belegen. Will man beim Funktionsaufruf diesen Standardwert nutzen, braucht man das Argument nicht anzugeben.
Gibt man den Wert beim Aufruf der Funktion an, wird der Standardwert überschrieben. 

      

        function bruttoAnzeigen($wert, $mwst = 19)
        {
           echo $wert * (100 + $mwst) / 100;

        }

        bruttoAnzeigen(30);

35.7

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

 

Benannte Argumente

Hat man mehrere Parameter mit Vorbelegung, kann es vorkommen, dass man beispielsweise den letzten Parameter mit einem eigenen Wert belegen will, aber die anderen Parameter sollen ihre Standardwerte behalten.

In dem Fall bietet es sich an, benannte Argumente einzusetzen. Die Bezeichner der Parameter werden ohne Dollarzeichen am Anfang aufgeführt gefolgt von einem Doppelpunkt und dem gewünschten Wert.

 

    function bruttoAnzeigen($wert, $mwst = 19, $waehrung = "€")
    {
        echo $wert * (100 + $mwst) / 100 . " " . $waehrung;
    }

    bruttoAnzeigen(wert: 30, waehrung: "$");

Wenn man sich an die Reihenfolge hält ist es möglich keine Namen anzugeben. So könnte der Aufruf der Funktion auch so notiert sein.

bruttoAnzeigen(30, waehrung: "$");

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

Ü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. Alternativ ist auch folgende Schreibweise möglich: $GLOBALS["bezeichner"] Der Bezeichner muss in Anführungszeichen ohne Dollarzeichen am Anfang. Es handelt sich bei dieser Syntax um ein assoziatives Array, welches alle globlen Variablen enthält. siehe Manual $GLOBALS[].

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 Variablennamen global $x oder man nutzt $GLOBALS["bezeichner"]
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.

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

 

Datentyp deklarieren

Man kann in Funktionen auch die Datentypen der Parameter angeben und den Datentyp des Rückgabewerts. Im folgendem Beispiel sehen wir vor dem Parameter den gewünschten Datentyp. Außerdem wird nach der Klammer ein Doppelpunkt mit Datentyp aufgeführt. Er definiert den Rückgabewert.

function machWas(int $a): int
{ return $a*2
}

strict_types

Es funktioniert jedoch auch wenn man beim Aufruf der Funktion einen String mit einer Zahl angibt, denn der String wird dann intern in einen integer umgewandelt. Damit das nicht funktioniert gibt man am Anfang des Scripts folgende Zeile ein.

declare(strict_types=1);

Union Types

Man kann auch mehrere Datentypen angeben. Diese werden dann mit dem Pipe-Zeichen getrennt int|float

function machWas(int|float $a) : int|float
{ return $a*2;
}

Ab PHP Vers.8 kann man auch mixed angeben, das bedeutet es sind mehrere Datentypen möglich. Das Schlüsselwort void setzt man ein, für eine Funktion ohne Rückgabewert.

Folgende Datentypen sind möglich

Weitere sind

mixed / alle Datentypen

void / bei einer Funktion ohne Rückgabewert

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.

Array als Argument

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.

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

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

Brutto, Netto, Mehrwertsteuer

Eine weitere Möglichkeit eine Funktion anzulegen, ist neben dem Rückgabewert noch einen Fehlercode zu definieren. 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);

?>

Klassen & Objekte

objektorientierte Programmierung

Klassen sind so etwas wie ein Blueprint, eine Vorlage, die man einsetzen kann.

Klassen gibt es in vielen Programmiersprachen. Klassen wurden erfunden, um komplexe Programmierungen verständlich anzulegen. Dazu werden Konzepte aus der wirklichen Welt in die Programmiersprache übertragen. Ein typisches Beispiel, um das Konzept zu erklären ist folgendes: Nehmen wir ein Auto, das Auto hat Eigenschaften wie Farbe, Türen, Lenkrad, Sitze. Außerdem hat es Methoden wie fahren, bremsen, lüften etc. Diese Dinge werden alle in einem Blueprint definiert. Dieser Blueprint oder diese Vorlage ist die Klasse.

Von dieser Klasse erzeugt man dann Instanzen. Die Instanzen bekommen einen eigenen Namen und man kann ihnen unterschiedliche Eigenschaftswerte zuweisen, beispielsweise eine andere Farbe eine andere Anzahl an Türen. Diese Instanzen können fahren, bremsen. Das entspricht dem Aufruf einer Methode. Eine Methode entspricht einer Funktion, die der Klasse zugewiesen ist.

Dieses Konzept könnte man auch auf andere Dinge anwenden beispielsweise auf eine Schlange, einen Kuchen, einen Warenkorb oder eine Spielfigur oder Waffe in einer Computerspielprogrammierung.

Im folgendem Beispiel wird eine Klasse Warenkorb mit dem Schlüsselwort class deklariert. Darin werden die Eigenschaften $kunde und $waren und die Methoden addProduct() und showProducts() erzeugt.

Man beachte, dass die interne Eigenschaft $waren innerhalb der Methoden mit der Syntax
$this->waren angesprochen wird.

Nach der Klassendeklaration wird eine neue Instanz oder Objekt der Klasse Warenkorb erezeugt und zwar mit dem Schlüsselwort new. Es hat hier den Namen $produkte bekommen. $produkte = new Warenkorb;
Dann werden Eigenschaftswerte zugewiesen und Methoden aufgerufen. Das geschieht über eine Pfeilsyntax:

$produkte->kunde = "Walter";
$produkte->addProduct("Hose");

Hier folgt der komplette Code.

class Warenkorb
{
    public $kunde;
    public $waren = [];
    public function addProduct($zutat)
    {
        array_unshift($this->waren, $zutat);
    }
    public function showProducts()
    {
        foreach ($this->waren as $n) {
            echo "$n <br>";
        }
    }
}

$produkte = new Warenkorb;
$produkte->kunde = "Walter";
$produkte->addProduct("Hose");
$produkte->addProduct("Jacke");
$produkte->showProducts();

Konstruktorfunktion

Wie in anderen Programmiersprachen, kann man aucn in PHP Konstruktorfunktionen in Klassen einsetzen.
Siehe PHP Manual Konstruktoren

Eine Konstruktorfunktion wird aufgerufen, wenn ein neues Objekt der Klasse erzeugt wird. Damit hat man die Möglichkeit dem Objekt beim Intialisieren bestimmte Eigenschaftswerte zuzuweisen. Obiges Beispiel wird hier um eine Konstruktorfunktion erweitert. Beim Initialisieren wird der Name für die Eigenschaft $kunde zugewiesen.

class Warenkorb
{
    public $kunde;
    public $waren = [];
    function __construct($kunde)
    {
        $this->kunde = $kunde;
    }
}

$produkte = new Warenkorb("Willi");

echo $produkte->kunde;

public, private, protected

Wenn ein Member als "protected" deklariert ist, bedeutet dies, dass er innerhalb der Klasse und auch in abgeleiteten Klassen (Kindklassen) zugänglich ist. Andere Klassen, die nicht von dieser Klasse erben, haben keinen direkten Zugriff auf geschützte Mitglieder.

Wenn ein Member als "private" deklariert ist, bedeutet dies, dass er nur innerhalb der Klasse, in der er definiert ist, zugegriffen werden kann. Andere Klassen, die von dieser Klasse erben, haben keinen direkten Zugriff auf private Mitglieder.

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