Im letzten Kapitel haben wir uns eingehend mit Variablen beschäftigt. Bevor wir in diesem mit Funktionen anfangen, werden noch ein paar Zeilen zu Konstanten kommen, da diese eine Sonderstellung im Bezug auf Funktionen ausüben.

Was ist eine Konstante?
Eine Konstante ist im Grunde genau dasselbe wie eine Variable, sie kann Werte jeglichen Datentyps aufnehmen, mit dem kleinen aber feinen Unterschied, dass eine Konstante wie der Name schon sagt, konstant, d.h. unveränderbar ist.

Wofür brauche ich Konstanten?
Eine berechtigte Frage, die schwer zu beantworten ist. Wenn ich z.B. ein mathematisches Script schreibe, und ich benötige mehrmals den Wert der Wurzel aus Pi. Dann werde ich diesen Wert in einer Konstante speichern - logisch, jedesmal rund 10 Stellen [mehr benutzt man normalerweilse nicht, da sowieso ein Rundungswert als Ergebnis herauskommt] in das Script zu schreiben. Dafür würden auch Variablen reichen. Trotzdem benutzt man in der Praxis dafür Konstanten, da die Wurzel von Pi unveränderbar ist. Man kann sich so auf jeden Fall sicher sein, dass der Wert nicht geändert wird, außerdem hat man mehr Spielraum für Namen. Da Konstanten kein vorangestelltes $-Zeichen besitzen, kann die Variable $foo, und die Konstante foo existieren.

Wie initialisiere ich Konstanten?
Konstanten werden mit der Funktion define() initialisiert. Die genaue Funktionsweise von Funktionen werden wir in diesem Kapitel noch kennenlernen, da man den Aufbau dieser Funktion sowie die in damit in Verbindung genannten Fachwörter werden am Ende des Kapitels klar sein.

<?php
define('Konstantennamen', 'Wert der Konstante');
define('Example', 'HelloWorld!);
echo Example;
?>

Aufmerksame Leser werden wahrscheinlich jetzt bereits wissen, wie man Konstanten definiert und benutzt. Ich werde das Beispiel an dieser Stelle ersteinmal so stehen lassen, mit den Funktionen allgemein fortfahren und am Ende des Kapitels - wenn wir bereits eingelesen im Thema Funktionen sind - wieder darauf zurückkommen.

Was sind Funktionen, was sind Sprachkonstrukte?
Funktionen sind, simple formuliert, Sammlungen von Anweisungen. Diese können aus zwei Quellen stammen, entweder werden sie von PHP mitgeliefert, oder man schreibt sie selber. Bei dem Wort Funktionen werden sich viele an den Mathematik-Unterricht erinnern. Ich kann allerdings versichern, dass sich vieles ähnelt, aber doch vieles sehr unterschiedlich ist. Außerdem werden die mathematischen Kapitel erst noch folgen.
Ein Sprachkonstrukt ist einer mit PHP mitgelieferten Funktion sehr ähnlich, mit dem Unterschied, dass man die Klammern weglassen kann - kennen gelernt haben wir bereits das Sprachkonstrukt echo() [Funktionen werden im Kontext immer mit Klammern genannt, bei Sprachkonstrukten tun dies viele auch, obwohl die Klammern bei der Programmierung meistens weggelassen werden].

Verwendung und Deklaration von Funktionen
Funktionen können in PHP sehr einfach verwendet werden. Sie müssen die Funktion zuerst definieren [in der Programmiersprache auch Deklaration genannt]. Wenn die Funktion mit PHP mitgeliefert wird, entfällt dieser Schritt logischerweise. Als Folge dessen, müssen sie die Funktion logischerweise auch ausführen, denn eine Funktion wird erst bzw. nur bei ihrem Aufruf ausgeführt.

Zum Definieren einer Funktion müssen sie das Schlüsselwort function benutzen:

<?php
function Name() {
    // Anweisungen
}
?>

Nach dem Schlüsselwort function folgt der Funktionsname. Die runden Klammern sind charakteristisch und notwendig für Funktionen. In diesen stehen die etwaigen Parameter [folgen im Laufe des Kapitels noch]. Die Anweisungen stehen in geschweiften Klammern.

Um eine Funktion letzten Endes aufzurufen, verwenden sie ihren Namen und die runden Klammern:

Name();

Um das ganze jetzt mal anschaubar zusammen zu fassen, folgt jetzt noch ein einfaches Beispiel. Die Funktion gibt einen Satz über echo() aus, wenn sie aufgerufen wird.

<?php
function text() {
    echo 'Ich gebe einen Text aus!';
}
text();
?>

Der Aufruf dieses PHP Scripts führt zu der folgenden Ausgabe:

Ich gebe einen Text aus!

Wichtig: Funktionsnamen folgen denselben Regeln via Variablen, d.h. sie dürfen nur aus Buchstaben, Zahlen und Unterstrichen bestehen und müssen mit einem Buchstaben oder einem Unterstrich anfangen. Im Gegensatz zu Variablen sind diese jedoch nicht case-sensitiv, d.h. sie unterscheiden sich nicht in Groß- und Kleinschreibung [die Funktion foo() ist dieselbe wie die Funktion FOO()].

Parameter
Funktionen ähneln Computerprogrammieren. Die Funktionalität steckt innerhalb der Anweisungen der Funktionen. Der Aufrufende muss allerdings nicht wissen, wie die Funktion technisch gesehen funktioniert bzw. wie sie genau aussieht [auch wenn das bei selbst deklarierten Funktionen immer der Fall ist], trotzdem muss er der Funktion Informationen und Werte übergeben können. Dies erledigen Parameter.

Die Parameter der Funktion müssen von Ihnen zwischen die Klammern bei der Deklaration der Funktion geschrieben werden. Die Parameter werden wie Variablen behandelt und sind auch so innerhalb der Funktion aufrufbar.

<?php
function text($nachricht) {
    echo $nachricht;
}
text('Ich werde ausgegeben!');
?> 

Dabei können die Parameter wie in diesem Beispiel direkt geschrieben werden, oder als Variable übergeben werden.

<?php
function text($nachricht) {
    echo $nachricht;
}
$var = 'Ich werde ausgegeben!';
text($var);
?> 

Mehrere Parameter werden [sowohl im Kopf, als auch beim Aufruf] via Kommata abgetrennt. Beim Aufrufen der Funktion entspricht der erste übergebene Wert auch dem ersten definierten Parameter, der zweite übergebene Wert dem zweiten Parameter, und so weiter [für alle ohne HTML-Kentnisse, das <br /> steht für einen Zeilenumbruch]:

<?php
function output($parameter1, $parameter2) {
    echo "Parameter 1: $parameter1 <br/>";
    echo "Parameter 2: $parameter2";
}
$var = 'Welt';
output('Hallo', $var);
?> 

Die oben gezeigte Funktion übergibt zwei Parameter, einen als direkten Wert, einen als Variable - und führt am Ende zu folgender Ausgabe:

Parameter 1: Hallo
Parameter 2: Welt 

Zurück zu den Konstanten
Um nun noch einmal auf die Konstanten bzw. die Funktion define() zurückzukommen. Um eine Konstante zu definieren, muss man die Funktion define aufruf. Die Funktion erwartet als 1. Parameter den Namen der Konstante als String [d.h. eine Zeichenkette in einfachen oder doppelten Anführungszeichen], und als 2. Parameter den Wert, der der Konstante zugewiesen werden soll [Datentyp ist dementsprechend egal, da eine Konstante wie eine Variable eine Ganzzahl, ein String und jegliche andere Art von Datentyp sein kann]. Die Konstanten werden dann über den Namen, der als 1. Parameter übergeben wurde, angesprochen.

Parameter: Wert oder Referenz
Wenn ein Parameter an eine Funktion übergeben wird, geschieht dies in PHP standardmäßig als Wert [call by value], d.h. während des Durchlaufs der Funktion wird eine exakte Kopie des übergebener Werts bzw. der übergebenen Variable angelegt, d.h. der Originalwert bleibt erhalten. Als Beispiel: Einer Funktion x() wird der Parameter $y übergeben. In der Funktion heißt der Parameter $z [$y ist der erste übergebene Parameter, in der Funktionsdeklaration ist der erste Parameter $z, d.h. $z steht in der Funktion für den Wert von dem ursprünglichen $y]. Ich erhöhe jetzt die Parametervariable $z um 2, danach wird die Funktion beendet. Der Wert der ursprünglich übergegebenen Variable $y ist jedoch immer noch derselbe].

Die Alternative ist die Übergabe als Referenz [call by reference]. In diesem Fall ist der Parameter der Funktion nur eine Referenz, d.h. ein Verweis auf die ursprünglich übergebene Variable. Wenn also die Parametervariable innerhalb der Funktion verändert wird, verändert sich auch die Ursprungsvariable. [in diesem Fall würde bei der Erhöhung von $z um 2 auch $y um 2 erhöht werden].
Um eine Variable als Referenz zu übergeben, muss ein Und- bzw. Et-Zeichen [ & ] dem Parameter im Kopf der Funktion vorangestellt werden.

<?php
function callbyvalue($z) {
    $z = $z + 2;
}
function callbyreference(&$z) {
    $z = $z + 2;
}

$y = 0;
callbyvalue($y);
/* Der Wert von $y ist immer noch 0,
   da nur der Wert der angelegten
   Kopie während der Laufzeit der
   Funktion verändert wurde.        */

callbyreference($y);
/* Der Wert von $y beträgt jetzt 2,
   da der Parameter diesmal ein
   Verweis auf die originale
   Variable war, d.h. der Wert
   der originalen Variable direkt
   verändert wurde.                 */
?> 

Ich denke, der Unterschied der Verfahren Wert oder Referenz ist in dem obigen Beispiel klar geworden, ich denke, das Beispiel ist ausreichend kommentiert.

Vorgabewerte
Wir haben bis jetzt nur gelernt, Parameter zu übergeben. Was ist allerdings, wenn - falls ein Parameter nicht übergeben wird - man einen Standardwert angeben will. Folgendes Beispiel: [Man schreibt ein soziales Netzwerk. Man kann das Geschlecht angeben, muss an aber nicht. Wenn die Person männlich ist, ist der Wert von $geschlecht 1, wenn sie weiblich ist, ist der Wert von $geschlecht 2. Wenn die Person jedoch keinen Wert übergibt, soll die Funktion automatisch $geschlecht gleich 0 sitzen, was bedeutet, dass kein Geschlecht angegeben wurde]:

<?php
function output($parameter = 'Standardwert') {
    echo "$parameter <br />";
    // <br /> -> Zeilenumbruch
}
output();
output('Übergebener Wert');
?> 

Der Standardwert wird immer den verwendet, wenn für den entsprechenden Parameter kein Wert übergeben wird [im obigen Beispiel wird beim ersten Aufruf der Funktion output() kein Parameter angeben, daher wird der Parameter mit dem Wert "Standartwert" gefüllt. Die obige Funktion führt zu dieser Ausgabe:

Standartwert
Übergebener Wert 

Um also einen Standardwert für einen Parameter zu definieren, muss in der Funktionsdeklaration dem Parameter - wie einer ganz normalen Variable - ein Wert über den Zuweisungsoperator zugewiesen werden.

Wichtig: Wenn man mehr als einen Parameter verwendet, muss man den oder die Parameter mit Standardwerten ans Ende schreiben. Dies ist relativ logisch, da die Parameter mit Standardwerten selbst wenn sie nicht über den Funktionsaufruf einen Wert zugewiesen bekommen, einen Standardwert enthalten, die ohne Standardwert jedoch noch gar keinen Wert zugewiesen bekommen haben.

Flexible Anzahl an Parametern
Der Standardwert ist die einzige Möglichkeit, zu wenig Parameter an eine Funktion zu übergeben. Zu viele Parameter können jedoch mit mehreren, von PHP mitgelieferten, Funktionen ausgelesen werden.

Erklärung: Das Übergeben von zu vielen Parametern wird in der Programmierung als Überladen bezeichnet. Während in anderen Programmiersprachen jedoch für unterschiedlich viele Parameter auch unterschiedliche Funktionen zur Verfügung stehen, ist das in PHP nicht der Fall.

Wofür benötigt man diese Funktionen? Nun, wenn man zu viele Funktionen übergibt, sind diese ja nicht vorher bei der Deklaration gesetzt. Irgendwie muss man allerdings darauf zugreifen. Das geht mit folgenden Funktionen:

func_num_args() - Liefert als Rückgabewert die Anzahl
der übergebenden Elemente, egal ob diese vorher als
Parameter bekannt gemacht wurden.
[Rückgabewerte folgen im nächsten Kapitel.]

Bsp.:
function funktion() {
    $elemente = func_get_args();
    echo $elemente;
}
funktion('Ein Element');

Dieses Script gibt dementsprechend eine 1 aus
[1 übergebender Wert]. 

func_get_args() - Liefert als Rückgabewert ein Array
[Arrays folgen in den späteren Kapiteln] mit den
übergebenden Parametern. 

Bsp.:
function funktion() {
    $elemente = func_get_args();
    echo $elemente[0];
}
funktion('Ein Element');

Dieses Script gibt das übergebende Element aus
[1 übergebender Wert, dieser wird durch den erste
Index des zurückgelieferten Arrays ausgegebn].

func_get_arg(Index) - Erlaubt den direkten Zugriff
auf ein Element ohne das Array. Der Parameter
der Funktion ist die Nummer das Index des
Parameters der zurückgeliefert werden soll
[der 1. Parameter hat den Index 0].

function funktion() {
    $element = func_get_arg(0);
    echo $element;
}
funktion('Element');

Dieses Script gibt 'Element' aus. 

Mit diesen 3 Funktionen können alle Parameter ausgelesen werden, auch wenn mehr als vorher deklariert übergeben werden.

Weiteres zu Funktionen folgt im nächsten Kapitel.

[Copyright 2009-2010 by Robin Rump, robinrump.com. All rights reserved. Do not copy, edit or publish without asking author.]