Grundlagen und Methoden zum Einbinden von Dateien in PHP über include

Sie befinden sich: Home > Php > Grundlagen und Methoden zum Einbinden von Dateien in PHP über include

Wenn Sie eine Website mit PHP erstellen, ist es oft nötig, dass Sie Code aus anderen Dateien einbinden. Das macht Ihre Webseite übersichtlicher und einfacher zu verwalten. Das PHP-Kommando include hilft Ihnen dabei. Es erlaubt Ihnen, den Inhalt einer Programmdatei in eine andere einzufügen.

Stellen Sie sich vor, Sie haben eine Webseite, die aus vielen Teilen wie dem Kopf (Header), dem Fuß (Footer) und einem Menü besteht. Sie möchten nicht den gleichen Code auf jeder Seite wiederholen. Hier kommt include ins Spiel. Sie schreiben den Code für den Kopf, das Menü und den Fuß nur einmal in separaten Dokument und binden diese dann in Ihre Hauptseite ein.

Beispiel:
Nehmen wir an, Sie haben eine Programmdatei namens header.php, die den oberen Teil Ihrer Webseite enthält, also den Seitenkopf. In Ihrer Hauptdatei, zum Beispiel index.php, können Sie header.php ganz einfach einbinden:

<?php include 'header.php'; ?>

Mit diesem Befehl wird PHP die Datei suchen und ihren Inhalt dort einfügen, wo Sie den include Befehl platziert haben. Wenn diese unter anderem Ihren Website-Titel und Ihr Logo enthält, erscheinen diese Elemente auf jeder Seite, die header.php einbindet.

Erweiterte Nutzung:
Was, wenn Sie nicht nur eine, sondern mehrere Programmdateien integrieren möchten? Kein Problem! Sie können include mehrmals verwenden:

<?php
include 'header.php';
include 'menu.php';
include 'footer.php';
?>

Hier binden Sie drei Teile ein: Kopf, Menü und Fuß. Jede dieser Programmdateien enthält spezifischen Code, der auf jeder Seite Ihrer Webseite wiederkehrt.

Was ist include_once?
Manchmal möchten Sie sicherstellen, dass ein Dokument nur einmal eingefügt wird, auch wenn sie versehentlich mehrfach aufgerufen wird. Hierfür gibt es include_once. Dieses Kommando funktioniert wie include, stellt aber sicher, dass das Skript nur ein einziges Mal eingefügt wird.

Beispiel:

<?php
include_once 'header.php';
include_once 'menu.php';
?>

Wenn header.php bereits durch include_once integriert wurde, ignoriert PHP weitere include_once Aufrufe für dieselbe Datei.

Tipps zum Auslagern:
Denken Sie daran, Ihre Dateien logisch zu organisieren. Lagern Sie wiederkehrende Elemente in eigene Dateien aus. Das macht Ihre Webseite leicht zu aktualisieren und zu warten.

Das Einbinden von PHP-Dateien ist also ein starkes Werkzeug, um Ihre Webseiten effizient und leicht verwaltbar zu gestalten. Nutzen Sie es, um Ihre Arbeit zu vereinfachen und Ihre Webseiten schnell zu aktualisieren.

Technische Details und Fehlerbehandlung beim Einbinden von Dateien mit der PHP Funktion include

Beim Inkludieren von Programmdateien in PHP gibt es einige technische Details und häufige Fehlerquellen, die Sie kennen sollten. Dies hilft Ihnen, Ihre Webseite effizienter zu gestalten und Fehler zu vermeiden.

Verwendung von include und require:
Es gibt zwei Hauptbefehle zum Einbinden von Skript-Dateien: include und require. Der Unterschied liegt in der Behandlung von Fehlern. include erzeugt eine Warnung, wenn die Datei nicht gefunden wird, aber das Skript läuft weiter. require hingegen stoppt das Skript mit einem fatalen Fehler, wenn die Datei fehlt. Dies ist nützlich, wenn das Fehlen der Datei die gesamte Webseite unbrauchbar macht.

Beispiel für require:
Angenommen, Ihre Webseite benötigt eine Datei config.php, die wichtige Einstellungen enthält. Wenn diese Datei fehlt, sollte die Webseite nicht weiterlaufen. Hier verwenden Sie:

<?php require 'config.php'; ?>

Wenn config.php nicht vorhanden ist, stoppt PHP die Ausführung und zeigt einen Fehler an. Dies verhindert, dass die Webseite mit unvollständigen Einstellungen läuft.

Pfade richtig setzen:
Ein häufiges Problem beim Einbinden von Programmdateien ist der Datei-Pfad. Wenn Sie relative Datei-Pfade verwenden, bezieht sich PHP auf das aktuelle Verzeichnis des Skripts, das ausgeführt wird. Dies kann zu Fehlern führen, wenn das Skript von einem anderen Ort aus aufgerufen wird. Um das zu vermeiden, verwenden Sie absoluten Datei-Pfade oder setzen Sie den include_path in der Datei php.ini oder mittels der Funktion set_include_path().

Beispiel für Pfade setzen:
Stellen Sie sich vor, Sie haben eine Dateistruktur, wo header.php im Ordner includes liegt. Sie können den Datei-Pfad absolut setzen, indem Sie voran den vollständigen Pfad angeben:

<?php include $_SERVER['DOCUMENT_ROOT'] . '/includes/header.php'; ?>

Hier nutzen das Skript die Server Variable $_SERVER. In dieser ist ein Array gespeichert. In diesem ist der Key DOCUMENT_ROOT vorhanden zum Wurzelverzeichnis Ihrer Website führt. So findet PHP die Datei, egal von wo das Skript aufgerufen wird.

Sicherheitshinweise für include:
Beim Einbinden von Dateien mit include und require sollten Sie wichtige Sicherheitsaspekte beachten:

• Niemals Benutzereingaben sichekt verwenden: Benutzereingaben dürfen niemals ungeprüft in include-Anweisungen verwendet werden, da dies zu Remote File Inclusion (RFI) führen kann.
• Gefährlich:

  include $_GET['file']; // NIEMALS SO MACHEN!

• Sicherer:

  // Definierte Dateien in einem Array erlauben
  $erlaubte_dateien = ['header', 'footer', 'sidebar'];
  $file = $_GET['section'] ?? '';
  
  if (in_array($file, $erlaubte_dateien)) {
      include 'templates/' . $file . '.php';
  } else {
      // Standardseite oder Fehlerseite laden
  }

• Schutz sensibler Dateien: Legen Sie Dateien mit sensiblen Informationen (wie Datenbank-Zugangsdaten) außerhalb des öffentlich zugänglichen Webroot-Verzeichnisses ab.

Umgang mit htaccess:
Sie können auch die .htaccess-Datei nutzen, um den include path bei Ihrem Webserver zu setzen. Dies ist besonders nützlich, wenn Sie auf die php.ini-Datei keinen Zugriff haben. In der .htaccess-Datei könnten Sie folgendes hinzufügen:

php_value include_path ".:/usr/local/lib/php:/mein/eigener/pfad"

Durch diese Zeile fügt PHP den angegebenen Datei-Pfad zu den Orten hinzu, an denen es nach einzubindenden Dateien sucht.

Fehlerunterdrückung mit dem @-Operator:
In manchen Fällen möchten Sie Fehlermeldungen unterdrücken, die beim Einbinden von Dateien auftreten können. Dafür können Sie den @-Operator vor include oder require setzen:

<?php
@include 'config.php'; /* Unterdrückt Warnungen, wenn die Datei nicht gefunden wird */
@require 'wichtige_datei.php'; /* Unterdrückt die Warnung, es wird dennoch ein fataler Fehler ausgelöst */
?>

Beachten Sie: Der @-Operator sollte sparsam eingesetzen werden, da er Fehler versteckt, die eigentlich behoben werden sollten. In Produktivumgebungen kann dies jedoch nützlich sein, um dem Benutzer keine Fehlermeldungen anzuzeigen.

Behandlung von Datei nicht gefunden-Fehlern:
Wenn eine Datei nicht gefunden wird, gibt PHP standardmäßig eine Warnung aus. Sie können diese Warnungen abfangen und eine benutzerfreundlichere Nachricht anzeigen lassen. Dies erreichen Sie durch eine eigene Fehlerbehandlung mit file_exists():

<?php
if (file_exists('important.php')) {
    include 'important.php';
} else {
    echo 'Die benötigte Datei ist nicht verfügbar.';
}
?>

Hier prüft das PHP-Skript, ob die File existiert, bevor sie integriert wird. Das vermeidet Fehlermeldungen und macht Ihre Webseite professioneller.

Relative vs. Absolute Pfade:
Bei der Verwendung von include oder require ist es wichtig, zu verstehen, wie Pfade interpretiert werden:

/* Relative Pfade (ausgehend vom aktuellen Verzeichnis) */
/* Sucht im Unterordner "inc" des aktuellen Verzeichnisses */
include 'inc/header.php';

/* Geht eine Ebene nach oben und dann in den Ordner "config" */
include '../config/settings.php';

/* Absolute Pfade (vom Stammverzeichnis des Servers ausgehend) */
/* Vollständiger Serverpfad */
include '/var/www/html/includes/functions.php';
/* Webroot-basierter Pfad */
include $_SERVER['DOCUMENT_ROOT'] . '/includes/nav.php';

In komplexen Projekten empfiehlt es sich, Konstanten für Ihre Basis-Pfade zu definieren:

// In einer zentralen Konfigurationsdatei
define('BASE_PATH', dirname(__FILE__));
define('INCLUDE_PATH', BASE_PATH . '/includes');

// Spätere Verwendung
include INCLUDE_PATH . '/header.php';

Diese Techniken helfen Ihnen, häufige Fehler beim Eingefügen von Dateien zu vermeiden und Ihre Webseite sicher und zuverlässig zu gestalten. Nutzen Sie sie, um Probleme proaktiv zu lösen und Ihre Webprojekte erfolgreich umzusetzen.

Wartung und Management von eingebundenen Dateien

Die Wartung und das Management von inkludierten Dateien in PHP sind wesentlich, um Ihre Webseite aktuell und funktional zu halten. Das Verwalten dieser Dateien erfordert ein systematisches Vorgehen, besonders wenn Ihre Webseite wächst und sich entwickelt.

Aktualisieren von eingebundenen Dateien:
Aktualisieren Sie regelmäßig Ihre inkludierten Dateien wie CSS oder HTML-Dokumente. Das stellt sicher, dass Ihre Webseite modern bleibt und neue Webstandards erfüllt. Zum Beispiel, wenn Sie ein neues Design-Element einführen wollen, aktualisieren Sie die CSS-Datei und binden diese dann in Ihre PHP-Seiten ein.

Beispiel für das Aktualisieren einer CSS-Datei:
Nehmen wir an, Sie möchten die Farbe der Überschriften auf Ihrer Webseite ändern. Sie öffnen Ihre CSS-Datei und fügen folgenden Code hinzu:

h1 {
    color: blue;
}

Speichern Sie die Datei und binden den HTML Code in Ihre PHP-Seiten ein:

<link rel="stylesheet" type="text/css" href="styles.css">

Mit dieser Änderung haben alle Überschriften auf den Seiten, die diese CSS-Datei einarbeiten, nun die Farbe Blau.

Verwalten von Pfaden:
Ein korrekter Dokument-Pfad ist entscheidend für das reibungslose Einfügen von Dateien. Verwenden Sie relative oder absolute Pfade, um sicherzustellen, dass PHP die Dateien korrekt findet. Bei vielen Seiten ist es ratsam, einen zentralen Ordner für alle integrierten Dateien zu nutzen.

Beispiel für Pfadverwaltung:
Wenn Sie eine Datei config.php haben, die wichtige Konfigurationen enthält, stellen Sie sicher, dass der Datei-Pfad richtig gesetzen ist. Wenn die Datei im Ordner config liegt, könnten Sie folgenden PHP-Befehl verwenden:

require_once($_SERVER['DOCUMENT_ROOT'] . '/config/config.php');

Dieser Befehl bindet die config.php sicher ein, unabhängig davon, von welchem Skript er aufgerufen wird.

Wiederkehrende Elemente einfügen:
Um Ihre Webseite konsistent und leicht zu verwalten zu machen, verwenden Sie wiederkehrende Elemente wie Webseitenkopf, Webseitenfuß oder Menüs. Diese Elemente in separate Dateien auszulagern und sie auf verschiedenen Seiten einzubetten, macht Updates einfach und schnell.

Beispiel für das Einfügen eines Headers:
Erstellen Sie eine Datei header.php, die den oberen Teil Ihrer Webseite enthält. Um diesen Seitenkopf in Ihrer Hauptseite index.php zu verwenden, schreiben Sie:

<?php include 'header.php'; ?>

Jedes Mal, wenn Sie den Seitenkopf aktualisieren, wird die Änderung auf allen Seiten sichtbar, wo Sie die header.php eingebaut haben.

Häufige Fehler vermeiden:
Stellen Sie sicher, dass alle Dateien auf Ihrer Webseite vorhanden sind. Fehlende Dateien können zu Fehlern führen, die die Funktionalität Ihrer Seite beeinträchtigen. Prüfen Sie die Pfade und die Verfügbarkeit der Dateien regelmäßig.

Performance und Best Practices

Die Verwendung von include kann Auswirkungen auf die Performance Ihrer Website haben. Hier einige Best Practices:

• Zwischenspeicherung (Caching): Bei komplexen Websites mit vielen includes sollten Sie Caching-Mechanismen wie OPCache verwenden, um die Leistung zu verbessern.
• Vermeiden Sie unnötige includes: Binden Sie nur die Dateien ein, die tatsächlich benötigt werden. Zu viele includes können die Ladezeit verlängern.
• Verwenden Sie include_once/require_once mit Bedacht: Diese Funktionen prüfen, ob die Datei bereits eingebunden wurde, was bei vielen Dateien zu Leistungseinbußen führen kann.
• Autoloading statt manuellem Einbinden: Für komplexe Anwendungen und Klassen verwenden Sie PSR-4-konformes Autoloading anstelle von manuellen includes.

Beispiel für einen einfachen Autoloader:

<?php
spl_autoload_register(function ($class_name) {
    // Wandelt Namespaces in Verzeichnispfade um
    $class_file = str_replace('\\', '/', $class_name) . '.php';
    $file = __DIR__ . '/classes/' . $class_file;

    if (file_exists($file)) {
        require_once $file;
        return true;
    }
    return false;
});

/* Jetzt kann die Klasse direkt verwendet werden, ohne sie explizit einzubinden */
$myObject = new App\Models\User();
?>

Durch diese Praktiken stellen Sie sicher, dass Ihre Webseite effizient verwaltet wird und Sie schnell auf Änderungen reagieren können. Dies spart Zeit und verhindert Probleme, die beim Betrieb Ihrer Website auftreten könnten.

Komplettes Beispiel: Modularisierung einer Website mit Include

Um die Vorteile der Modularisierung mit Include besser zu verstehen, betrachten wir ein praktisches Beispiel einer modularen Website-Struktur:

Projektstruktur:

website/
├── index.php
├── kontakt.php
├── produkte.php
├── includes/
│   ├── config.php
│   ├── functions.php
│   ├── header.php
│   ├── footer.php
│   ├── navigation.php
│   └── sidebar.php
└── assets/
    ├── css/
    ├── js/
    └── images/

config.php: Enthält die grundlegenden Einstellungen

<?php
// Datenbank-Konfiguration
define('DB_HOST', 'localhost');
define('DB_USER', 'username');
define('DB_PASS', 'password');
define('DB_NAME', 'dbname');

// Website-Informationen
define('SITE_TITLE', 'Meine Webseite');
define('SITE_URL', 'https://www.meine-webseite.de');

// Pfad-Konfigurationen
define('ROOT_PATH', dirname(__DIR__));
define('INCLUDES_PATH', ROOT_PATH . '/includes');
define('ASSETS_PATH', ROOT_PATH . '/assets');
?>

index.php: Die Hauptseite, die die modularen Komponenten einbindet

<?php
// Konfiguration einbinden
require_once 'includes/config.php';
require_once 'includes/functions.php';

// Seitentitel für dieses Dokument
$page_title = 'Startseite';
$meta_description = 'Willkommen auf unserer Webseite!';

/* Header einbinden (enthält den Beginn des HTML-Dokuments) */
include 'includes/header.php';

// Navigation einbinden
include 'includes/navigation.php';
?>

<main class="content">
    <section class="main-content">
        <h1>Willkommen auf unserer Webseite</h1>
        <p>Dies ist der Hauptinhalt der Startseite.</p>
    </section>

    <?php include 'includes/sidebar.php'; ?>
</main>

<?php
/* Footer einbinden (enthält das Ende des HTML-Dokuments) */
include 'includes/footer.php';
?>

Dieses Beispiel zeigt, wie Sie mit includes eine übersichtliche, wartbare Website-Struktur aufbauen können. Jede Komponente ist in eine separate Datei ausgelagert, was die Entwicklung und Aktualisierung deutlich vereinfacht.

Zusammenfassung: Include in PHP

Das Einbinden von Dateien mit PHP ist ein wesentlicher Bestandteil der Webentwicklung und bietet zahlreiche Vorteile:

• Verbesserte Codeorganisation durch die Aufteilung in logische Module
• Erhöhte Wartbarkeit, da Änderungen nur an einer Stellen Sie vorgenommen werden müssen
• Bessere Wiederverwendbarkeit von Code-Komponenten in verschiedenen Projekten
• Möglichkeit zur Modularisierung von Projekten, wodurch komplexe Anwendungen überschaubarer werden

Vergessen Sie nicht, die wichtigsten Regeln zu beachten:

1. Verwenden Sie require, wenn die Datei essentiell für Ihre Anwendung ist
2. Nutzen Sie include, wenn die Anwendung auch ohne die Datei weiter funktionieren kann
3. Setzen Sie include_once oder require_once ein, wenn Sie sicherstellen müssen, dass eine Datei nur einmal eingebunden wird
4. Achten Sie auf sichere Pfadangaben und vermeiden Sie dynamische Einbindung von nicht überprüften Dateien
5. Organisieren Sie Ihre Dateien in einer logischen Struktur, die die Wartung erleichtert

Mit diesem Wissen sind Sie nun bestens gerüstet, um PHP-Dateien effektiv einzubinden und modulare, wartbare Webanwendungen zu entwickeln.

include, require, include_once und require_once im sichekten Vergleich

Auf den ersten Blick wirken die vier Anweisungen austauschbar, denn sie alle binden eine externe PHP-Datei in Ihr laufendes Skript ein. Beim genauen Hinsehen unterscheiden sie sich aber in zwei wichtigen Achsen, und genau diese beiden Achsen entscheiden über das Verhalten Ihrer Anwendung im Fehlerfall. Die erste Achse ist die Schwere des Fehlers, wenn die Datei nicht gefunden wird. Die zweite Achse ist die Frage, ob PHP die Datei mehrfach einbinden darf oder nicht.

Die Faustregel ist nicht kompliziert. Wenn ein Fehlen der Datei die Anwendung unbrauchbar macht, gehoert ein require hin. Wenn die Datei optional ist und das Skript ohne sie weiterlaufen darf, ist include die richtige Wahl. Die _once-Varianten brauchen Sie nur dort, wo dieselbe Datei aus mehreren Stellen heraus geladen werden könnte und ein doppeltes Einbinden zu Fehlern wie "Cannot redeclare function" oder "Cannot redeclare class" führen würde.

Warum require_once heute meistens vermeidbar ist

In aelteren PHP-Projekten sehen Sie oft Bootstrap-Dateien mit dutzenden require_once-Aufrufen, die jede Klassen-Datei einzeln aufzählen. Das funktioniert, hat aber drei spuerbare Nachteile. Erstens kostet jedes require_once einen Stat-Call und einen Lookup im internen Hash der bereits geladenen Dateien. Zweitens muss die Liste der Includes manuell gepflegt werden, was bei jedem neuen Datei-Hinzufuegen zu Aufwand führt. Drittens kennt PHP keine Reihenfolge-Optimierung, Sie müssen also selbst dafuer sorgen, dass Basis-Klassen vor ihren Erben geladen werden.

Die moderne Loesung heißt Autoloading. Statt jede Datei einzeln einzubinden, registrieren Sie eine Funktion, die PHP automatisch aufruft, sobald eine unbekannte Klasse referenziert wird. PHP bringt dafuer spl_autoload_register mit. Damit verschwinden die require_once-Listen komplett, Ihr Bootstrap wird kürzer und die Performance steigt, weil nur tatsaechlich verwendete Klassen geladen werden. Für reale Projekte übernimmt diese Aufgabe der Composer-Autoloader.

Pfade sicher aufloesen mit __DIR__

Eine der häufigsten Stolperfallen mit include sind relative Pfade. PHP lösen relative Pfade nicht relativ zur Datei auf, in der das include steht, sondern relativ zum Working Sichectory des aktuellen Prozesses. Wenn Ihr Skript per Cron, über eine andere Datei oder aus einem anderen Verzeichnis heraus aufgerufen wird, verschiebt sich das Working Sichectory und Ihr include 'config.php' findet plötzlich nichts mehr. Die saubere Loesung ist die magische Konstante __DIR__. Sie liefert immer das Verzeichnis der aktuellen Datei, unabhaengig davon, wer die Datei eingebunden hat.

<?php
declare(strict_types=1);

/* Falsch: relativer Pfad bricht, wenn das Working Directory wechselt. */
include 'config/database.php';

/* Richtig: __DIR__ liefert das Verzeichnis dieser Datei. */
require __DIR__ . '/config/database.php';

/* Auch fuer Eltern-Verzeichnisse zuverlaessig. */
require __DIR__ . '/../vendor/autoload.php';

/* Konstante fuer den Projekt-Root einmal definieren und ueberall nutzen. */
define('PROJECT_ROOT', __DIR__);
require PROJECT_ROOT . '/src/Bootstrap.php';

Machen Sie es sich zur Gewohnheit, jeden include oder require mit __DIR__ zu beginnen. Sie sparen sich damit eine ganze Klasse von Bugs, die schwer zu reproduzieren sind, weil sie nur in bestimmten Aufrufkontexten auftreten.

include_path und seine Sicherheits-Implikationen

PHP kennt eine globale Konfigurationssichektive namens include_path. Sie funktioniert aehnlich wie die PATH-Variable im Shell und listet Verzeichnisse auf, in denen PHP nach Include-Dateien sucht, wenn ein relativer Pfad angegeben wird. Auf den ersten Blick ist das praktisch, denn Sie können Bibliotheks-Verzeichnisse einmal eintragen und sich danach um nichts mehr kuemmern. In modernen Projekten ist include_path aber eine Quelle von Verwirrung und sollte nur in Ausnahmefaellen verwendet werden.

Das eigentliche Problem ist die Sicherheit. Wenn Sie Pfade aus User-Eingaben in include oder require hineinreichst, öffnen Sie Tür und Tor für Local File Inclusion, kurz LFI. Ein Angreifer kann dann gezielt Dateien wie ../../../etc/passwd einbinden oder eigene PHP-Dateien aus dem Upload-Ordner ausführen lassen. Validiere User-Eingaben deshalb immer, bevor sie in einen Include-Pfad fliessen, am besten mit einer expliziten Whitelist statt mit Filter-Funktionen wie filter_var.

<?php
declare(strict_types=1);

/* GEFAEHRLICH: User-Input direkt in include. */
$page = $_GET['page'] ?? 'home';
include __DIR__ . '/pages/' . $page . '.php'; /* LFI moeglich */

/* SICHER: Whitelist erlaubter Werte. */
$erlaubt = ['home', 'about', 'contact', 'impressum'];
$page    = $_GET['page'] ?? 'home';

if (!in_array($page, $erlaubt, true)) {
    $page = 'home';
}

include __DIR__ . '/pages/' . $page . '.php';

Merke sich die Regel: Wenn ein Wert aus einem Request stammt, gehoert er nicht ungeprueft in einen Datei-Pfad. Auch basename und realpath alleine reichen nicht aus, weil ein Angreifer sehr kreativ werden kann. Eine harte Whitelist ist die einzige Variante, die Sie vertretbar finden wirst, wenn Sie sich nachts Ihren Server-Log anschauen.

Templates sauber per include trennen

Eine der elegantesten Anwendungen von include ist die Trennung von Logik und Präsentation. Sie bauen Ihre Daten in einer Controller-Datei zusammen und übergeben sie per einfachem Variablen-Scope an ein Template, das nur noch für die Ausgabe zustaendig ist. Die Variablen aus der einbindenden Datei sind im Template sichekt verfügbar, denn include teilt sich den Scope mit der aufrufenden Datei.

<?php
/* controller.php */
declare(strict_types=1);

$titel    = 'Willkommen';
$benutzer = 'Anna';
$artikel  = [
    ['titel' => 'Erster Beitrag', 'datum' => '2026-05-01'],
    ['titel' => 'Zweiter Beitrag', 'datum' => '2026-05-08'],
];

include __DIR__ . '/templates/seite.php';

Wichtig ist, dass Ihr Template nur Daten ausgibt und keine Datenbank-Aufrufe oder Geschaefts-Logik enthält. Dann können Sie die Datei jederzeit gegen eine andere Variante austauschen, etwa für eine alternative Ansicht oder eine andere Sprache.

Composer-Autoloader: ein require, alles drin

Wenn Sie Composer verwenden, ersetzen eine einzige Zeile alle require_once-Listen, die Ihr Projekt jemals haben wird. Composer generiert beim composer install oder composer update die Datei vendor/autoload.php. Sobald Sie diese eine Datei einbindest, sind alle Ihre Klassen, alle Ihre Bibliotheken und alle Dependencies sofort verfügbar, ohne dass Sie eine einzige Datei manuell laden müssen.

<?php
declare(strict_types=1);

/* index.php oder ein zentrales bootstrap.php */

require __DIR__ . '/vendor/autoload.php';

/* Eigene Klassen aus src/ und alle Composer-Pakete sind ab hier verfuegbar. */
use App\Service\UserService;

$service = new UserService();

Composer optimiert beim Deployment den Autoloader sogar in eine Classmap, mit der jede Klasse in einem einzigen Hash-Lookup gefunden wird. Schneller geht es nicht. Wenn Sie heute ein neues Projekt aufsetzen, sollte require __DIR__ . '/vendor/autoload.php' der einzige Include in Ihrem Bootstrap sein.

Entscheidungsbaum: welche Anweisung passt wann

Die folgende kleine Grafik fasst die Auswahllogik in eine einzige Frage-Sequenz zusammen. Wenn Sie im Code stehst und kurz zweifelst, gehen Sie den Baum von oben nach unten durch und triffst in zwei Schritten die richtige Entscheidung.

flowchart TD
    A[Datei einbinden] --> B{Datei kritisch?}
    B -- Ja --> C{Mehrfach moeglich?}
    B -- Nein --> D{Mehrfach moeglich?}
    C -- Ja --> E[require_once]
    C -- Nein --> F[require]
    D -- Ja --> G[include_once]
    D -- Nein --> H[include]

Im Alltag landest Sie in den meisten Faellen bei require, denn ein fehlendes Bootstrap-File oder eine fehlende Konfig sind in aller Regel echte Stoerungen, die das Skript nicht weiter laufen lassen sollten. include bleibt für Templates und optionale Erweiterungen reserviert.

Praxisbeispiel: Konfig laden und Template einbinden

Zum Abschluss ein kleines, aber realistisches Setup, das die Konzepte aus diesem Artikel zusammenbringt. Sie haben eine zentrale Konfiguration, einen Composer-Autoloader und mehrere Templates. Der Bootstrap baut die Anwendung zusammen, der Controller laedt Daten und das Template übernimmt nur die Ausgabe.

<?php
/* config/database.php */
declare(strict_types=1);

return [
    'host'     => getenv('DB_HOST') ?: 'localhost',
    'database' => getenv('DB_NAME') ?: 'app',
    'user'     => getenv('DB_USER') ?: 'root',
    'pass'     => getenv('DB_PASS') ?: '',
];

<?php
/* public/index.php (der Einstiegspunkt) */
declare(strict_types=1);

/* 1. Composer-Autoloader fuer alle Klassen. */
require __DIR__ . '/../vendor/autoload.php';

/* 2. Konfiguration als Array zurueckgeben (return-Pattern). */
$config = require __DIR__ . '/../config/database.php';

$dsn = "mysql:host={$config['host']};dbname={$config['database']};charset=utf8mb4";
$pdo = new PDO($dsn, $config['user'], $config['pass'], [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
]);

$stmt    = $pdo->query('SELECT id, titel, datum FROM artikel ORDER BY datum DESC LIMIT 10');
$artikel = $stmt->fetchAll(PDO::FETCH_ASSOC);

$titel = 'Aktuelle Artikel';
include __DIR__ . '/../templates/artikel-liste.php';

Auffaellig sind drei Punkte. Erstens nutzen der Code konsequent __DIR__, der Einstiegspunkt funktioniert deshalb auch dann, wenn er aus einem CLI-Cron oder einem anderen Verzeichnis heraus aufgerufen wird. Zweitens verwendet die Konfig-Datei das return-Pattern, bei dem ein require sichekt ein Array zurueckliefert. Damit verschmutzt die Konfig den globalen Scope nicht. Drittens übernimmt Composer das Laden aller Klassen, sodass im gesamten Skript nur drei Includes stehen: ein Autoloader, eine Konfiguration und ein Template.