Programmieren mit php und mySQL (Funktionen) - Guru 2.0
Programmieren mit php und mySQL (Funktionen)

Programmieren mit php und mySQL (Funktionen)

Die Arrays sind mit der letzten Hausübung abgeschlossen. Diese war sicher ein wenig schwieriger, aber Du hast es sicher geschafft. In diesem Teil beschäftigen wir uns mit etwas ganz neuem und einem Programmierkonzept. Was das ist und wie es funktioniert, wirst Du gleich nach der Lösung der Hausaufgabe erfahren.

Lösung zu Übung 5.3

Dies war sicher eine schwierige Übung, aber Du hast sie sicher gemeistert. So hier der SourceCode ohne jede weiter Erklärung. Warum? Weil Du jetzt soweit bist, dass Du aus den Bemerkungen im Code alles herauslesen kannst.

[php collapse=”true”]<?php
/******************
* Zeichenketten zerlegen
* Dateiname: uebung_5_3.php
* Funktion: Zerlegen einer Zeichenkette u. Array aufbauen
* erstellt am: 5. Juni 2009, 21:03
* Copyright: Clemens Gull
*/
//Zeichenkette erstellen
$photo["Rom"] =
"Name: Petersdom + Datum: 20.04.09 + Zeit: 10:12 + wertUng: 2 + Datei: rom_01.jpg;".
"Name: Park + Datum: 20.04.09 + Zeit: 13:40 + wertUng: 5 + Datei: rom_02.jpg;".
"Name: Moench + Datum: 21.04.09 + Zeit: 9:23 + wertUng: 7 + Datei: rom_03.jpg";
$photo["paris"] =
"Name: Louvre + Datum: 18.10.09 + Zeit: 18:03 + wErtUnG: 8 + Datei: paris_02.jpg;".
"Name: Pohtographie + Datum: 18.10.09 + Zeit: 9:17 + wErtUnG: 10 + Datei: paris_01.jpg;".
"Name: Unendlichkeit + Datum: 20.10.09 + Zeit: 12:12 + wErtUnG: 3 + Datei: paris_03.jpg;".
"Name: Triumphbogen + Datum: 19.10.09 + Zeit: 14:39 + wErtUnG: 6 + Datei: paris_04.jpg";

//neues Array anlegen
$photos = array();

//Photo-Array durchlaufen
foreach($photo as $key => $value) {
//Schluessel in normale Schreibweise bringen
$key = ucwords(strtolower($key));
//Neues Arrayelement anlegen
$photos[$key] = array();
//Zerteilen des Strings in einzelne Arrayteile
$arrPhoto = explode(";", $value);
foreach($arrPhoto as $index => $element) {
//neues Element im Array anlegen
$photos[$key][$index] = array();
//Zerteilen des Strings in einzelne Tupel (Parameter-Wert-Paar)
$arrWerte = explode(" + ", $element);
//alle einzelnen Elemente in das Array aufnehmen
foreach($arrWerte as $tupel) {
//Tupel zerteilen
$arrTupel = explode(": ", $tupel);
//Array-Element erzeugen und den Schluessel konvertieren
$photos[$key][$index][strtolower($arrTupel[0])] = $arrTupel[1];
}
}
}
//Array ausgeben
foreach($photos as $key => $array) {
//erste Ebene (Ort) ausgeben
echo "<ul><li>".$key."</li><ul>";
foreach($array as $key => $array) {
//Index des Photos ausgeben
echo "<li>Index: ".$key."</li><ul>";
foreach($array as $key => $value) {
//Einzelne Elemente des Photos ausgeben
if ($key == "wertung") {
$value = number_format($value, 1, ",", ".");
}
echo "<li><em>".$key."</em>: ".$value."</li>";
}
echo "</ul>";
}
echo "</ul></ul>";
}
?>[/php]

Ein wichtiger Teil ist abgeschlossen: Du kannst mit Variablen und Arrays umgehen, Strings verarbeiten ist auch kein Problem mehr und das treffen von Entscheidungen geht auch schon ganz gut. Du kannst auch ein paar Zeilen Code wiederholt ausführen, da Du ja die Schleifen beherrscht. Jetzt ist Dir sicher aufgefallen, dass wir in verschiedenen Übungen ganze Codeblöcke einfach kopiert haben um sie weider zu verwenden (Schau dir dazu einemal die Schleifen zur Ausgabe in der Lösung der Übung 4.6 an). Auch für dieses Programmierproblem gibt es eine Lösung und wie der Titel sagt, sind es Funktionen.

Funktionen

Den Begriff kennst Du schon. Wir haben schon die eine oder andere Funktion von php einfach benutzt, denke an strtolower(). Du kannst Dir eine Funktion als Befehl vorstellen der etwas bestimmtes macht, irgendwelche Übergabeparameter verlangt und vielleicht einen Wert zurückgibt oder auch nur etwas ausgibt. Es gibt einerseits die internen Funktionen, welche Dir php zur Verfügung stellt und die benutzerdefinierten Funktionen. Und gerade die zweiten interessieren uns, denn damit können wir viel eleganter programmieren.

Es ist absolut nicht sinnvoll SourceCode künstlich zu verlängern und redundanten Code zu schreiben. Damit ist gemeint, dass Du jeden Codeblock, den Du mehr als einmal brauchst, in eine Funktion packen sollst. Warum eigentlich? Dazu gibt es mehrere Gründe, ein paar liste ich Dir hier auf:

  • Gleichen Code an mehreren Stellen musst Du auch an allen Stellen anpassen, um Änderungen durchzuführen.
  • Fehler in einem Codeblock, kopierst Du einfach weiter.
  • Fehler in den kopierten Codeblöcken, müssen auch überall wiederholt behoben werden.
  • Redundanter Code ist schwer zu warten und zu lesen.
  • Redundanter Code ist lang und unflexibel.

Daher ist es gut mit Funktionen zu arbeiten.

Aufruf von Funktionen

Den Aufruf kennst Du eigentlich schon sehr gut. Wir arbeiten ja schon lange mit Funktionen. Die einfachen Aufrufe wie mit strtolower() sind gar kein Problem. Du kannst auch Rückgabewerte annehmen wie hier gezeigt:

[php light=”true”]$value = number_format($value, 1, ",", ".");[/php]

Und eine Verschachtelung von Funktionen ist auch kein Fremdwort mehr. Wir haben diese ja in der Hausübung verwendet:

[php light=”true”]$key = ucwords(strtolower($key));[/php]

Und das Du die Rückgabewert direkt verarbeiten kannst, kennst Du aus der Übung 2.6:

[php light=”true”]echo "Bewertung:<br />Du hast um ".
number_format($mehrVerbrauch, 3, ",", ".").
" Liter weniger verbraucht, als normal!";
[/php]

Definition einer Funktion

Viel interessanter ist die Definition. Wie erstellen wir uns eine eigene Funktion? Dies ist ganz einfach.

function

Syntax

function funktionsName ($arg1, $arg2, …, $arg#) {


}

Parameter

  • $funktionsName
    Dies ist der Name der Funktion, mit diesem wir sie später aufgerufen. Es gelten die gleichen Regeln, wie für die Variablennamen.
  • $arg#
    Diese sind die Übergabeparameter. Es sind Variablennamen, welche in der Funktion zur Verfügung stehen.

Beispiele

[php]<?php
//gibt eine Begruessung aus
function hallo1() {
echo "<h1>Hallo!</h1>";
}

//gibt eine persoenliche Begruessung aus
function hallo2($benutzer) {
echo "<h1>Hallo ".$benutzer."!</h1>";
}

//gibt eine persoenliche Begruessung aus
function hallo3($benutzer = "unbekannter Benutzer") {
echo "<h1>Hallo ".$benutzer."!</h1>";
}

//berechnet eine Summe
function calcSum($wert1, $wert2) {
$summe = $wert1 + $wert2;
return $summe;
}

echo "1. Beispiel:";
hallo1();
echo "2. Beispiel:";
hallo2("Guru");
echo "3. Beispiel (mit Parameter):";
hallo3("Guru 2.0");
echo "3. Beispiel (ohne Parameter):";
hallo3();
echo "4. Beispiel:";
echo "<p>Die Summe ist: ".calcSum(2, 5)."</p>";
?>[/php]

Du siehst an den obigen Beispielen wie unterschiedlich sich eine function präsentieren kann. Kopiere Dir den Code und probier in selber aus um die Resultate zu sehen.

Im ersten Beispiel wird nur ein Text ausgegeben. Das zweite Beispiel gibt eine Begrüßung aus und fügt einen Übergabeparameter ein. Im dritten Beispiel wird der Übergabeparameter mit einem Wert vorbelegt, falls beim Aufruf keiner übergeben wird. Und das vierte Beispiel gibt gar nichts aus, sondern berechnet die Summe und gibt sie zurück.

return

Innerhalb einer Funktion aufgerufen, beendet er diese sofort und gibt einen Wert zurück.

Syntax

return [$rueckgabeWert]

Parameter

  • $rueckgabeWert
    Diese optionale Variable enthält den Wert der zurückgegeben werden soll.

Ein Beispiel siehst Du oben, bei der Summenberechnung.

Nun müssen wir leider einen kleinen Ausflug in die Theorie machen. Es geht um Gültigkeitsbereiche von Variablen.

Gültigkeitsbereiche von Variablen

Jetzt denkst Du sicher, warum sollten Variablen ungültig werden? Das gibt es wirklich nicht jede Variable ist in jedem Programmteil bekannt. Besonders dann, wenn Du mit Funktionen arbeitest, sind mehrere Ebenen für die Variablen vorhanden. Eine global gültige Art kennst Du schon: die Konstanten. Aber Variable selbst haben verschieden Bereiche in denen sie bekannt sind.

Innerhalb einer Funktion sind nur die in ihr definierten und die übergebenen Variablen bekannt. Das heißt, sie sind lokal gültig. Dies hat den Vorteil, dass Du in größeren Projekten, die Werte in den einzelnen Variablen nicht zufällig überschreiben kannst. Genauso ist es umgekehrt. Variablen, welche außerhalb der Funktion definiert wurden, sind innerhalb nicht bekannt.

[php]<?php
$userName ="Guru";

function hallo1() {
echo "<h1>hallo1()</h1><p>Hallo ".$userName."!</p>";
}

function hallo2($benutzer = "unbekannter Benutzer") {
echo "<h1>hallo2()</h1><p>Hallo ".$benutzer."!</p>";
}

function calcSumme($wert1, $wert2) {
$summe = $wert1 + $wert2;
echo "<h1>calcSumme()</h1><p>Summe: ".$summe."!</p>";
}

function calcSumme2($wert1, $wert2) {
$summe2 = $wert1 + $wert2;
echo "<h1>calcSumme2()</h1><p>Summe: ".$summe2."!</p>";
}

hallo1();
hallo2("Guru 2.0");
hallo2($userName);
calcSumme(2, 3);
echo "Summe: ".$summe."!<br/>";
$summe2 = 17;
echo "Summe2: ".$summe2."!";
calcSumme2(2, 3);
echo "Summe2: ".$summe2."!";
?>[/php]

Schau Dir einmal die Funktionen an. Du kannst sie kopieren und ausprobieren, aber sei nicht überrascht! In hallo1() wird der Name nicht ausgegeben, da $userName nicht in der Funktion bekannt ist. Der Aufruf von hallo2() ist wie erwartet. Auch calcSumme() reagiert beim ersten Aufruf wie gewohnt. Aber Du siehst beim letzten echo-Befehl in Zeile 27, dass die Variable $summe nur in der Funktion verwendet werden kann. Ab Zeile 28 siehst Du, dass eine Variable denselben Namen haben kann, aber trotzdem zwei Werte besitzen kann. Dies ist der Gültigkeitsbereich! Außerhalb der Funktion hat $summe2 den Wert 17 und innerhalb den berechneten Wert.

Globale Variablen

Diesen Gültigkeitsbereich kannst Du auch verändern. Also Variablen von außerhalb der Funktion auch innerhalb verwenden. Umgekehrt geht es nur wenn Du mit return einen Wert zurückgibst.

global

Syntax

global $varName1, $varName2, …

Parameter

  • $varName#
    Name der globalen Variable

spiele

[php]<?php
$userName = "Guru 2.0";
//gibt eine Begruessung aus
function hallo() {
global $userName;
echo "<h1>Hallo ".$userName."!</h1>";
$userName = "Guru";
}

hallo();
echo $userName;
?>[/php]

Der Befehl global kann nur innerhalb einer Funktion vorkommen.

Wie Du im obigen Beispiel siehst, steht die Variable $userName auch in der Funktion zur Verfügung. Soweit ist es gleich wie eine Parameterübergabe im der Argumentliste einer Funktion. Aber in der letzten Zeile wird der Wert der Variablen $userName verändert und damit auch die globale Variable. Hier liegt eben der entscheidende Unterschied.

Lebensdauer von Variablen

Wieso Lebensdauer, sterben Variable leicht? Ja, wir haben das schon in einem früheren Kapitel beim Speichermanagement kennengelernt. Und jetzt – mit Funktionen – trifft uns das besonders. Global definierte Variablen leben so lange im Hauptspeicher, wie das php-Programm läuft. Aber lokal – innerhalb einer Funktion – definierte Variablen sind nur so lange im Speicher, wie die Funktion aktiv ist. Trifft der Parser auf die schließende Klammer am Ende der Funktion, verwirft er auch alle in der Funktion definierten Variablen. Probier dieses Beispiel einfach aus:

[php]<?php
for ($i = 0; $i < 20; $i++) {
echo $i.". Zeile: ".funcRekursiv()."<br/>";
}

function funcRekursiv() {
$aufruf = 0;
$aufruf++;
return $aufruf;
}
?>[/php]

Du siehst, die Zeilen werden zwar fortlaufend nummeriert, aber die Variable $aufruf wird jedes Mal neu initialisiert und hat immer den Wert 1. Wenn wir das Beispiel ein bisschen verändern, können wir dieses Initialisieren unterbinden und auch das verwerfen der Variablen $aufruf am Ende der Funktion.

[php highlight=”7″]<?php
for ($i = 0; $i < 20; $i++) {
echo $i.". Zeile: ".funcRekursiv()."<br/>";
}

function funcRekursiv() {
static $aufruf = 0;
$aufruf++;
return $aufruf;
}
?>[/php]

Die siehst in der Zeile 7 das Schlüsselwort static. Es bedeutet, falls die Variable noch nicht existiert definiere und initialisiere sie. Weiters weist es php an, die Variable so lange im Speicher – mit dem letzten Wert – zu belassen bis die Applikation beendet wird. Wenn Du das Beispiel ausprobierst, siehst Du wie auch die Variable bei jedem neuen Aufruf um eins erhöht wird.

Zusammenfassung

Diesmal gibt es auch noch eine kurze Zusammenfassung des Gelernten:

  • Funktionen sind ein Programmierkonzept um redundanten (sich wiederholenden Code) zu vermeiden.
  • Funktionen können mit oder ohne Argumente aufgerufen werden
    • Argumente können mit einem Standardwert belegt werden.
  • Funktionen können Werte mit dem Befehl return zurückgeben.
  • Funktionen schauen für den Programmierer wie neue Befehl aus.
  • Variablen
    • außerhalb der Funktion, sind innerhalb der Funktion nicht bekannt. Außer man verwendet global.
    • innerhalb der Funktion, können außerhalb nicht verwendet werden.
    • werden bei jedem Funktionsaufruf neu initialisiert. Außer man verwendet static.

Übung 6.1: Erstellen von Funktionen

Nimm die Lösung zu Übung 4.6 und ändere Sie so, dass der gesamte redundante Code in einer Funktion liegt.

In eigener Sache

Ich wünsche Dir wieder viel Erfolg bei den Übungen und auch bei der Hausübung. Ich bin gespannt wie viele mitmachen und auf die Lösung kommen. Ich werde es aber nur erfahren, wenn Du einen Kommentar eingibst. Also schreib ruhig, dass Du die Übungen machst und auch wie es Dir dabei geht. Der Kurs kann für Dich ein riesiger Erfolg werden, wenn Du mir eine Rückmeldung gibst. Denn dann kann ich die weiteren Artikel Deinen Wünschen anpassen.
Trotz meiner Vermutung, dass ich es heute nicht schaffe, gibt es trotzdem die Fortsetzung des Kurses. Morgen wirst Du dann etwas über die nächste Gruppe der Schleifen erfahren.

Information

Diese Artikelserie ist mit dem Tag phpMySQL@Kurs versehen. Damit kannst Du schnell alle Teile des Kurses finden: https://www.guru-20.info/tag/phpMySQL@Kurs

Startseite bzw. Inhaltsverzeichnis des Kurses

Blogheim.at Logo
Diese Website verwendet Cookies - nähere Informationen dazu finden Sie in unserer „Datenschutzerklärung“. Klicken Sie auf „Ich stimme zu“, um Cookies zu akzeptieren und unsere Webseite zu besuchen, oder klicken Sie auf „Cookie-Einstellungen“, um Ihre Cookies selbst zu verwalten.