PHP Funktionen

6 Kernkonzepte

Die wichtigsten Konzepte für Funktionen in PHP: function · Parameter · return · anonyme Funktionen · Arrow Functions · include / require Funktionen sind das Herzstück der PHP-Programmierung. Sie ermöglichen modularen, wiederverwendbaren und wartbaren Code – von einfachen Hilfsfunktionen bis zu komplexen Klassenmethoden.

Deklaration – Funktionen definieren

function · Rückgabetyp · visibility

// Einfache Funktion function greet($name) { return "Hallo " . $name; } // Mit Rückgabetyp (PHP 7+) function add($a, $b): int { return $a + $b; }

Funktionen werden mit dem Schlüsselwort function deklariert. Sie können Parameter entgegennehmen und Werte mit return zurückgeben. Seit PHP 7 können Rückgabetypen angegeben werden.

Deklarationsvarianten

Variante	Beschreibung	Beispiel
function name()	Einfache Funktion	function sayHello() { ... }
: type	Rückgabetyp (PHP 7+)	function get(): string { ... }
public/private	Sichtbarkeit (in Klassen)	public function run() { ... }
static	Statische Methode	static function calc() { ... }

Beispiele

// Funktion ohne Rückgabewert

function logMessage($message) {

echo "[" . date("Y-m-d H:i:s") . "] " . $message . "\n";

}

// Funktion mit Rückgabetyp (strict_types)

function multiply(float $a, float $b): float {

return $a * $b;

}

// Funktion mit union type (PHP 8+)

function getValue($input): int|null {

return is_numeric($input) ? (int)$input : null;

}

Tipp: Verwenden Sie declare(strict_types=1); am Dateianfang für strikte Typ-Prüfung. Das verhindert unerwartete Typkonvertierungen.

Parameter – Argumente übergeben

Typed · Optional · Reference · Variadic

// Typed Parameter function setUser(string $name, int $age) { ... } // Optionaler Parameter function greet($name, $greeting = "Hallo") { ... } // Reference Parameter function increment(&$value) { $value++; }

Parameter sind die Eingabewerte einer Funktion. PHP unterstützt typisierte Parameter (seit PHP 7), optionale Parameter mit Default-Werten, Referenzparameter (&) und variadische Parameter (...).

Beispiele

// Typisierte Parameter

function createUser(string $username, int $age, bool $active = true) {

// Implementierung

}

// Referenzparameter (verändert Original)

function addToArray(&$array, $value) {

$array[] = $value;

}

$list = [1, 2];

addToArray($list, 3); // $list ist jetzt [1, 2, 3]

// Variadische Parameter (PHP 5.6+)

function sum(...$numbers) {

return array_sum($numbers);

}

echo sum(1, 2, 3, 4); // 10

// Named Arguments (PHP 8+)

function createPost(string $title, string $content, bool $published = false) { ... }

createPost(published: true, title: "Mein Artikel", content: "Inhalt...");

Tipp: Verwenden Sie Typed Parameters für mehr Sicherheit und bessere IDE-Unterstützung. Named Arguments (PHP 8+) verbessern die Lesbarkeit bei vielen Parametern.

Rückgabewerte – Ergebnisse zurückgeben

return · void · mixed · never

// Mit Rückgabetyp function getConfig(): array { return ['debug' => true]; } // void (kein Rückgabewert, PHP 7.1+) function log($msg): void { echo $msg; }

Rückgabewerte werden mit return zurückgegeben. Seit PHP 7 können Rückgabetypen deklariert werden – void für keine Rückgabe, never für Funktionen, die nie zurückkehren (PHP 8.1+).

Beispiele

// Verschiedene Rückgabetypen

function getUser($id): array|null {

return $id > 0 ? ['id' => $id] : null;

}

// mixed (PHP 8+) – jeder Typ erlaubt

function getData(): mixed {

return rand(0, 1) ? "string" : 42;

}

// never (PHP 8.1+) – Funktion kehrt nie zurück

function exitWithError($message): never {

die($message);

}

// Null-Coalescing mit Rückgabewert

function getValue($input): string {

return $input ?? "Standard";

}

Tipp: Deklarieren Sie immer den Rückgabetyp – das verbessert die Lesbarkeit und hilft dem Compiler bei Optimierungen. void ist der richtige Typ für Funktionen ohne return.

Anonyme Funktionen – Closures & Arrow Functions

function() · use · fn() =>

// Anonyme Funktion (Closure) $greet = function($name) { return "Hallo " . $name; }; // Arrow Function (PHP 7.4+) $multiply = fn($a, $b) => $a * $b;

Anonyme Funktionen (Closures) sind Funktionen ohne Namen. Arrow Functions (PHP 7.4+) sind eine kompakte Schreibweise für einfache Funktionen mit automatischem Zugriff auf äußere Variablen.

Beispiele

// Closure mit use (Variable von außen)

$factor = 2;

$double = function($x) use ($factor) {

return $x * $factor;

};

echo $double(5); // 10

// Arrow Function (automatischer Zugriff)

$multiply = fn($a, $b) => $a * $b;

echo $multiply(3, 4); // 12

// Arrow Function mit äußerer Variable

$factor = 3;

$triple = fn($x) => $x * $factor; // $factor wird automatisch eingefangen

echo $triple(5); // 15

// Closure als Callback (array_map)

$numbers = [1, 2, 3];

$squared = array_map(function($n) { return $n * $n; }, $numbers);

echo print_r($squared, true); // [1, 4, 9]

Tipp: Arrow Functions sind ideal für einfache Callbacks (z.B. array_map). Closures mit use sind notwendig, wenn Sie auf Variablen zugreifen und diese möglicherweise verändern möchten.

Variable Funktionen – Callbacks & Dynamik

call_user_func · $function() · is_callable

// Variable Funktion $func = 'strtoupper'; echo $func("hallo"); // "HALLO" // call_user_func $result = call_user_func('strlen', "Test"); // 4

Variable Funktionen ermöglichen den Aufruf von Funktionen mit variablen Namen. call_user_func und call_user_func_array sind alternative Wege, um Funktionen dynamisch aufzurufen.

Beispiele

// Variable Funktion

function sayHello() { return "Hallo"; }

function sayGoodbye() { return "Auf Wiedersehen"; }

$action = 'sayHello';

echo $action(); // "Hallo"

// call_user_func mit Parameter

$result = call_user_func('strpos', "Hallo Welt", "Welt"); // 6

// call_user_func_array mit Array

$params = ["Hallo Welt", "Welt"];

$result = call_user_func_array('strpos', $params); // 6

// is_callable Prüfung

if (is_callable($action)) {

echo $action();

}

// Methoden als Callback (Array)

$obj = new MyClass();

$result = call_user_func([$obj, 'method'], 'param');

Tipp: Verwenden Sie is_callable(), bevor Sie eine variable Funktion aufrufen, um Fehler zu vermeiden. call_user_func_array ist nützlich, wenn Sie eine variable Anzahl von Parametern haben.

Include / Require – Dateien einbinden

include · require · include_once · require_once

// Datei einbinden include 'config.php'; require 'functions.php'; // Nur einmal einbinden include_once 'db.php'; require_once 'config.php';

include und require binden externe Dateien ein. require führt bei Fehler zu einem fatalen Fehler (Script stoppt), include gibt nur eine Warnung aus. Die _once-Varianten verhindern mehrfaches Einbinden.

Beispiele

// config.php

<?php

$dbHost = 'localhost';

$dbUser = 'root';

// index.php

require_once 'config.php';

echo $dbHost; // 'localhost'

// Mit Pfad (__DIR__ für aktuelles Verzeichnis)

require_once __DIR__ . '/lib/functions.php';

// Include mit Fehlerunterdrückung (@)

@include 'optional.php'; // Unterdrückt Warnung

// Prüfen ob Datei existiert

if (file_exists('config.php')) {

require_once 'config.php';

} else {

die('Konfigurationsdatei fehlt!');

}

Tipp: Verwenden Sie require_once für wichtige Dateien (Konfiguration, Funktionen) und include_once für optionale Dateien. __DIR__ sorgt für absolute Pfade und verhindert Probleme mit relativen Pfaden.

PHP Funktionen im Überblick

function Funktion deklarieren
return · Typ

Parameter Argumente übergeben
Typed · Optional · Referenz

return Wert zurückgeben
void · mixed · never

Closure Anonyme Funktion
use · fn() =>

callable Callback-Funktionen
is_callable

include Dateien einbinden
require · _once

Quick Summary

function

Deklaration

Parameter

Argumente

return

Rückgabe

fn()

Arrow Function

callable

Callbacks

include

Einbinden

function greet(string $name): string { return "Hallo $name"; } · include_once 'config.php';