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 direkt ein Text in die date() Funktion eingesetzt 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 nutzt 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 genutzten Datumsfunktionen, weil sie natürlichsprachliche Ausdrücke in berechenbare Timestamps übersetzt. 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 direkt. 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 direkt 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 gesetzt 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 direkt 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.

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.