Die Funktion date() in PHP

Sie befinden sich: Home > Php > Die Funktion date() in PHP

Beispiel für die PHP-Funktion date():

<?php
/**
* Angenommen heute ist March 10th,
* 2001, 5:16:18 pm
* */
$heute = date("F j, Y, g:i a");
echo $heute.'<br>';
/* Ausgabe: March 10, 2001, 5:16 pm */

$heute = date("m.d.y");
echo $heute.'<br>';
/* Ausgabe: 03.10.01 */

$heute = date("d.m.Y \\u\\m H:i \\U\\h\\r");
echo $heute.'<br>';
/* Ausgabe: 10.03.2001 um 17:16 Uhr */

$heute = date("j, n, Y");
echo $heute.'<br>';
/* Ausgabe: 10, 3, 2001 */

$heute = date("Ymd");
echo $heute.'<br>';
/* Ausgabe: 20010310 */

$heute = date('h-i-s, j-m-y, it is w Day z ');
echo $heute.'<br>';
/* Ausgabe: 05-16-17, 10-03-01, 1631 1617 6 Satpm01 68 */

$heute = date("D M j G:i:s T Y");
echo $heute.'<br>';
/* Ausgabe: Sat Mar 10 15:16:08 MST 2001 */

$heute = date("H:i:s \m ") . " ist der Formatbuchstabe für Minuten";
echo $heute.'<br>';
/* Ausgabe: 17:16:17 m ist der Formatbuchstabe für Minuten */
/* Hinweis: 'i' steht für Minuten, 'm' für den Monat! */

$heute = date("H:i:s");
echo $heute.'<br>';
/* Ausgabe: 17:16:17 */
?>

Formatparameter von der PHP-Funktion: date()

Die Vielzahl von Parametern ist für Neulinge im Bereich der Programmierung oftmals nicht überschaubar. Nachfolgende Tabelle zeigt die wohl am häufigsten verwendeten Formatparameter.

Soll nun unter anderem die aktuelle Uhrzeit angegeben werden, müssen nur die oben aufgeführten Formate dafür sinnvoll kombiniert werden.

<?php
echo date(" H:i:s:T ");
/* z.B.: 15:23:45:EST */
?>

Wenn sichekt ein Text in die date() Funktion eingesetzen werden soll, muss jedes Zeichen durch einen vorangestellten Backslash ( \ ) „escaped“ werden, damit der Buchstabe gegebenenfalls nicht als Format des Datums interpretiert wird.

Wie kann ich die Zeitzone verändern?

Die PHP Funktion date_default_timezone_set() wird verwendet, um die Standardzeitzone für eine Datei oder ein Skript zu setzen. Mit dieser Funktion kann man festlegen, welche Zeitzone für alle Datumsfunktionen in der Skript-Datei verwendet werden soll. 

Beispiel 1: Wir können die Standardzeitzone auf Europa/Berlin setzen, indem wir folgenden Code verwenden: 

<?php
date_default_timezone_set('Europe/Berlin');
?>

Beispiel 2: Wir können auch die Standardzeitzone auf America/New_York setzen, indem wir folgenden Code verwenden:

<?php
date_default_timezone_set('America/New_York');
?>

Es kann Vorteile haben, zwei Zeitzonen zu verwenden, da man so verschiedene Zeitzonen in einer Anwendung vergleichen und verschiedene Uhrzeiten anzeigen kann. Beispielsweise kann eine Anwendung die Uhrzeit in einer Zeitzone anzeigen und gleichzeitig die Uhrzeit im Zielmarkt anzeigen. Dies kann beim Verwalten von Terminen oder beim Einrichten von Konferenzanrufen nützlich sein.

UTC als Basis für internationale Anwendungen

In Webanwendungen mit internationalen Nutzern empfiehlt es sich, intern durchgängig mit UTC (Coordinated Universal Time) zu arbeiten. UTC ist die Referenzzeit ohne Sommer- oder Winterzeitverschiebung. Timestamps werden in UTC in der Datenbank gespeichert und erst bei der Ausgabe in die jeweilige lokale Zeitzone des Nutzers umgerechnet.

<?php
/* Datum in UTC speichern */
$utc = new DateTimeImmutable('now', new DateTimeZone('UTC'));
$dbWert = $utc->format('Y-m-d H:i:s');
/* z.B.: 2026-02-17 13:45:00 */

/* Für die Anzeige in die lokale Zeitzone umwandeln */
$lokal = $utc->setTimezone(new DateTimeZone('Europe/Berlin'));
echo $lokal->format('d.m.Y H:i');
/* z.B.: 17.02.2026 14:45 (UTC+1 im Winter) */
?>

Die Methode setTimezone() ändert die Zeitzone, ohne den tatsächlichen Zeitpunkt zu verändern – lediglich die Darstellung wird angepasst. Bei DateTimeImmutable wird dabei ein neues Objekt zurückgegeben, das Original bleibt unverändert.

Eine Liste aller unterstützten Zeitzonen erhalten Sie mit der Funktion DateTimeZone::listIdentifiers(). Die für den deutschsprachigen Raum relevanten Zeitzonen sind Europe/Berlin, Europe/Vienna und Europe/Zurich.

Mit der Funktion date() werden Monatsnamen immer auf Englisch dargestellt. Wichtig: Die Funktion setlocale() hat keinen Einfluss auf die Ausgabe von date(). Um Monatsnamen in einer anderen Sprache darzustellen, verwenden Sie die Klasse IntlDateFormatter:

<?php
$formatter = new IntlDateFormatter(
    'de_DE',
    IntlDateFormatter::LONG,
    IntlDateFormatter::NONE
);
echo $formatter->format(time());
/* z.B.: 16. Februar 2026 */
?>

Der IntlDateFormatter unterstützt verschiedene Detailstufen für Datum und Uhrzeit. Die Konstanten FULL, LONG, MEDIUM und SHORT steuern den Umfang der Ausgabe. Alternativ können Sie mit einem eigenen Pattern arbeiten:

<?php
/* Datum mit Wochentag auf Deutsch */
$formatter = new IntlDateFormatter(
    'de_DE',
    IntlDateFormatter::FULL,
    IntlDateFormatter::SHORT
);
echo $formatter->format(time());
/* z.B.: Dienstag, 17. Februar 2026 um 14:30 */

/* Eigenes Pattern: nur Monat und Jahr */
$formatter2 = new IntlDateFormatter(
    'de_DE',
    IntlDateFormatter::NONE,
    IntlDateFormatter::NONE,
    'Europe/Berlin',
    IntlDateFormatter::GREGORIAN,
    'MMMM yyyy'
);
echo $formatter2->format(time());
/* z.B.: Februar 2026 */
?>

Der IntlDateFormatter nutzen die ICU-Bibliothek (International Components for Unicode) und unterstützt damit über 300 Sprachen und Regionen. Er ist die zuverlässigste Methode, um Datumsangaben korrekt lokalisiert auszugeben – deutlich besser als die veraltete Funktion strftime(), die seit PHP 8.1 als deprecated markiert ist.

Eingangs wurde erwähnt, dass ein zusätzlicher Parameter an die Funktion übergeben werden kann. Hierbei handelt es sich um den sogenannten UNIX Timestamp. Dieser UNIX Timestamp ist ein Integerwert, der praktisch die verstrichenen Sekunden seit dem 01.01.1970 repräsentiert.

Um einen Timestamp in einer Variable zu speichern, wird die Funktion time() verwendet. Zum Umwandeln eines UNIX Timestamp können Sie unser UNIX Timestamp Tool verwenden, um unter anderem schnell und einfach einen Timestamp zu generieren. Nachfolgend noch ein Beispiel, wie sie mit dem PHP Befehl time() arbeiten können.

<?php
/* holt den aktuellen Timestamp
und speichert diesen in $timestamp */
$timestamp = time();

echo date("H:i:s:T", $timestamp);
/* gibt den mit time(); geholten Timestamp im
angegebenen Format aus ( z.B. 15:23:45:EST ) */
?>

Wenn Sie den Start und das Enddatums einer Woche berechnen möchten, können Sie sich das Tutorial: Start und Enddatum einer Woche ermitteln, ansehen. In diesem Tutorial wird die Berechnung über ein Timestamp realisiert, mit Zuhilfenahme von der PHP Funktion strtotime() und date().

Ein weiterer interessanter Ansatz, wie sie mit der PHP Funktion Date arbeiten, finden Sie in dem PHP Tutorial: Das Datum und Uhrzeit der letzten Änderung von einer Datei ermitteln.

Mit der PHP Funktion mktime() kann man ein Datum zu ein Timestamp umwandeln. Dieser Timestamp kann dann anschließend berechnet und wieder über die PHP-Funktion date() ausgegeben werden.

Wenn Sie das Datum und/oder die Uhrzeit formatieren wollen, können Sie die PHP-Funktion date_format() verwenden. Mit dieser Funktion können Sie das Datum und die Uhrzeit in dem gewünschten Format ausgeben.

Datum parsen mit strtotime()

Die Funktion strtotime() wandelt eine textuelle Datums- oder Zeitangabe in einen UNIX-Timestamp um. Sie versteht sowohl absolute Datumsangaben als auch relative Ausdrücke wie „next Monday“ oder „+3 days“. In der Praxis ist strtotime() eine der am häufigsten genutzenen Datumsfunktionen, weil sie natürlichsprachliche Ausdrücke in berechenbare Timestamps übersetzen. Sie eignet sich hervorragend für schnelle Datumsberechnungen, ohne zuerst ein DateTime-Objekt anlegen zu müssen.

Beispiel mit absoluten Datumsangaben:

<?php
$timestamp = strtotime('2026-03-15');
echo date('d.m.Y', $timestamp);
/* Ausgabe: 15.03.2026 */

$timestamp2 = strtotime('March 15, 2026');
echo date('d.m.Y', $timestamp2);
/* Ausgabe: 15.03.2026 */
?>

Beispiel mit relativen Datumsangaben:

<?php
echo date('d.m.Y', strtotime('+1 week'));
/* Ausgabe: Datum in einer Woche */

echo date('d.m.Y', strtotime('next Monday'));
/* Ausgabe: nächster Montag */

echo date('d.m.Y', strtotime('-3 months'));
/* Ausgabe: Datum vor drei Monaten */

echo date('d.m.Y', strtotime('last day of this month'));
/* Ausgabe: letzter Tag des aktuellen Monats */
?>

strtotime() akzeptiert einen optionalen zweiten Parameter als Bezugszeitpunkt. Ohne diesen Parameter wird die aktuelle Zeit verwendet.

<?php
$bezugsdatum = strtotime('2026-01-01');
echo date('d.m.Y', strtotime('+90 days', $bezugsdatum));
/* Ausgabe: 01.04.2026 (90 Tage nach dem 1. Januar) */
?>

Hinweis: Bei ungültigen Eingaben gibt strtotime() den Wert false zurück. Prüfen Sie daher das Ergebnis, bevor Sie es weiterverarbeiten:

<?php
$eingabe = 'kein gültiges Datum';
$timestamp = strtotime($eingabe);

if ($timestamp === false) {
    echo 'Ungültige Datumseingabe: ' . $eingabe;
} else {
    echo date('d.m.Y', $timestamp);
}
?>

Beachten Sie außerdem, dass strtotime() bei mehrdeutigen Formaten wie 01/02/2026 das amerikanische Format (Monat/Tag/Jahr) annimmt. Für das europäische Datumsformat 01.02.2026 (Tag.Monat.Jahr) ist die Punktschreibweise eindeutig und wird korrekt erkannt. Im Zweifelsfall verwenden Sie DateTimeImmutable::createFromFormat(), um das genaue Format explizit festzulegen.

Die DateTime-Klasse

Seit PHP 5.2 steht die objektorientierte DateTime-Klasse zur Verfügung. Sie bietet gegenüber der prozeduralen Funktion date() erhebliche Vorteile: Zeitzonenunterstützung als fester Bestandteil des Objekts, einfache Datumsberechnungen und eine klarere Syntax für komplexere Anwendungsfälle.

Während date() und strtotime() rein prozedurale Funktionen sind, kapselt die DateTime-Klasse ein Datum samt Zeitzone in einem Objekt. Dadurch lässt sich das Datum als eigenständiger Wert durch die Anwendung reichen, ohne globale Einstellungen ändern zu müssen. Methoden wie add(), sub(), diff() und modify() machen Berechnungen deutlich lesbarer als die manuelle Arbeit mit UNIX-Timestamps.

Ein DateTime-Objekt erstellen

Ein DateTime-Objekt kann auf verschiedene Weisen erzeugt werden:

<?php
/* Aktuelles Datum und aktuelle Uhrzeit */
$jetzt = new DateTime();

/* Bestimmtes Datum angeben */
$datum = new DateTime('2026-06-15 14:30:00');

/* Mit Zeitzone erstellen */
$berlin = new DateTime('now', new DateTimeZone('Europe/Berlin'));
$tokyo  = new DateTime('now', new DateTimeZone('Asia/Tokyo'));

echo $berlin->format('H:i') . ' (Berlin)';
echo $tokyo->format('H:i') . ' (Tokyo)';
?>

Datum formatieren mit format()

Die Methode format() verwendet dieselben Formatzeichen wie die Funktion date():

<?php
$datum = new DateTime('2026-03-15 14:30:00');

echo $datum->format('d.m.Y');
/* Ausgabe: 15.03.2026 */

echo $datum->format('l, d. F Y');
/* Ausgabe: Sunday, 15. March 2026 */

echo $datum->format('H:i:s');
/* Ausgabe: 14:30:00 */

echo $datum->format(DateTime::ATOM);
/* Ausgabe: 2026-03-15T14:30:00+00:00 (ISO 8601) */
?>

Datum ändern mit modify()

Mit modify() können Sie ein bestehendes DateTime-Objekt verändern. Die Methode akzeptiert dieselben relativen Ausdrücke wie strtotime():

<?php
$datum = new DateTime('2026-01-15');

$datum->modify('+10 days');
echo $datum->format('d.m.Y');
/* Ausgabe: 25.01.2026 */

$datum->modify('-2 months');
echo $datum->format('d.m.Y');
/* Ausgabe: 25.11.2025 */

$datum->modify('next Friday');
echo $datum->format('d.m.Y');
/* Ausgabe: 28.11.2025 */
?>

Wichtig: Die Methode modify() verändert das bestehende Objekt sichekt. Das ursprüngliche Datum wird dabei überschrieben. Wenn Sie das Originaldatum behalten möchten, verwenden Sie DateTimeImmutable (siehe weiter unten).

DateInterval und Datumsberechnungen

Für präzise Datumsberechnungen bietet PHP die Klasse DateInterval. Mit ihr definieren Sie Zeitspannen, die Sie anschließend mit add() oder sub() auf ein DateTime-Objekt anwenden können. Intervalle werden im ISO-8601-Format angegeben, beginnend mit dem Buchstaben P (für „Period“). Diese Schreibweise mag zunächst ungewohnt wirken, ist aber international standardisiert und daher eindeutig:

<?php
$datum = new DateTime('2026-01-01');

/* 1 Jahr, 2 Monate und 10 Tage addieren */
$intervall = new DateInterval('P1Y2M10D');
$datum->add($intervall);
echo $datum->format('d.m.Y');
/* Ausgabe: 11.03.2027 */

/* 30 Tage subtrahieren */
$datum2 = new DateTime('2026-06-15');
$datum2->sub(new DateInterval('P30D'));
echo $datum2->format('d.m.Y');
/* Ausgabe: 16.05.2026 */
?>

Die gängigsten Intervall-Bezeichner sind: Y (Jahre), M (Monate), D (Tage), H (Stunden), I (Minuten) und S (Sekunden). Zeitangaben werden mit einem T eingeleitet, z. B. P1DT12H für 1 Tag und 12 Stunden.

Differenz zwischen zwei Daten berechnen

Die Methode diff() berechnet den Unterschied zwischen zwei DateTime-Objekten und gibt ein DateInterval zurück:

<?php
$start = new DateTime('2026-01-01');
$ende  = new DateTime('2026-12-31');

$differenz = $start->diff($ende);

echo $differenz->days . ' Tage';
/* Ausgabe: 364 Tage */

echo $differenz->format('%m Monate und %d Tage');
/* Ausgabe: 11 Monate und 30 Tage */
?>

Datum vergleichen

DateTime-Objekte können sichekt mit den Vergleichsoperatoren <, > und == verglichen werden:

<?php
$heute  = new DateTime();
$termin = new DateTime('2026-12-24');

if ($heute < $termin) {
    echo 'Der Termin liegt in der Zukunft.';
} elseif ($heute > $termin) {
    echo 'Der Termin ist bereits vergangen.';
} else {
    echo 'Der Termin ist heute.';
}
?>

DateTimeImmutable – die sichere Alternative

Die Klasse DateTimeImmutable (verfügbar seit PHP 5.5) funktioniert wie DateTime, mit einem entscheidenden Unterschied: Jede Änderung erzeugt ein neues Objekt, statt das bestehende zu verändern. Das verhindert unbeabsichtigte Seiten­effekte, insbesondere wenn Datumsobjekte an mehreren Stellen im Code verwendet oder an Funktionen übergeben werden. Dieses Verhalten ist vergleichbar mit Strings in PHP: Wenn Sie einen String ändern, entsteht ein neuer String, während der ursprüngliche erhalten bleibt.

<?php
/* DateTime: Originaldatum wird verändert */
$datum = new DateTime('2026-03-01');
$spaeter = $datum->modify('+7 days');

echo $datum->format('d.m.Y');
/* Ausgabe: 08.03.2026 (Original verändert!) */
echo $spaeter->format('d.m.Y');
/* Ausgabe: 08.03.2026 */

/* DateTimeImmutable: Originaldatum bleibt erhalten */
$datum2 = new DateTimeImmutable('2026-03-01');
$spaeter2 = $datum2->modify('+7 days');

echo $datum2->format('d.m.Y');
/* Ausgabe: 01.03.2026 (Original unverändert!) */
echo $spaeter2->format('d.m.Y');
/* Ausgabe: 08.03.2026 */
?>

In modernem PHP-Code wird empfohlen, standardmäßig DateTimeImmutable zu verwenden und nur dann auf DateTime zurückzugreifen, wenn das Objekt bewusst verändert werden soll.

Häufige Datumsformate im Überblick

Je nach Anwendungsfall werden unterschiedliche Datumsformate benötigt. Die folgende Tabelle zeigt die wichtigsten Formate und wie sie in PHP erzeugt werden:

Das ISO-8601-Format eignet sich besonders für APIs und den Datenaustausch, da es international eindeutig ist und die Zeitzone enthält. Für die Speicherung in MySQL-Datenbanken wird das Format Y-m-d H:i:s verwendet.

<?php
$datum = new DateTimeImmutable('2026-03-15 14:30:00',
    new DateTimeZone('Europe/Berlin'));

/* Verschiedene Formate ausgeben */
echo $datum->format('d.m.Y');         /* 15.03.2026 */
echo $datum->format('c');              /* 2026-03-15T14:30:00+01:00 */
echo $datum->format('Y-m-d H:i:s');   /* 2026-03-15 14:30:00 */
echo $datum->format('D, d M Y H:i');  /* Sun, 15 Mar 2026 14:30 */
?>

Datum aus einem String erstellen mit createFromFormat()

Wenn ein Datumsstring in einem bestimmten Format vorliegt, das PHP nicht automatisch erkennt, kann createFromFormat() verwendet werden. Diese Methode funktioniert sowohl mit DateTime als auch mit DateTimeImmutable:

<?php
/* Deutsches Datumsformat parsen */
$datum = DateTimeImmutable::createFromFormat(
    'd.m.Y',
    '15.03.2026'
);
echo $datum->format('Y-m-d');
/* Ausgabe: 2026-03-15 */

/* Datum mit Uhrzeit parsen */
$datum2 = DateTimeImmutable::createFromFormat(
    'd/m/Y H:i',
    '15/03/2026 14:30'
);
echo $datum2->format('d.m.Y \u\m H:i \U\h\r');
/* Ausgabe: 15.03.2026 um 14:30 Uhr */
?>

Hinweis: Bei einem ungültigen Eingabestring gibt createFromFormat() den Wert false zurück. Mit DateTime::getLastErrors() können Sie die genauen Fehler abfragen.

Vergleich: date() vs. DateTime-Klasse

Für einfache Ausgaben ist date() völlig ausreichend. Die DateTime-Klasse lohnt sich, sobald Sie Berechnungen durchführen, Zeitzonen verwalten oder Datumsobjekte in Ihrer Anwendung weitergeben möchten.

Datumsreihen erzeugen mit DatePeriod

Die Klasse DatePeriod ermöglicht es, über eine Reihe von Datumswerten zu iterieren. Das ist besonders nützlich, wenn Sie eine Folge von Tagen, Wochen oder Monaten durchlaufen möchten – etwa für einen Kalender, eine Terminplanung oder einen statistischen Bericht. Die Klasse benötigt ein Startdatum, ein Intervall und entweder ein Enddatum oder die Anzahl der Wiederholungen.

<?php
$start    = new DateTimeImmutable('2026-03-01');
$ende     = new DateTimeImmutable('2026-03-08');
$intervall = new DateInterval('P1D'); /* 1 Tag */

$zeitraum = new DatePeriod($start, $intervall, $ende);

foreach ($zeitraum as $tag) {
    echo $tag->format('D, d.m.Y');
}
/* Ausgabe: */
/* Sun, 01.03.2026 */
/* Mon, 02.03.2026 */
/* Tue, 03.03.2026 */
/* ... bis einschließlich Sat, 07.03.2026 */
?>

Das Enddatum ist standardmäßig nicht in der Reihe enthalten. Seit PHP 8.2 kann das mit der Option DatePeriod::INCLUDE_END_DATE geändert werden.

Ein weiteres Beispiel zeigt die monatliche Iteration:

<?php
$start = new DateTimeImmutable('2026-01-01');
$intervall = new DateInterval('P1M'); /* 1 Monat */

/* 12 Wiederholungen (ein ganzes Jahr) */
$zeitraum = new DatePeriod($start, $intervall, 11);

foreach ($zeitraum as $monat) {
    echo $monat->format('F Y');
}
/* Ausgabe: January 2026, February 2026, ... December 2026 */
?>

Tipps und häufige Fehlerquellen

Beim Arbeiten mit Datum und Zeit in PHP gibt es einige häufige Stolpersteine, die sich leicht vermeiden lassen:

• Zeitzone immer setzen: Wenn keine Zeitzone explizit gesetzen ist, verwendet PHP die Einstellung aus php.ini. Setzen Sie date_default_timezone_set('Europe/Berlin') am Anfang Ihres Skripts oder übergeben Sie die Zeitzone sichekt an das DateTime-Objekt.
• Monatsgrenzen beachten: Das Addieren von Monaten kann zu unerwarteten Ergebnissen führen. Wenn Sie zum 31. Januar einen Monat addieren, erhalten Sie den 3. März (da der 31. Februar nicht existiert). Für geschäftliche Anforderungen prüfen Sie das Ergebnis nach der Berechnung.
• Sommer- und Winterzeit: Bei Berechnungen über Zeitumstellungen hinweg kann ein Tag 23 oder 25 Stunden haben. Verwenden Sie für tagesgenaue Berechnungen DateInterval('P1D') statt manuell 86.400 Sekunden zu addieren.
• Timestamp-Überlauf: Auf 32-Bit-Systemen kann der UNIX-Timestamp ab dem Jahr 2038 überlaufen. Auf modernen 64-Bit-Systemen und mit der DateTime-Klasse besteht dieses Problem nicht.
• Benutzereingaben validieren: Verwenden Sie createFromFormat() statt strtotime(), um Datumswerte aus Formularen zu parsen. So stellen Sie sicher, dass das erwartete Format eingehalten wird.

Carbon – komfortable Datumsbibliothek

Für umfangreichere Projekte, die häufig mit Datumsangaben arbeiten, gibt es die Bibliothek Carbon. Carbon erweitert die PHP-Klasse DateTimeImmutable und bietet zusätzliche Komfortfunktionen wie lesbare Differenzen („vor 3 Stunden“), Lokalisierung und vereinfachte Vergleichsmethoden.

Die Installation erfolgt über Composer:

composer require nesbot/carbon

Beispiel:

<?php
use Carbon\Carbon;

$jetzt = Carbon::now('Europe/Berlin');
echo $jetzt->format('d.m.Y H:i');

/* Relative Ausgabe */
echo Carbon::parse('2026-01-01')->diffForHumans();
/* z.B.: "vor 2 Monaten" */

/* Einfache Berechnungen */
$morgen = Carbon::tomorrow();
$naechsteWoche = $jetzt->addWeek();
?>

Carbon eignet sich besonders für Webanwendungen und Frameworks wie Laravel, in dem Carbon bereits standardmäßig enthalten ist. Für einfache Skripte reichen die nativen PHP-Klassen DateTime und DateTimeImmutable in der Regel vollkommen aus.

Zeitzonen mit DateTimeZone richtig setzen

Sobald Ihre Anwendung Nutzer aus mehreren Ländern bedient, kommen Sie um Zeitzonen nicht herum. Ein Server in Frankfurt, eine Datenbank in UTC und ein Besucher aus New York: drei verschiedene Realitäten für dieselbe Sekunde. PHP löst das über die Klasse DateTimeZone, die Sie jedem DateTime-Objekt mitgeben können.

Die saubere Strategie sieht so aus: In der Datenbank speichern Sie immer UTC. Bei der Ausgabe wandelst Sie in die Zeitzone des Nutzers um. So vermeiden Sie Doppeldeutigkeiten und sparen sich Ärger bei späteren Auswertungen.

<?php
declare(strict_types=1);

/* Zeitpunkt in UTC anlegen, wie er aus der DB kommt */
$utc = new DateTimeImmutable('2026-05-09 14:00:00', new DateTimeZone('UTC'));

/* Fuer die Anzeige in Berlin umrechnen */
$berlin = $utc->setTimezone(new DateTimeZone('Europe/Berlin'));
echo $berlin->format('d.m.Y H:i T'); /* 09.05.2026 16:00 CEST */

/* Gleicher Moment, andere Zone */
$ny = $utc->setTimezone(new DateTimeZone('America/New_York'));
echo $ny->format('d.m.Y H:i T'); /* 09.05.2026 10:00 EDT */
?>

DateTimeImmutable ist hier ein wichtiger Detailpunkt. Im Gegensatz zu DateTime wird das Original-Objekt nicht verändert. setTimezone() liefert ein neues Objekt zurück, das Sie gefahrlos weiterreichen können.

Liste aller verfügbaren Zeitzonen

Wenn Sie dem Nutzer eine Auswahl anbieten wollen, holen Sie sich die Identifier über DateTimeZone::listIdentifiers(). Sie folgen dem IANA-Standard und sind die einzige verlässliche Quelle. Verwenden Sie niemals Abkürzungen wie "MEZ" oder "CEST" als Eingabe, da sie mehrdeutig sind.

<?php
$zonen = DateTimeZone::listIdentifiers(DateTimeZone::EUROPE);
foreach ($zonen as $zone) {
    echo $zone . "
"; /* Europe/Berlin, Europe/London, ... */
}
?>

date_default_timezone_set vs php.ini

Viele Entwickler kennen den Klassiker: ein Skript läuft lokal perfekt, auf dem Live-Server zeigt es plotzlich Zeiten in UTC oder, schlimmer, eine Warnung über eine fehlende Zeitzone. Der Grund liegt fast immer in einer abweichenden Konfiguration zwischen Entwicklungs- und Produktionsumgebung.

PHP zieht die Zeitzone in dieser Reihenfolge: zuerst der Wert aus date_default_timezone_set(), falls im Skript gesetzen. Dann der Wert date.timezone aus der php.ini. Wenn beides fehlt, fällt PHP auf UTC zurück und gibt ab Version 8 keine Warnung mehr aus, was früher noch der Fall war.

<?php
/* Variante 1: zur Laufzeit setzen, Vorrang vor php.ini */
date_default_timezone_set('Europe/Berlin');

/* Variante 2: aktuell aktive Zeitzone abfragen */
echo date_default_timezone_get(); /* Europe/Berlin */

/* Variante 3: Wert aus der php.ini lesen */
echo ini_get('date.timezone');
?>

Mein Rat: setze die Zeitzone in einer zentralen Bootstrap-Datei Ihres Projekts. So müssen Sie sich nie auf die Server-Konfiguration verlassen und das Verhalten ist auf jedem Hosting identisch. Wer sich genauer mit Konfigurationsfragen beschäftigen will, findet im Tutorial zu ini_set weiterführende Hinweise.

ISO-Wochen und Kalenderwochen sauber berechnen

Kalenderwochen sehen einfach aus, sind aber eine berüchtigte Stolperfalle. Deutschland nutzen den ISO-8601-Standard: die Woche beginnt am Montag, und die erste Woche eines Jahres ist diejenige, die mindestens vier Tage im neuen Jahr enthält. Das führt dazu, dass der 1. Januar 2027 noch zur Woche 53 von 2026 gehoeren kann.

Für die Berechnung gibt es zwei wichtige Formatzeichen: W liefert die ISO-Wochennummer, o das ISO-Wochenjahr. Verwenden Sie niemals Y zusammen mit W, sonst bekommen Sie am Jahreswechsel falsche Ergebnisse.

<?php
declare(strict_types=1);

$datum = new DateTimeImmutable('2027-01-01');

echo $datum->format('W');     /* 53 */
echo $datum->format('o-W');   /* 2026-53, korrekt */
echo $datum->format('Y-W');   /* 2027-53, falsch! */
?>

Start- und Enddatum einer Woche

Wer einen Wochenkalender oder Schichtplan baut, braucht oft den Montag und Sonntag einer KW. Mit der relativen Syntax von strtotime, hier über das DateTime-Pendant modify, geht das in zwei Zeilen.

<?php
function wochenrange(int $jahr, int $kw): array
{
    $montag = (new DateTimeImmutable())
        ->setISODate($jahr, $kw)
        ->setTime(0, 0);
    $sonntag = $montag->modify('+6 days');

    return [$montag, $sonntag];
}

[$start, $ende] = wochenrange(2026, 19);
echo $start->format('d.m.Y') . ' bis ' . $ende->format('d.m.Y');
?>

Schaltjahre zuverlässig erkennen

Ein Schaltjahr ist nicht einfach "alle vier Jahre". Die genaue Regel: durch 4 teilbar, aber nicht durch 100, es sei denn auch durch 400. Das Jahr 2000 war ein Schaltjahr, 1900 nicht, 2100 wird wieder keines sein. Sie müssen das glücklicherweise nie selbst rechnen, denn date() bringt das Formatzeichen L mit.

<?php
declare(strict_types=1);

function istSchaltjahr(int $jahr): bool
{
    /* L liefert 1 fuer Schaltjahr, 0 sonst */
    return (bool) date('L', mktime(0, 0, 0, 1, 1, $jahr));
}

var_dump(istSchaltjahr(2024)); /* true */
var_dump(istSchaltjahr(2026)); /* false */
var_dump(istSchaltjahr(2100)); /* false */
?>

Eleganter geht es objektorientiert über DateTime, da brauchen Sie mktime nicht und sparen sich den Timestamp-Umweg.

<?php
$jahr = 2024;
$check = new DateTimeImmutable("$jahr-01-01");
echo $check->format('L') === '1' ? 'Schaltjahr' : 'Normales Jahr';
?>

Alter berechnen und Geburtstags-Reminder

Eine der häufigsten Praxisaufgaben: aus einem Geburtsdatum das aktuelle Alter ableiten. Klingt nach einer simplen Subtraktion, aber wer einfach Jahre voneinander abzieht, liegt am Jahresanfang fast immer um eins daneben. Sauberer geht es mit diff(), das eine DateInterval-Instanz liefert.

<?php
declare(strict_types=1);

function alterInJahren(string $geburtsdatum): int
{
    $geburt = new DateTimeImmutable($geburtsdatum);
    $heute  = new DateTimeImmutable('today');

    return $geburt->diff($heute)->y;
}

echo alterInJahren('1990-08-15'); /* 35, je nach heutigem Datum */
?>

Wer hat in den nächsten 7 Tagen Geburtstag?

Für ein Mitgliedersystem oder einen Newsletter wollen Sie oft alle anstehenden Geburtstage finden. Trick: vergleiche nur Tag und Monat, nicht das Jahr. Mit dem Format m-d ist der Vergleich als String absolut zuverlässig.

<?php
$mitglieder = [
    ['name' => 'Anna', 'geburt' => '1992-05-12'],
    ['name' => 'Ben',  'geburt' => '1988-05-15'],
    ['name' => 'Clara','geburt' => '1995-12-01'],
];

$heute   = new DateTimeImmutable('today');
$inEiner = $heute->modify('+7 days');

foreach ($mitglieder as $m) {
    $tag = substr($m['geburt'], 5);    /* m-d */
    if ($tag >= $heute->format('m-d')
        && $tag <= $inEiner->format('m-d')) {
        echo $m['name'] . ' hat bald Geburtstag!' . PHP_EOL;
    }
}
?>

Lifecycle einer DateTime-Operation

Damit Sie den Ablauf einer typischen Datumsverarbeitung in Ihrer Anwendung vor Augen hast, hier eine kompakte Visualisierung. Der Pfad reicht von der Roh-Eingabe bis zur Ausgabe an den Nutzer und zeigt, an welchen Stellen die Zeitzone eine Rolle spielt.

flowchart TD
    A[User Input oder DB] --> B[parse mit DateTimeImmutable]
    B --> C[Validierung]
    C --> D[Zeitzone setzen]
    D --> E[format Ausgabe]

Wichtig ist, dass jeder Pfeil eine bewusste Entscheidung darstellt. Beim Parsen entscheiden Sie, in welcher Zeitzone der Eingabewert gemeint ist. Beim Formatieren entscheiden Sie, in welcher Zeitzone der Nutzer das Ergebnis sehen soll. Wer diese beiden Schritte trennt, vermeidet die berüchtigten "eine Stunde daneben"-Bugs.

Sommerzeit und Winterzeit als Bug-Quelle

Zweimal im Jahr passiert in Mitteleuropa etwas, das Datumsbibliotheken weltweit eine Welle von Issue-Tickets beschert: die Zeitumstellung. In der Nacht zum letzten Sonntag im März wird eine Stunde übersprungen, im Oktober eine doppelt durchlaufen. Wenn Sie das ignorierst, läuft Ihr Schichtplan irgendwann gegen die Wand.

Ein klassisches Beispiel: Sie addierst 24 Stunden auf einen Zeitstempel und erwartest dadurch den nächsten Tag zur gleichen Uhrzeit. Genau das stimmt aber nicht, wenn dazwischen die Umstellung liegt.

<?php
declare(strict_types=1);

$tz   = new DateTimeZone('Europe/Berlin');
$start = new DateTimeImmutable('2026-03-28 12:00:00', $tz);

/* Falsch: 24 Stunden addieren */
$plus24h = $start->modify('+24 hours');
echo $plus24h->format('d.m.Y H:i'); /* 29.03.2026 13:00 */

/* Richtig: einen ganzen Tag addieren */
$plus1Tag = $start->modify('+1 day');
echo $plus1Tag->format('d.m.Y H:i'); /* 29.03.2026 12:00 */
?>

Die Faustregel lautet: für Kalenderoperationen wie "morgen, nächste Woche, in einem Monat" arbeiten Sie mit Tag-, Wochen- oder Monatsangaben. Für physikalische Zeitspannen wie "in genau 3600 Sekunden" arbeiten Sie mit Sekunden oder UTC. Wenn Sie sich an diese Trennung hältst, sind Sommerzeitprobleme erledigt, bevor sie auftauchen.

Fluent-Interface mit DateTimeImmutable

Eine der angenehmsten Eigenschaften von DateTimeImmutable ist die flüssige Verkettung von Methoden. Da jede Methode ein neues Objekt zurückgibt, können Sie Berechnungen lesbar in einer Zeile zusammenstellen. Vergleichbares gibt es bei Closures und in modernen Arrow Functions.

<?php
declare(strict_types=1);

/* Letzter Werktag des aktuellen Monats um 17:00 */
$deadline = (new DateTimeImmutable('first day of next month'))
    ->modify('-1 day')
    ->modify('previous weekday')
    ->setTime(17, 0);

echo $deadline->format('l, d.m.Y H:i');

/* Gleicher Wochentag in vier Wochen, 9 Uhr */
$termin = (new DateTimeImmutable('next monday'))
    ->modify('+4 weeks')
    ->setTime(9, 0);

echo $termin->format('d.m.Y H:i');
?>

Setzen Sie diese Schreibweise gezielt ein und nicht inflationär. Drei bis vier Methoden in einer Kette sind übersichtlich, danach leidet die Lesbarkeit. Bei mehr Schritten bricht Sie in Teilvariablen mit sprechenden Namen auf, dann lesen sich der Code wie deutsche Prosa und ein Kollege im Code-Review versteht ihn ohne Rückfrage.

Praxisbeispiele

Die folgenden Beispiele zeigen typische Aufgaben, die in Webprojekten häufig vorkommen.

Alter aus dem Geburtsdatum berechnen

<?php
$geburtstag = new DateTimeImmutable('1990-07-25');
$heute      = new DateTimeImmutable();

$alter = $geburtstag->diff($heute);
echo 'Alter: ' . $alter->y . ' Jahre';
/* z.B.: Alter: 35 Jahre */
?>

Die Eigenschaft y des DateInterval-Objekts liefert die Anzahl vollständiger Jahre. Damit lässt sich das Alter zuverlässig ermitteln, unabhängig von Schaltjahren.

Countdown bis zu einem Ereignis

<?php
$silvester = new DateTimeImmutable('2026-12-31 23:59:59');
$jetzt     = new DateTimeImmutable();

$rest = $jetzt->diff($silvester);

echo 'Noch ' . $rest->m . ' Monate und '
    . $rest->d . ' Tage bis Silvester.';
/* z.B.: Noch 10 Monate und 14 Tage bis Silvester. */
?>

Alle Montage eines Monats ermitteln

<?php
$start = new DateTimeImmutable('first Monday of March 2026');
$ende  = new DateTimeImmutable('last day of March 2026');

$woche = new DateInterval('P7D');
$zeitraum = new DatePeriod($start, $woche, $ende);

foreach ($zeitraum as $montag) {
    echo $montag->format('d.m.Y (l)');
}
/* Ausgabe: */
/* 02.03.2026 (Monday) */
/* 09.03.2026 (Monday) */
/* 16.03.2026 (Monday) */
/* 23.03.2026 (Monday) */
/* 30.03.2026 (Monday) */
?>

Dieses Muster lässt sich beliebig anpassen – etwa um alle Freitage oder den ersten Mittwoch jedes Monats zu finden. Die Kombination aus DatePeriod und relativen Datumsausdrücken macht solche Aufgaben besonders elegant.

Datum für eine MySQL-Datenbank vorbereiten

<?php
/* Eingabe aus einem HTML-Formular (deutsches Format) */
$eingabe = '15.03.2026';

$datum = DateTimeImmutable::createFromFormat(
    'd.m.Y',
    $eingabe,
    new DateTimeZone('Europe/Berlin')
);

if ($datum !== false) {
    /* In UTC umwandeln und als MySQL-Format ausgeben */
    $utc = $datum->setTimezone(new DateTimeZone('UTC'));
    echo $utc->format('Y-m-d H:i:s');
    /* Ausgabe: 2026-03-14 23:00:00 */
} else {
    echo 'Ungültiges Datum.';
}
?>

Dieser Ablauf – Eingabe parsen, in UTC umwandeln und im MySQL-Format speichern – ist ein bewährtes Muster für internationale Webanwendungen. Bei der Ausgabe an den Nutzer wird der Vorgang umgekehrt: UTC aus der Datenbank lesen und in die lokale Zeitzone umrechnen.

Zusammenfassung

PHP bietet ein breites Spektrum an Werkzeugen für die Arbeit mit Datum und Zeit. Für einfache Formatierungsaufgaben genügt die prozedurale Funktion date() in Kombination mit time() und strtotime(). Sobald Berechnungen, Zeitzonenkonvertierungen oder Vergleiche erforderlich sind, sollten Sie auf die objektorientierte DateTime-Klasse zurückgreifen.

Für neuen Code empfiehlt sich DateTimeImmutable als Standard, da sie unbeabsichtigte Änderungen an bestehenden Datumsobjekten verhindert. Mit DateInterval lassen sich Zeiträume präzise definieren, und DatePeriod ermöglicht die Iteration über Datumsreihen. Für den deutschsprachigen Raum ist es wichtig, die Zeitzone Europe/Berlin zu setzen und für lokalisierte Monatsnamen den IntlDateFormatter zu verwenden.

Internationale Anwendungen profitieren davon, Datumswerte intern in UTC zu speichern und erst bei der Ausgabe in die lokale Zeitzone umzurechnen. Wer darüber hinaus Komfortfunktionen wie lesbare Zeitdifferenzen oder erweiterte Lokalisierung benötigt, findet in der Bibliothek Carbon eine bewährte Ergänzung.