HTMLWorld - HTML, CSS, JavaScript, PHP, Java, Flash und vieles mehrHTMLWorld:   Home | Impressum |
 

 
 

Anzeige 
 
               Forum
 
 
HTMLWorld » PHP » Funktionen

PHP: Funktionen

von Andre Fritzsche

Die elementare Grundlage einer strukturierten und effektive Programmierung sind Funktionen. Ohne diese müsste jeder wiederholt vorkommende Quellcodeteil neu geschrieben werden und komplexe mathematische Operationen wären nicht möglich.

Anzeige

Syntax  nach oben

Der Aufbau einer Funktionsdeklaration ist denkbar simpel:

function funktionsname(parameter1,parameter2,...) 
{
  ...Anweisungen...
}

Im Wesentlichen besteht eine Funktion aus einem Funktionskopf und einem Funktionsrumpf. Der Kopf legt fest, wie die Funktion aufgerufen werden muss. Hier wird das Schlüsselwort function vor den Funktionsnamen gestellt, danach folgen in runden Klammern die Parameter, insofern welche benötigt werden. Im Funktionsrumpf, der wie ein Anweisungsblock durch die geschweiften Klammern dargestellt wird, stehen die Anweisungen, die die Funktion zur Ausführung benötigt.

Funktionsparameter  nach oben

Wie in der Mathematik macht auch in PHP eine Funktion ohne Parameter nur in seltenen Fällen Sinn. Dabei gibt es aber mehrere Dinge zu beachten.

Parameterübergabe

In vielen Fällen ist es notwendig, an eine Funktion Werte zu übergeben. Das geschieht mittels der Parameterliste im Funktionskopf:

function add($param1,$param2) 
{
  return $param1+$param2;
}

Den so angegebenen Parametern wird bei einem Aufruf der Funktion der entsprechende Wert zugewiesen.

add(12,3);

Bei diesem Aufruf erhält $param1 den Wert 12 und $param2 den Wert 3. Werden beim Aufruf als Parameter Ausdrücke oder Variablen angegeben, so erhalten die Parameter deren Wert.

add(12,$a*3);

$param1 erhält wieder die 12, $param2 den Wert von $a multipliziert mit 3.
Innerhalb des Funktionsrumpfes kann jetzt auf die Parameter wie auf eine Variable zugegriffen (im Grunde genommen sind sie ja auch nichts anderes) und sogar deren Wert geändert werden. Allerdings ändern sich bei einer Änderung der Parameter innerhalb der Funktion die Werte einer eventuell aufrufenden Variable nicht.

function add($param1,$param2)
{
  $param2++;
  echo "param2 (b) = ",$param2,"\n";
  return $param1+$param2;
}

$a=2; $b=1;
add($a,$b);       //Ausgabe 'param2 (b) = 2'
echo "a=",$a,"\n" //Ausgabe 'a=2;
echo "b=",$b,"\n" //Ausgabe 'b=1;

In der Funktion wird der Wert von $param2 um eins erhöht. Gibt man allerdings $b nach Aufruf der Funktion aus, so stellt man fest, das $b den gleichen Wert wie vor dem Aufruf hat.

Referenzparameter

Sollte das nicht erwünscht sein, so muss der Parameter als Referenz deklariert werden (&-Operator):

function add($param1 , &$param2) 
{
  $param2++;
  echo "param2 (b) = ",$param2,"\n";
  return $param1+$param2;
}

$a=2; $b=1;
add($a,$b);       //Ausgabe 'param2 (b) = 2'
echo "a=",$a,"\n" //Ausgabe 'a=2;
echo "b=",$b,"\n" //Ausgabe 'b=2;

Hier wird ebenfalls $param2 um eins erhöht. Doch durch den Referenzoperator & in der Parameterliste ändert sich hier auch der Wert unserer übergebenen Variable $b.
Mehr zu Referenzen im Abschnitt Rückgabe von Ergebnissen und im Kapitel Variablen, Abschnitt Referenzen.

Optionale Parameter

Grundsätzlich sind Parameterangaben in einer Funktionsdeklaration optional, dass heisst, wir können Parameter angeben, müssen aber nicht.
Allerdings gibt es in PHP die Möglichkeit, Werte von Parameter vorzudefinieren und diese somit optional zu machen. Diese sogenannten Optionalen Parameter werden wie eine Wertzuweisung im Funktionskopf angegeben:

function add($param1,$param2=12) 
{
 return $param1+$param2;
}

echo "add(12) ergibt ",add(12),"\n";    
echo "add(12,2) ergibt ",add(12,2),"\n";

/* Ausgabe:
 add(12) ergibt 24
 add(12,2) ergibt 14
*/

Im ersten Aufruf wurde kein zweiter Parameter angegeben und somit erhielt $param2 den Standardwert 12 und das Ergebnis dieses Aufrufs 12+12=24. Der zweite Aufruf enthielt als zweiten Parameter 2, so dass der Aufruf 12+2=14 ergibt. Ein praktisches Beispiel ist die wurzel()-Funktion aus dem Abschnitt Grundlegendes diesen Kapitels.

Rückgabe von Funktionsergebnissen  nach oben

Genau wie in der Mathematik können Funktion in PHP Ergebnisse liefern. Hierzu wird das Schlüsselwort return benutzt.

function add($param1,$param2) 
{
  return $param1+$param2;
}
echo add(5,-3); //Ausgabe: '2'

Allerdings ist hier zu beachten, dass ein return nicht nur den Rückgabewert festlegt sondern auch aus der Funktion herausspringt. Das heisst, alle Anweisungen nach einem return werden nicht mehr ausgeführt.

function add($param1,$param2) 
{
  $retval=0;
  return $retval; 
  //hier wird die Funktion verlassen und $retval zurückgegeben

  $retval=$param1+$param2; 
  //diese Zeile wird nicht mehr ausgeführt!
}

Das kann aber manchmal auch erwünscht sein:

function enthalten($wert,$liste) 
{
  foreach ($liste as $element) 
  {
    if ($element==$wert) return true;
  }
  return false;
}

if (enthalten('Negro',array('Negro','Kira','Angie'))) 
   echo 'Enthalten';

Diese Funktion durchläuft alle Elemente einer Liste $liste und prüft, ob der als Parameter angegebene Wert $wert mit einem der Elemente übereinstimmt. Ist das der Fall, so wird sofort die Funktion verlassen und true zurückgegeben. Gelangt die Ausführung des Codes bis hinter den Anweisungsblock unserer for-Schleife wissen wir, dass kein Element gefunden wurde und geben false zurück.
Was aber macht man, wenn eine Funktion nicht nur ein sondern gleich mehrere Ergebnisse liefern soll? Dazu gibt es zwei Varianten: entweder man gibt eine Liste mit allen gewünschten Ergebnissen zurück ...

return array($ergebnis_1,$ergebnis_2,...);

... oder man gibt die Parameter im Funktionskopf als Referenz an (siehe auch Kapitel Variablen, Abschnitt Referenz).

function funktionsname($a , &$b , &$c)

Wobei in diesem Beispiel eine Änderung der Parameter $b und $c innerhalb des Funktionsrumpfes auch die Aufrufparameter auswirkt. Bauen wir das Beispiel mit der Elementsuche in Listen aus und wollen jetzt nicht nur wissen, ob das Element enthalten ist sondern auch noch seinen Schlüssel und den Wert des Elements selbst haben.

function enthalten($wert, $liste) 
{
  foreach ($liste as $element) 
  {
   if ($element==$wert)
   { return array(key($liste),pos($liste)); }
  }
  return false;
}

if(list($k,$p) = enthalten('A',array('A','B','C')))
{ echo "$k: $p"; } //Ausgabe: '0: A'

Dieses Beispiel liefert im Erfolgsfall eine Liste mit zwei Element zurück, das erste ist der Schlüssel und das zweite der Wert des Elements. Man sollte noch beachten, dass in der if-Abfrage eine Zuweisung stattfindet, kein Vergleich! Allerdings kann, wie im Kapitel Operatoren erläutert, der Wert einer Zuweisung ausgewertet werden, und das ist in diesem Fall entweder ein Wert (=true), wenn das Element gefunden wurde oder false, wenn nicht. Nun die Variante mit Referenzparametern:

function enthalten($wert,$liste,&$key,&$elem) 
{
  foreach ($liste as $element) 
    if ($element==$wert) 
    {
      $key=key($liste);
      $elem=pos($liste);
      return true;
    }
  return false;
}

if (enthalten('A',array('A','B','C'), $schluessel,$wert)) 
{ echo "$schluessel: $wert"; }
//Ausgabe: '0: A'

Hier wird einfach den beiden Referenzvariablen $key und $elem der entsprechende Wert zugewiesen und im Erfolgsfall kann dann auf diese beiden zugegriffen werden.

Rückgabe von Referenzen  nach oben

Funktionen können nicht nur Werte sondern auch Referenzen zurückgeben. Wenn Sie nicht wissen was Referenzen sind, so lesen Sie bitte im Kapitel Variabeln den Abschnitt über Referenzen.
Die Rückgabe von Referenzen als Ergebnis einer Funktion macht vor allem dann Sinn, wenn Objekte oder Listen zurückgegeben werden sollen, weil gerade diese Typen sehr viel Speicher benötigen und so nur eine Referenz übergeben wird und nicht eine Kopie des Typs.

function &getobject($index) 
{
  return $objectlist[$index];
}

$obj=&getobject(2);

Dieses Beispiel demonstriert die Syntax einer Referenzrückgabe. Im Gegensatz zu Referenzen als Parameter muss hier sowohl beim Aufruf als auch in der Deklaration der Funktion der Referenzoperator & angegeben werden.

Funktionstypen  nach oben

Im Prinzip gibt es nur einen Typ: die Funktion an sich. Allerdings ist je nachdem, wo man eine Funktion deklariert, deren Verhaltensweise unterschiedlich.

Bedingte Funktionen

Ähnlich wie bei den Pre-Compiler-Anweisung in C kann man auch in PHP bedingte Ausführungen vornehmen, nur dass hier keine speziellen Anweisungen erforderlich sind, da unsere Scripte ja sowieso erst zur Laufzeit interpretiert werden.

$sprache='deutsch';

if ($sprache=='deutsch') 
{ function hallo() { echo "Willkommen!\n"; } } 
else 
{ function hallo() { echo 'Welcome!\n";        } }

hallo(); 

In diesem Beispiel gibt es zwei Funktionsdeklaration für die Funktion hallo(). Ist $sprache gleich 'deutsch' wird diese so implementiert, dass sie 'Willkommen' ausgibt, ansonsten 'Welcome'.
Auf diese Art und kann man mehrere (gleiche) Funktionen definieren und über eine Bedingung (kann auch eine Konstante sein) auswählen, welche implementiert wird.

Rekursive Funktionen

Rekursive Funktionen sind Funktionen, die sich selbst aufrufen. Mit der Möglichkeit der Rekursion hat man in PHP eine sehr mächtiges Werkzeug zur Hand, da man hier mit wenig Aufwand viel erreicht.

get_files(".");

function get_files($startdir) 
{
  $dh=opendir($startdir);
  while (false !== ($file = readdir($dh))) 
  {
    if ($file!="." && $file!="..") 
    {
      if (is_dir($startdir."/".$file)) 
      {
        get_files($startdir."/".$file."/");
      }
      else echo "$file\n";
    }
  }
  closedir($dh);
}

Dieses Beispiel gibt alle Dateien im aktuellen und dessen untergeordneten Verzeichnis aus. Die Funktion erhält ein Verzeichnis als Parameter und liest nun nacheinander alle Einträge in diesem Verzeichnis aus. Ist einer dieser Einträge ein Verzeichnis, so ruft sich die Funktion selbst auf und übergibt den Eintrag als Parameter. Hiermit werden jetzt wieder alle Einträge aus diesem Verzeichnis geholt und so weiter. Das alles ist allerdings auf diese Art und Weise nur möglich, weil die benutzen Variablen für jeden der Funktionsaufrufe gespeichert werden, so dass ein rekursiver Aufruf nicht die Inhalte der genutzten Variablen überschreibt.

Funktionsvariablen  nach oben

PHP bietet die Möglichkeit, Funktionsaufrufe in Variablen zu übergeben. Dazu muss in der Variablen einfach der Name der Funktion als Zeichenkette gespeichert werden. Will man diese jetzt aufrufen, so setzt man diese Variable mit einer Parameterliste dahinter als Anweisung ein. Hier ein Beispiel:

function fn_eins($param) {  return 'Eins? '.$param; }

function fn_zwei() { return 'Zwei!'; }

function ausgabe($aufruf) { echo $aufruf('1!'),"\n"; }

$funktion='fn_eins';
ausgabe($funktion);
$funktion='fn_zwei';
echo $funktion(),"\n";



« zurück weiter »
Bewerten

 

PHP

.Autor:Jan Winkler.
. Bewertung:
PHP: Funktionen HTMLWorld
(5/5 bei 1 Votes)
.
. Community: 586 Beiträge im PHP Forum .

Navigation


 
     
 

Anzeige