====== PHP-Funktionen ======

===== PHP interne Funktionen =====

PHP selbst hat eine Menge eigener Funktionen, die man, ohne irgendetwas einbinden zu müssen, aufrufen kann. Um eine Funktion aufzurufen, muss man zunächst den Funktionsnamen angeben und meistens eine Variable, in die der Rückgabewert der Funktion gespeichert werden kann. Außerdem braucht man oft einen oder mehrere Werte, die die Funktion bearbeiten soll, oder die der der Funktion mitteilen, was genau sie tun soll (Funktionsparameter).

==== Eine interne Funktion aufrufen ====

<code php>
<?php
$rueckgabewert = funktionsname (Funktionsparameter);
?>
</code>

Nehmen wir als Beispiel die Funktion:
<code php>int strlen  (string $string)</code>
Aus dieser Schreibweise können wir folgendes erkennen: 
  - "(int)": Die Funktion gibt eine Ganzzahl (int = Integer) zurück
  - Der Funktionsname ist strlen
  - Die Funktion benötigt einen Parameter (eine Variable, die der Funktion mitgeteilt wird), der in diesem Fall ein String (also eine Zeichenkette) ist.

Der Name der übermittelten Variable muss aber nicht unbedingt $string sein. Man kann jede Stringvariable übergeben, doch in der Funktion wird der Variable $string der Wert des übermittelten Parameters zugewiesen.

Um herauszufinden, was diese Funktion tut, kann man sie auf [[http://de3.php.net/manual-lookup.php]] suchen (teilweise englisch).
Dort steht, dass die Funktion die Anzahl der Zeichen des übermittelten Parameters zurückgibt:

<code php>
<?php
$name = "Rasmus";
$anzahl_zeichen = strlen($name);
echo "Dein Name hat $anzahl_zeichen Zeichen";
?>
</code>

Das gleiche Ergebnis könnte man auch so erreichen:

<code php>
<?php
$anzahl_zeichen = strlen("Rasmus");
echo "Dein Name hat $anzahl_zeichen Zeichen";
?>
</code>
<code php>
<?php
$name = "Rasmus";
echo 'Dein Name hat '.strlen($name).' Zeichen';
?>
</code>
Wichtig ist hierbei, dass PHP zwar Variablen innerhalb der doppelten Anführungsstriche erkennt, nicht jedoch Funktionen. Deshalb wurde im letzten Beispiel das einfache Anführungszeichen in Verbindung mit einem Punkt verwendet.

==== Mehrere Parameter übergeben ====

Manche Funktionen benötigen allerdings mehrere Parameter. In so einem Fall übermittelt man die Parameter, indem man sie mit einem Komma voneinander trennt.

Als Beispiel:
<code php>
string str_repeat (string $input, int $multiplier)
</code>
Diese Funktion verdoppelt eine Zeichenkette so oft, wie in int $multipler angegeben ist.

<code php>
$alter_string = "lol"
$neuer_string = str_repeat ($alter_string, 3);
echo $neuer_string;
</code>
//Ausgabe: lollollol//

==== Optionale Parameter ====

Es gibt auch Parameter, die man nicht bei jedem Funktionsaufruf angeben muss, da sie einen Standardwert haben, den man nur in Ausnahmefällen ändern muss.
Im PHP-Manual sieht das so aus:

<code php>
Variablentyp Funktionsname (Variablentyp $parameter1, Variablentyp $parameter2 [, Variablentyp $optionaler_parameter  ] )
</code>

Ein Beispiel dafür ist explode().

<code php>
array explode  ( string $delimiter  , string $string  [, int $limit  ] )
</code>
Diese Funktion teilt eine Zeichenkette ($string) bei einem bestimmten Zeichen oder einer bestimmten Folge von Zeichen ($delimiter). Gibt man auch noch einen Wert für $limit an, dann hat das Array, dass die Funktion zurückgibt, höchstens $limit-Elemente. Das letzte Element würde den ganzen Rest der Zeichenkette enthalten.

Beispiel:
<code php>
$string = "Hi. Ich heisse Hauke. Ich finde PHP toll";
$saetze = explode (".",$string);
echo saetze[0]; // Hi
echo saetze[1]; // Ich heisse Hauke
echo saetze[2]; // Ich finde PHP toll
</code>
Hier wurde nach jedem Punkt ein neues Array-Element begonnen.

<code php>
$string = "Hi. Ich heisse Hauke. Ich finde PHP toll";
$saetze = explode (".",$string, 2);
echo saetze[0]; // Hi
echo saetze[1]; // Ich heisse Hauke. Ich finde PHP toll
</code>

Hier wurde das Array auf maximal 2 Elemente begrenzt, weshalb der letzte Punkt nicht entfernt und ein neues Array-Element begonnen wurde.
 
===== Eigene Funktionen =====
Man kann jedoch auch eigene Funktionen definieren. Das ist nützlich, wenn man eine Reihe von Befehlen immer wieder ausführen muss, z.B. eine Login-Kontrolle. Man übergibt die ID oder den Namen des Users, die Befehle werden ausgeführt, und zum Schluss sagt die Funktion, ob der User angemeldet ist oder nicht. Ändert sich nun z.B. ein Variablenname, muss man nicht in allen Dateien die Loginkontrolle ändern, sondern nur in der Funktion, die in den anderen Dateien aufgerufen wird.

==== Definieren ====

Ein Funktion kann man einfach in der PHP-Datei, in der man sie benutzt definieren. Es bietet sich jedoch an eine Datei //functions.php// zu erstellen, dort die Funktionen zu definieren, und dann per [[php:include|Include]] in die Datei einzubinden, in der man sie benutzt.

<code php>
<?php
function funktionsname ($parameter1,$parameter2)
{
    Befehl1;
    Befehl2;
    return $rueckgabewert;
}
?>
</code>

Diese Funktion würde zwei Parameter erwarten, dann die Befehle ausführen (in der auf die übermittelten Variablen mir //$parameter1// bzw. //$parameter2// zugegriffen werden könnte), und schließlich den Wert //$rueckgabewert// zurückgeben.

Machen wir eine Beispielfunktion, die Vor- und Nachname einer Person zusammenfügt und zurückgibt (sinnlos, aber es ist ja nur ein Beispiel ;) )

<code php>
<?php
function get_full_name($name1,$name2)
{
    $full_name = $name1.' '.$name2; // Die beiden Parameter werden zusammengeführt, in der _internen_ Variable $full_name
    return $full_name; // Die interne Variable wird zurückgegeben
}
?>
</code>

Ich wiederhole nochmal: Von einer Funktion aus kann man nur auf Variablen in der Funktion oder auf Variablen, die der Funktion übermittelt wurden, zugreifen. Umgekehrt kann man von außen nur auf die Variable zugreifen, die die Funktion zurückgeliefert, also in eine externe Variable gespeichert, hat.

==== Anwenden ====

Das Anwenden ist ähnlich einfach (wir machen gleich mit dem Beispiel von oben weiter):

<code php>
<?php
// ... hier muss die Funktion definiert worden sein, oder eine Datei mit den Funktionsdefinitionen inkludiert worden sein
$rueckgabewert = get_full_name("Matthew","Farrell"); // Die Funktion wird aufgerufen, zwei Parameter werden übermittelt, und eine Variable, in der der Rückgabewert geschrieben werden soll, wird angegeben
echo $full_name;
?>
</code>

Man kann nicht mehrere Variablen als Rückgabewert angeben, jedoch kann man ein Array zurückgeben.

==== Optionale Parameter ====

Doch was, wenn eine Person noch einen Zwischennamen hat? An sich kein Problem: Wir fügen einen neuen Parameter in die Funktionsdefinition ein, und übermitteln eine zusätzliche Variable an die Funktion. Wenn die Person keinen Zwischennamen hat, meldet PHP jedoch 
<code>
Warning: Missing argument x for funktionsname(), called in xxx.php on line x and defined in yyy.php on line y
</code>

Und so definieren wir einen optionalen Parameter:
<code php>
<?php
function get_full_name($name, $name2 , $name3 = 'Kein Zwischenname')
{
    $full_name = $name1.' '.$name3.' '.$name2; // $name3 ist nun, falls er nicht im Funktionsaufruf definiert wurde "Kein Funktionsname" 
    return $full_name; // Die interne Variable wird zurückgegeben
}
?>
</code>

Wir können die Funktion also nun entweder mit //$full_name = get_full_name("Hauke","Jan","Luebbers"); // oder mit //$full_name = get_full_name("Hauke","Luebbers");// aufrufen.