Wiederverwendbarer Code in PHP

Eigene Funktionen definieren, aufrufen und nutzen

Hier lernst du

Funktionen schreiben

Du lernst, eigene Funktionen zu definieren und aufzurufen

Parameter & Return

Du verstehst, wie Funktionen Werte empfangen und zurückgeben

Scope & Sicherheit

Du kannst Code sicher organisieren und Fehler vermeiden

1. Was ist eine Funktion?

Stell dir vor, du schreibst denselben Code immer wieder an verschiedenen Stellen deines Programms. Das ist fehleranfällig und mühsam. Eine Funktion löst dieses Problem: Du schreibst einen Codeblock einmal, gibst ihm einen Namen – und kannst ihn danach beliebig oft aufrufen.

Die Kaffeemaschinen-Metapher

1. Einmal bauen

Du baust eine Kaffeemaschine (function) und programmierst, wie sie Kaffee kocht.

2. Knopf drücken

Jedes Mal wenn du Kaffee willst, drückst du einfach den Knopf – du rufst die Funktion auf.

3. Ergebnis erhalten

Die Maschine gibt dir das Ergebnis zurück – die Funktion gibt einen Rückgabewert zurück.

2. Eine eigene Funktion definieren

Eine Funktion wird mit dem Schlüsselwort function definiert. Der Name der Funktion, gefolgt von runden Klammern (), gibt an, wie sie aufgerufen wird. Alles in den geschwungenen Klammern { } ist der Inhalt der Funktion.

function begruesse ( $name ) { ... }

Schlüsselwort
Zeigt PHP: "Hier beginnt eine Funktion"

Name der Funktion
Selbst gewählt, wie ein Variablenname (ohne $)

Parameter
Eingaben, die die Funktion erwartet (optional)

<?php
// 1. DEFINIEREN: Die Funktion wird "gebaut" (läuft noch NICHT)
function begruesse($name) {
echo "Hallo, " . $name . "!";
}

// 2. AUFRUFEN: Jetzt wird die Funktion tatsächlich ausgeführt
begruesse("Anna"); // Ausgabe: Hallo, Anna!
begruesse("Max"); // Ausgabe: Hallo, Max!
begruesse("Lisa"); // Ausgabe: Hallo, Lisa!
?>

Definieren ≠ Ausführen

Die Definition mit function führt den Code nicht aus – sie legt ihn nur bereit. Der Code innerhalb der Funktion läuft erst, wenn die Funktion explizit aufgerufen wird.

3. Parameter & Standardwerte

Parameter sind Platzhalter in der Funktionsdefinition. Beim Aufruf übergibt man konkrete Argumente, die in diese Platzhalter eingesetzt werden. Man kann Parametern auch einen Standardwert geben – falls beim Aufruf kein Argument übergeben wird.

<?php
// Der Parameter $sprache hat den Standardwert "Deutsch"
function begruesse($name, $sprache = "Deutsch") {
    if ($sprache == "Englisch") {
        echo "Hello, " . $name . "!";
    } else {
        echo "Hallo, " . $name . "!";
    }
}

begruesse("Anna"); // Ausgabe: Hallo, Anna! (Standardwert wird genutzt)
begruesse("Tom", "Englisch"); // Ausgabe: Hello, Tom! (Standardwert wird überschrieben)
?>

Parameter (Definition)

Stehen in der function-Zeile. Sind Platzhalter – lokale Variablen der Funktion.

Argumente (Aufruf)

Stehen beim Funktionsaufruf. Sind die konkreten Werte, die übergeben werden.

4. Rückgabewerte mit `return`

Bisher haben unsere Funktionen nur etwas ausgegeben. Viel mächtiger ist es, wenn eine Funktion ein Ergebnis berechnet und zurückliefert. Dafür nutzen wir return. Der zurückgegebene Wert kann in einer Variable gespeichert oder direkt weiterverwendet werden.

Eingabe

$a = 15
$b = 4

Funktion

addiere()
rechnet: 15 + 4

Rückgabe

return 19

<?php
// Diese Funktion gibt kein echo aus – sie BERECHNET und GIBT ZURÜCK
function addiere($a, $b) {
$ergebnis = $a + $b;
return $ergebnis; // Hier "liefert" die Funktion ihren Wert ab
}

// Der zurückgegebene Wert wird in $summe gespeichert
$summe = addiere(15, 4);
echo "Das Ergebnis ist: " . $summe; // Ausgabe: Das Ergebnis ist: 19

// Oder direkt in einer anderen Rechnung weiterverwenden:
$doppelt = addiere(5, 5) * 2; // $doppelt = 20
?>

return beendet die Funktion sofort!

Sobald PHP auf return trifft, verlässt es die Funktion. Code, der nach return steht, wird niemals ausgeführt.

5. Gültigkeitsbereich (Variable Scope)

Variablen, die innerhalb einer Funktion erstellt werden, existieren nur dort – außerhalb sind sie unsichtbar. Das nennt man den lokalen Scope. Genauso gilt: Variablen außerhalb einer Funktion sind innerhalb standardmäßig nicht zugänglich.

Die Glas-Box-Metapher 🔲

Globaler Bereich (außen)

$name = "Anna";

$alter = 14;

Diese Variablen existieren im "Hauptprogramm".

Lokaler Bereich (Funktion)

function beispiel() {

$lokal = "Ich lebe nur hier!";

}

$lokal ist außerhalb der Funktion nicht bekannt. $name ist innerhalb nicht direkt zugänglich.

<?php
$name = "Anna"; // Globale Variable

function zeigeName() {
    // Fehler! $name ist hier nicht bekannt (falscher Scope)
    echo $name; // Gibt eine Warnung und nichts aus
}

function zeigeNameRichtig() {
    global $name; // Mit "global" holen wir die Variable in die Funktion
    echo $name; // Ausgabe: Anna
}

zeigeNameRichtig(); // Ausgabe: Anna
?>

Empfehlung: global lieber vermeiden

Die Verwendung von global kann Code schwer verständlich machen. Sauberer ist es, die Daten als Parameter zu übergeben und das Ergebnis per return zurückzuliefern.

6. Eingebaute PHP-Funktionen

PHP bringt Hunderte von fertigen Funktionen mit. Man muss das Rad nicht neu erfinden – für fast jede häufige Aufgabe gibt es bereits eine eingebaute Funktion.

String-Funktionen

<?php
$text = "Hallo Welt";

echo strlen($text); // 10 — Anzahl der Zeichen
echo strtoupper($text); // "HALLO WELT" — alles Großbuchstaben
echo strtolower($text); // "hallo welt" — alles Kleinbuchstaben
echo str_replace("Welt", "PHP", $text); // "Hallo PHP" — Ersetzen
echo substr($text, 0, 5); // "Hallo" — Teil-String extrahieren
echo trim(" leerzeichen "); // "leerzeichen" — Leerzeichen entfernen
?>

Mathematische Funktionen

<?php
echo round(4.6); // 5 — Runden
echo floor(4.9); // 4 — Abrunden
echo ceil(4.1); // 5 — Aufrunden
echo abs(-7); // 7 — Absolutwert
echo max(3, 8, 2); // 8 — Größter Wert
echo min(3, 8, 2); // 2 — Kleinster Wert
echo rand(1, 6); // z.B. 4 — Zufallszahl (wie Würfeln)
?>

Array-Funktionen

<?php
$zahlen = [5, 2, 8, 1, 9];

echo count($zahlen); // 5 — Anzahl der Elemente
sort($zahlen); // [1, 2, 5, 8, 9] — Aufsteigend sortieren
array_push($zahlen, 10); // 10 ans Ende anhängen
echo array_sum($zahlen); // Summe aller Elemente
echo in_array(8, $zahlen); // true — Prüft ob 8 im Array ist
?>

7. Jetzt bist du dran!

Übung: Notenrechner

Kombiniere alles aus diesem Skriptum: Schreibe eine Funktion, die aus einem Array von Punktzahlen den Durchschnitt berechnet – und eine zweite, die die Punktzahl in eine Notenstufe umwandelt. Im dritten Schritt verbindest du das Ganze mit einem POST-Formular.

Die vollständige Aufgabenstellung und die Lösung zum Aufdecken findest du in der zugehörigen Übungsdatei.

Cheat Sheet: Funktionen auf einen Blick

Funktion definieren

function name($param) {
return $param;
}

Funktion aufrufen

$erg = name("Wert");
echo $erg;

Standardwert (Default)

function name($p = "Standard") {
return $p;
}

Globale Variable nutzen

function name() {
global $meineVar;
echo $meineVar;
}

Dynamische Webseiten 2 | eduhigh.net | Seminarunterlagen