Kategorie:PHP

Informationen folgen in Kürze - es findet aktuelle eine Datenübernahme statt.

Funktionen

PHP mail() mit Umlauten

Nicht-kodierte Umlaute in E-Mails sind grundsätzlich nicht erlaubt und entsprechen nicht dem RFC. E-Mails können deswegen von Empfängern (insbes. GMX, Gmail & Co, die sehr streng sind) abgelehnt werden. Auf php.net gibt es dazu sowohl Hinweise auf den RFC, als auch weiter unten ein Beispiel zur korrekten Kodierung von deutschen Umlauten mit der PHP mail() Funktion.

Kompatibilität

PHP 7.4.22 / PHP 8 - `??` vs. `isset()`

PHP bietet mit dem Null-Coalescing-Operator (`??`) und der Funktion `isset()` zwei Möglichkeiten, sicher mit Variablen umzugehen, die möglicherweise nicht definiert sind, z. B. bei Formulareingaben oder Konfigurationsdaten in Webshops. `??` liefert schnell einen Standardwert, wenn eine Variable nicht existiert oder `null` ist, während `isset()` prüft, ob eine Variable definiert ist und nicht `null`. Beide Ansätze verhindern Fehler wie „undefined index“ und sind essenziell für robusten Code. Besonders für autodidaktische Programmierer ist es wichtig zu verstehen, dass Unterschiede zwischen diesen Methoden ab PHP 7.4.22 und PHP 8 zu Kompatibilitätsproblemen führen können, wenn Code zwischen verschiedenen PHP-Versionen wechselt.

In Webentwicklungsprojekten kann der Null-Coalescing-Operator (`??`) ab PHP 7.4.22 und besonders in PHP 8 Kompatibilitätsprobleme verursachen, wenn Anwendungen auf `isset()` basieren. Der Operator `??` ist ein Null-Coalescing-Mechanismus, der einen Fallback-Wert liefert, falls eine Variable nicht gesetzt oder `null` ist, während `isset()` eine explizite Existenz- und Null-Prüfung durchführt. Dies führt zu unterschiedlichem Verhalten bei Funktionen für sichere Konfigurationszugriffe, abhängig von der PHP-Version (z. B. PHP 7.4 oder PHP 8). Entwickler können eine Konstante verwenden, um zwischen dem modernen `??`-Operator und dem traditionellen `isset()`-Ansatz zu wechseln, um plattformübergreifende Kompatibilität zu gewährleisten.

Beispiel:

===PHP 8 - String-to-Number-Vergleiche===

PHP vergleicht oft Daten wie Texte und Zahlen, etwa bei Formulareingaben oder Datenbankabfragen. In älteren PHP-Versionen waren solche Vergleiche flexibel und führten manchmal zu überraschenden Ergebnissen, z. B. wenn ein Text wie „42abc“ als Zahl behandelt wurde. PHP 8 hat diese Vergleiche strenger gemacht, um präzisere und vorhersehbarere Ergebnisse zu liefern. Für autodidaktische Programmierer ist es wichtig zu wissen, dass diese Änderung bestehenden Code beeinflussen kann, der auf die lockeren Regeln von PHP 7.4.22 angewiesen ist, und Anpassungen erfordert, um Fehler zu vermeiden.

In PHP 8 wurden nicht strikte Vergleiche (`==`) zwischen Strings und Zahlen durch eine präzisere Typkonvertierung ersetzt, was zu Kompatibilitätsproblemen mit PHP 7.4.22 führen kann. Während PHP 7.4 bei Vergleichen wie `"42abc" == 42` den String in eine Zahl umwandelte und `true` zurückgab, führt PHP 8 solche Vergleiche strikter durch, was oft `false` ergibt, da der String nicht mehr automatisch konvertiert wird. Dies betrifft insbesondere Anwendungen mit Formularvalidierungen oder Datenbankabfragen, wo lockere Vergleiche üblich waren. Entwickler sollten explizite Typkonvertierungen oder strikte Vergleiche (`===`) verwenden, um robusten, plattformübergreifenden Code zu gewährleisten, und können Konfigurationsflags nutzen, um zwischen altem und neuem Verhalten zu wechseln.

'''Beispiel:'''
<source lang="php">
define('STRICT_COMPARE', 1); // 1 für PHP 8-Verhalten, 0 für PHP 7.4-Verhalten

function compareValue($input, $number, $default = false) {
    if (!STRICT_COMPARE) {
        // PHP 7.4: Lockere Konvertierung, kann unerwartete Ergebnisse liefern
        return $input == $number;
    }
    // PHP 8: Präziser Vergleich, keine automatische Konvertierung
    if (!is_numeric($input)) {
        return $default; // Vermeide falsche Übereinstimmungen
    }
    return (int)$input === $number; // Strikter Vergleich
}

// Beispielaufruf
$input = "42";
echo compareValue($input, 42, false) ? 'true' : 'false'; // Ausgabe: true

// Problemfall: String mit Buchstaben
$invalid = "42abc";
echo compareValue($invalid, 42, false) ? 'true' : 'false'; // PHP 7.4: true, PHP 8: false

define('USE_MODERN_PHP', 1); // 1 für ?? (PHP 8+), 0 für isset() (PHP 7.4)

function getValue($value, $default = ) {

   if (!USE_MODERN_PHP) {
       return isset($value) ? $value : $default; // Älteres Verhalten
   }
   return $value ?? $default; // Modernes Verhalten

}

// Beispielaufruf $blog = ['language' => 'de']; $language = getValue($blog['language'], 'en'); echo $language; // Ausgabe: de

// Problemfall: Nicht gesetzte Variable $timezone = getValue($blog['timezone'], 'UTC'); echo $timezone; // ?? gibt 'UTC', isset() könnte Fehler auslösen </source>

PHP 8 - Strikte Typprüfung und TypeError

PHP-Code arbeitet oft mit verschiedenen Datentypen, wie Zahlen, Texten oder Arrays, und muss sicherstellen, dass diese korrekt verwendet werden. In älteren PHP-Versionen war die Typprüfung flexibel und meldete Fehler durch falsche Typen meist als Warnungen, die den Code nicht stoppten. Mit PHP 8 wurden viele Funktionen strenger: Falsche Typen lösen nun ernsthafte Fehler aus, die das Programm beenden können. Für Programmierer bedeutet dies, dass sie lernen müssen, ihren Code anzupassen, um robuste Anwendungen zu schreiben, die auch mit neueren PHP-Versionen funktionieren.

In PHP 8 führt die verschärfte Typprüfung, insbesondere bei internen Funktionen und Array-Operationen, zu Kompatibilitätsproblemen, da PHP 7.4.22 oft Warnungen (`Warning`) statt Ausnahmen (`TypeError`) ausgab. Ein prominentes Beispiel ist die Funktion `array_key_exists()`, die in PHP 7.4 bei nicht-Array-Argumenten eine Warnung erzeugte, während PHP 8 eine `TypeError`-Ausnahme wirft. Dies erfordert defensive Programmierung mit expliziten Typprüfungen, um plattformübergreifende Kompatibilität zu gewährleisten. Entwickler können Konfigurationsflags oder Konstanten nutzen, um zwischen lockerer und strenger Typprüfung zu wechseln, besonders bei Projekten, die zwischen PHP-Versionen migrieren.