--- title: 'PHP-Grundlagen & globale Variablen: Gültigkeitsbereich & Superglobale | DevSense' description: 'Ein umfassender Leitfaden zu PHP-Variablen-Gültigkeitsbereichen (lokal, global, statisch) und allen Superglobalen. Erfahren Sie Best Practices, Sicherheitsfallen und PHP 8.1+ Einschränkungen.' faq: - { question: 'Was ist der Unterschied zwischen lokalen, globalen und statischen Variablen-Gültigkeitsbereichen in PHP?', answer: "Lokale Variablen existieren nur innerhalb der Funktion, in der sie deklariert wurden. Globale Variablen existieren außerhalb von Funktionen und der Zugriff erfolgt über das Schlüsselwort 'global' oder das Array $GLOBALS. Statische Variablen existieren lokal, behalten jedoch ihren Wert über mehrere Funktionsaufrufe hinweg bei." } - { question: 'Warum schlägt die Neuzuweisung der Variablen $GLOBALS in PHP 8.1+ fail?', answer: "Seit PHP 8.1 verhindert die Zend Engine das Neuzuweisen des gesamten $GLOBALS-Arrays (z. B. ist $GLOBALS = [] verboten), um die Geschwindigkeit der Variablensuche zu optimieren und die interne Konsistenz sicherzustellen. Sie können jedoch weiterhin einzelne Schlüssel ändern (z. B. $GLOBALS['myVar'] = 'value')." } - { question: 'Wie handhabe ich sichere Dateiuploads mit $_FILES in PHP?', answer: "Überprüfen Sie immer den Upload-Status mit $_FILES['field']['error'], validieren Sie die Dateigröße und den MIME-Typ serverseitig, verifizieren Sie die Datei mit is_uploaded_file() und verschieben Sie sie mit move_uploaded_file() in ein sicheres Verzeichnis." } - { question: 'Warum wird in der modernen PHP-Entwicklung vom direkten Zugriff auf $_GET oder $_POST abgeraten?', answer: 'Der direkte Zugriff auf Superglobale koppelt Ihren Code an den globalen Zustand, was Unit-Tests und das Simulieren (Mocking) von Requests extrem erschwert. Zudem wird die Filterung umgangen, was das Risiko von XSS und SQL-Injection erhöht. Verwenden Sie stattdessen einen Request-Wrapper.' } published: '2026-06-07' --- # PHP Basics: Variable Scopes and Superglobals **Difficulty Level:** Junior **Target PHP Versions:** PHP 7.0+ (with features marked up to PHP 8.3+) Stellen Sie sich vor, Sie spielen ein kleines Code-Refactoring ein und Ihre Produktionsumgebung stürzt plötzlich mit einer fatalen Laufzeit-Ausnahme ab: `Fatal error: Cannot reassign $GLOBALS`. Oder Sie haben ein einfaches Kontaktformular geschrieben und stellen fest, dass ein böswilliger Benutzer über `$_POST` eine XSS-Payload eingeschleust und die Admin-Sitzungen übernommen hat. In PHP sind Variablen-Gültigkeitsbereiche (Scopes) und Superglobale das Fundament des Datenflusses. Dennoch sind sie für Entwickler, die neu in der Sprache sind, eine häufige Quelle für Scope-Verunreinigungen, Speicherlecks und kritische Sicherheitslücken. Zu verstehen, wie Variablen sich zwischen Gültigkeitsbereichen bewegen und wie sich Superglobale verhalten — insbesondere unter den strengen Regeln moderner PHP-Engines — ist unerlässlich für das Schreiben von sicherem, testbarem und robustem Code. --- ## Variable Scopes: Local, Global, and Static Der Gültigkeitsbereich (Scope) definiert die Sichtbarkeit und den Lebenszyklus von Variablen in Ihrem Code. In PHP fließen Variablen nicht automatisch in verschachtelte Scopes ein, es sei denn, dies wird explizit angewiesen. ### Local Scope * **Point**: Variablen, die innerhalb einer Funktion oder einer Klassenmethode deklariert werden, sind von der äußeren Umgebung isoliert. * **Why it matters**: Der lokale Gültigkeitsbereich verhindert Namenskollisionen und unerwartete Mutationen. Eine Variable namens `$user` innerhalb einer Funktion kann nicht versehentlich eine andernorts definierte `$user`-Variable überschreiben. * **Example**: ```php // app/Services/CalculationService.php function calculateTotal(float $price, float $tax): float { $total = $price + ($price * $tax); // Local variable return $total; } // Accessing $total here will throw a Warning (Undefined variable $total) ``` * **Consequence**: Sobald die Ausführung der Funktion beendet ist, werden ihre lokalen Variablen zerstört und ihr Speicher freigegeben. Jeder Versuch, vom globalen Scope aus auf sie zuzugreifen, führt zu einer Undefined-Variable-Warnung. ### Global Scope * **Point**: Variablen, die außerhalb einer Funktion oder Klasse definiert sind, gehören zum globalen Gültigkeitsbereich. Sie sind jedoch nicht automatisch innerhalb von Funktionen zugänglich. * **Why it matters**: Globale Variablen ermöglichen die gemeinsame Nutzung von Konfigurationen oder Datenbankverbindungen über verschiedene Dateien hinweg. Der Zugriff auf sie innerhalb von Funktionen erfordert jedoch explizite Schlüsselwörter. * **Example**: ```php // config/database.php $dbDsn = "mysql:host=127.0.0.1;dbname=app_db"; function connect(): PDO { // Accessing global scope requires the 'global' keyword global $dbDsn; return new PDO($dbDsn, "root", "secret"); } ``` * **Consequence**: Die Verwendung des Schlüsselworts `global` führt zu versteckten Abhängigkeiten. Dies erschwert Unit-Tests erheblich, da das Testprogramm globale Werte nicht einfach isolieren oder simulieren (mocken) kann. ### Static Scope * **Point**: Eine statische Variable wird innerhalb einer Funktion mithilfe des Schlüsselworts `static` deklariert. Sie existiert nur im lokalen Scope dieser Funktion, behält aber ihren Wert zwischen nachfolgenden Funktionsaufrufen bei. * **Why it matters**: Statische Variablen eignen sich hervorragend für das Caching aufwendiger Berechnungen, das Verfolgen der Rekursionstiefe oder das Generieren einfacher Sequenz-IDs, ohne den globalen Namensraum zu belasten. * **Example**: ```php // app/Utils/SequenceGenerator.php function getNextSequenceId(): int { static $id = 0; // Initialized only on the first call $id++; return $id; } echo getNextSequenceId(); // 1 echo getNextSequenceId(); // 2 ``` > [!NOTE] > **Hinweis zur PHP-Version**: Seit PHP 8.3+ können statische Variablen mit dynamischen Ausdrücken (z. B. durch Aufruf anderer Funktionen) initialisiert werden. Vor PHP 8.3 durften sie nur mit konstanten Werten oder Literalen initialisiert werden. * **Consequence**: Die Variable bleibt für die Dauer des aktuellen PHP-Prozesses im Speicher. Wenn Ihre Anwendung unter persistenten Runtimes (wie RoadRunner oder FrankenPHP) läuft, behalten statische Variablen ihren Zustand über verschiedene HTTP-Requests hinweg bei. Dies kann zu Speicherlecks oder zum Vermischen von Benutzerdaten führen, wenn sie nicht zurückgesetzt werden. --- ## PHP Superglobals Superglobale sind vordefinierte assoziative Arrays, die im gesamten Skript-Lebenszyklus und in allen Scopes immer verfügbar sind. Sie müssen nicht das Schlüsselwort `global` verwenden, um auf sie zuzugreifen. ### 1. `$GLOBALS` (mit Einschränkungen zur Neuzuweisung ab PHP 8.1+) * **Point**: Ein assoziatives Array, das Referenzen auf alle derzeit im globalen Gültigkeitsbereich des Skripts definierten Variablen enthält. * **Why it matters**: Bietet programmgesteuerten, dynamischen Zugriff auf den globalen Scope, ohne `global $varName` deklarieren zu müssen. * **Example**: ```php // app/Utils/DebugHelper.php $debugMode = true; function isDebugEnabled(): bool { // Directly check the global variable through the superglobal array return $GLOBALS['debugMode'] ?? false; } ``` * **PHP 8.1+ Einschränkung**: Vor PHP 8.1 konnte das `$GLOBALS`-Array neu zugewiesen oder als Referenz übergeben werden. Ab PHP 8.1+ ist die Neuzuweisung des gesamten `$GLOBALS`-Arrays (z. B. `$GLOBALS = [];` oder `$GLOBALS =& $otherArray;`) verboten und führt zu einem fatalen Fehler zur Kompilierzeit oder Laufzeit. Diese Einschränkung wurde eingeführt, um die Geschwindigkeit der Variablensuche in der Zend Engine zu optimieren. Sie können jedoch weiterhin einzelne Schlüssel ändern: ```php // app/Utils/LegacyRunner.php // This throws a Compile Error in PHP 8.1+: // $GLOBALS = ['app_env' => 'production']; // This is fully supported and correct: $GLOBALS['app_env'] = 'production'; ``` * **Consequence**: Legacy-Codebasen, die den globalen Zustand während des Bereinigens von Unit-Tests mit `$GLOBALS = []` zurückgesetzt haben, müssen so umgeschrieben werden, dass Variablen Schlüssel für Schlüssel zurückgesetzt werden. ### 2. `$_SERVER` * **Point**: Enthält Header, Pfade, Skript-Standorte und Server-Umgebungsvariablen. * **Why it matters**: Unerlässlich für das Request-Routing, das Überprüfen von HTTP-Methoden (GET, POST) und das Validieren von HTTP-Headern. * **Example**: ```php // public/index.php $requestUri = $_SERVER['REQUEST_URI'] ?? '/'; $requestMethod = $_SERVER['REQUEST_METHOD'] ?? 'GET'; $isHttps = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off'; ``` * **Consequence**: Werte, die mit `HTTP_` beginnen (z. B. `HTTP_USER_AGENT`, `HTTP_X_FORWARDED_FOR`), werden direkt vom Client-Browser bereitgestellt. Ihnen darf niemals blind vertraut werden, da sie leicht gefälscht werden können. ### 3. `$_GET` * **Point**: Ein assoziatives Array von Query-String-Variablen, die über die URL an das Skript übergeben werden. * **Why it matters**: Wird verwendet, um unkritische Navigationsparameter wie Paginierungs-Offsets, Filter und Suchbegriffe zu übergeben. * **Example**: ```php // app/Controllers/SearchController.php // URL: /search.php?query=php&page=2 $query = $_GET['query'] ?? ''; $page = (int)($_GET['page'] ?? 1); // Cast to int for safety ``` * **Consequence**: Query-Parameter werden im Browserverlauf und in Webserver-Protokollen gespeichert. Übergeben Sie sensible Anmeldedaten (Passwörter, API-Schlüssel oder Reset-Token) niemals via `$_GET`. ### 4. `$_POST` * **Point**: Ein assoziatives Array von Variablen, die über HTTP POST übergeben werden (z. B. HTML-Formulare oder `application/x-www-form-urlencoded`-Payloads). * **Why it matters**: Wird verwendet, um große Datensätze, Datei-Metadaten und sensible Payloads zu übertragen, die Daten auf dem Server ändern. * **Example**: ```php // app/Controllers/RegistrationController.php if ($_SERVER['REQUEST_METHOD'] === 'POST') { // PHP 8.0+ allows throw expressions with null coalescing: $email = $_POST['email'] ?? throw new InvalidArgumentException('Email is required'); $password = $_POST['password'] ?? ''; } ``` * **Consequence**: Wenn ein Benutzer eine Formular-Payload hochlädt, die die Einstellung `post_max_size` in der `php.ini` überschreitet, verwirft PHP die Payload stillschweigend. Das Array `$_POST` bleibt leer und es wird nicht automatisch ein Fehler ausgelöst. ### 5. `$_SESSION` * **Point**: Ein assoziatives Array, das für das aktuelle Skript verfügbare Session-Variablen enthält. * **Why it matters**: Ermöglicht das dauerhafte Speichern der Benutzeridentität und des Zustands (wie Warenkörbe oder Login-Status) über mehrere zustandslose HTTP-Requests hinweg. * **Example**: ```php // app/Services/AuthenticationService.php // PHP 7.0+ allows passing runtime options to session_start() session_start([ 'cookie_httponly' => true, 'cookie_secure' => true, 'cookie_samesite' => 'Lax', ]); $_SESSION['is_logged_in'] = true; $_SESSION['username'] = 'john_doe'; ``` * **Consequence**: `session_start()` muss vor dem Zugriff auf `$_SESSION` aufgerufen werden. Wenn Session-Cookies nicht mit dem Flag `HttpOnly` konfiguriert sind, kann die Session-ID per XSS gestohlen werden, was Benutzerkonten gefährdet. ### 6. `$_COOKIE` * **Point**: Ein assoziatives Array, das Cookies enthält, die vom Browser des Benutzers an den Server gesendet wurden. * **Why it matters**: Ermöglicht das Auslesen von clientseitigen Einstellungsdaten oder "Remember Me"-Authentifizierungstoken. * **Example**: ```php // app/Services/ThemeService.php $userTheme = $_COOKIE['preferred_theme'] ?? 'dark'; ``` * **Consequence**: Cookies werden vollständig auf der Clientseite gespeichert. Ein Benutzer kann Cookie-Werte manuell im Browser ändern. Vertrauen Sie `$_COOKIE`-Werten niemals für geschäftskritische Logik (wie `$_COOKIE['is_admin'] = 1`). ### 7. `$_ENV` * **Point**: Ein assoziatives Array, das Umgebungsvariablen enthält, die an den PHP-Prozess übergeben wurden. * **Why it matters**: Hält sensible Zugangsdaten (Datenbankpasswörter, Mailer-API-Schlüssel) sicher und getrennt vom Quellcode. * **Example**: ```php // app/Config/Database.php $dbPassword = $_ENV['DB_PASSWORD'] ?? 'default_password'; ``` * **Consequence**: `$_ENV` kann völlig leer sein, wenn die Direktive `variables_order` in der `php.ini` den Buchstaben `"E"` nicht enthält (z. B. wenn sie als `"GPCS"` konfiguriert ist). Wenn `$_ENV` leer ist, verwenden Sie `getenv()` oder passen Sie Ihre Konfiguration an. ### 8. `$_FILES` * **Point**: Ein assoziatives Array, das Metadaten über Dateien enthält, die über HTTP POST auf den Server hochgeladen wurden. * **Why it matters**: Ermöglicht den sicheren Zugriff auf die Eigenschaften der hochgeladenen Datei (Name, Typ, Größe, tmp_name, Fehler), um sie zu validieren und zu verschieben. * **Example**: ```php // app/Services/UploadService.php if (isset($_FILES['profile_pic']) && $_FILES['profile_pic']['error'] === UPLOAD_ERR_OK) { $tempPath = $_FILES['profile_pic']['tmp_name']; // Strict security validation if (is_uploaded_file($tempPath)) { $filename = uniqid('avatar_', true) . '.png'; move_uploaded_file($tempPath, '/var/www/uploads/' . $filename); } } ``` * **Consequence**: Wenn Dateien während der Request-Ausführung nicht mit `move_uploaded_file()` verschoben werden, löscht PHP die temporäre Datei nach Beendigung des Skripts automatisch aus dem Temp-Verzeichnis. --- ## Limitations, Trade-offs, and Clean Architecture Obwohl globale Variablen und Superglobale in PHP der Einfachheit halber integriert sind, raten moderne Software-Design-Praktiken von ihrer direkten Verwendung in der Business-Logik ab. * **Lack of Testability**: Der direkte Zugriff auf `$_GET`, `$_POST` oder `$_SERVER` koppelt Ihre Service-Klasse direkt an den globalen Zustand. Dies macht Unit-Tests unmöglich, da Sie den Ausführungskontext nicht isolieren können, ohne globale Variablen vor jedem Test zu modifizieren. * **Security Exposure**: Superglobale stellen rohe, nicht vertrauenswürdige Client-Eingaben dar. Der direkte Zugriff auf `$_POST['username']` anstelle der Verwendung eines validierten Datentransferobjekts erhöht die Angriffsfläche für SQL-Injection und Cross-Site Scripting (XSS). * **The Framework Alternative**: Moderne PHP-Frameworks (wie Laravel und Symfony) kapseln Superglobale in Request- und Response-Objekte. Anstatt `$_GET['id']` auszulesen, injizieren Sie eine `Request`-Instanz: ```php // app/Http/Controllers/UserController.php // Modern framework approach using Dependency Injection public function show(Request $request): Response { $userId = $request->query('id'); // Mockable and testable // ... } ``` --- ## Practical Takeaways 1. **Gültigkeitsbereich minimieren**: Halten Sie Variablen so lokal wie möglich. Übergeben Sie Variablen als Argumente an Funktionen, anstatt über das Schlüsselwort `global` auf sie zuzugreifen. 2. **RoadRunner/FrankenPHP-Lebenszyklen beachten**: Wenn Sie statische Variablen verwenden, bereinigen oder setzen Sie diese zurück, falls Ihre Umgebung persistente Worker-Prozesse nutzt. Andernfalls kommt es zu Speicherlecks oder zum Vermischen von Benutzerdaten. 3. **Request-Wrapper nutzen**: Wenn Sie reines PHP (ohne Framework) schreiben, erstellen Sie eine Wrapper-Klasse oder verwenden Sie `filter_input()`, anstatt direkt auf Superglobale zuzugreifen. 4. **Auf PHP 8.1+ vorbereiten**: Stellen Sie sicher, dass Sie keinen Legacy-Bibliothekscode haben, der `$GLOBALS` neu zuweist oder per Referenz übergibt. --- ## Self-Check Quiz Testen Sie Ihr Verständnis von PHP-Scopes und Superglobalen. ### Question 1: Was ist die Ausgabe des folgenden PHP-Codes? ```php // app/Http/Controllers/TestController.php $name = "Alice"; function greet(): string { return "Hello, " . $name; } echo greet(); ``` - A) `Hello, Alice` - B) `Hello, ` zusammen mit einer Undefined Variable Warning - C) `Hello, $name`
Antworten anzeigen **Antwort: B** Im globalen Scope definierte Variablen sind innerhalb von Funktionen nicht automatisch sichtbar. Da `$name` nicht mit dem Schlüsselwort `global` deklariert oder über `$GLOBALS['name']` innerhalb von `greet()` aufgerufen wurde, wirft PHP eine Warnung über eine undefinierte Variable aus und behandelt die Variable als `null`.
### Question 2: Welche Aussage bezüglich der Neuzuweisung von `$GLOBALS` ist korrekt? - A) `$GLOBALS` kann in allen PHP-Versionen neu zugewiesen werden. - B) Das Neuzuweisen von `$GLOBALS` (z. B. `$GLOBALS = [];`) löst ab PHP 8.1+ einen fatalen Fehler aus. - C) Das Ändern einzelner Schlüssel wie `$GLOBALS['user'] = 'Bob';` ist veraltet und ab PHP 8.1+ deaktiviert.
Antworten anzeigen **Antwort: B** Ab PHP 8.1 können Sie das gesamte `$GLOBALS`-Array aufgrund von Optimierungen in der Symboltabelle der Zend Engine nicht mehr neu zuweisen. Das Ändern einzelner Schlüssel (wie `$GLOBALS['user'] = 'Bob'`) bleibt jedoch weiterhin vollständig unterstützt und funktionsfähig.
### Question 3: Warum sollten Sie vermeiden, `$_FILES['input_name']['type']` zu vertrauen? - A) Dieser Wert ist immer leer. - B) Er wird von PHP auf der Serverseite ermittelt und ist häufig falsch. - C) Er wird vom Browser (Client) gesendet und kann von einem Angreifer manipuliert werden.
Antworten anzeigen **Antwort: C** Der MIME-Typ in `$_FILES['...']['type']` wird direkt über die Request-Header des Client-Browsers bereitgestellt. Ein Angreifer kann ein bösartiges `.php`-Skript hochladen, aber den Header manipulieren, sodass dort `image/png` steht. Validieren Sie den MIME-Typ immer auf dem Server mithilfe von `finfo_file()` oder der `fileinfo`-Erweiterung.