Funkcje daty i czasu

PHP oferuje dwa główne sposoby pracy z datą i czasem:

1. Funkcje proceduralne (starsze, np. `date()`, `time()`, `strtotime()`)
2. Klasy DateTime (nowoczesne, obiektowe, zalecane od PHP 5.2+)

Era Uniksa (Unix Timestamp)

Aktualny czas, podawany jako liczba sekund, które upłynęły od nastania Ery Unixu: 1 stycznia 1970, 0:00:00 GMT.

Uniwersalny sposób reprezentacji czasu w systemach komputerowych – jedna liczba zamiast wielu składowych (rok, miesiąc, dzień, itd.).

Przykład:
- `0` = 1 stycznia 1970, 00:00:00 GMT
- `1000000000` = 9 września 2001, 01:46:40 GMT
- `1700000000` = 14 listopada 2023, 22:13:20 GMT

time()

Zwraca aktualny uniksowy znacznik czasu

$teraz = time();
echo $teraz; // np. 1714481247

// Za tydzień (7 dni * 24 godziny * 60 minut * 60 sekund)
$zaTydzien = time() + (7 * 24 * 60 * 60);
echo $zaTydzien;

date()

Formatuje lokalny czas/datę na czytelny format.

string date ( string $format [, int $timestamp = time() ] )

Jako $format podajemy odpowiedni schemat zapisu z tabeli poniżej, a $timestamp to znacznik czasowy – nie musimy go podawać, jest ustawiany automatycznie (jest to ilość sekund od nastania Ery Unixu: 1 stycznia 1970, 0:00:00 GMT).

Przykład:

echo date("l");                     // wyświetli Monday
echo date("m.d.y");                 // wyświetli 03.10.01
echo date("j, n, Y");               // wyświetli 10, 3, 2001
echo date('l jS \of F Y h:i:s A');  // wyświetli Monday 8th of August 2005 03:12:46 PM

echo date('Y-m-d', time()+(7*24*60*60)); //wyświetli datę za tydzień (7*24*60*60=604800 tyle sekund ma tydzień)

date() zwraca datę sformatowaną zgodnie z szablonem przedstawionym w poniższej tabeli.

Poniższych znaków używa się jako tekstu w parametrze format

getdate()

Zwraca tablicę asocjacyjną z informacjami o dacie

array getdate ([ int $timestamp = time() ] )

Funkcja zwraca tablicę asocjacyjną, a $timestamp to znacznik czasowy – nie musimy go podawać, jest ustawiany automatycznie (jest to ilość sekund od nastania Ery Unixu: 1 stycznia 1970, 0:00:00 GMT).

Przykład:

$info= getdate();
print_r($info);
echo "Dzisiaj jest {$info['mday']} {$info['month']} {$info['year']}";
// Dzisiaj jest 1 May 2024

Zostanie wyświetlone:

Array
(
    [seconds] => 45        // sekundy
    [minutes] => 30        // minuty
    [hours]   => 14        // godziny (24h)
    [mday]    => 1         // dzień miesiąca (1-31)
    [wday]    => 1         // dzień tygodnia (0=niedziela, 6=sobota)
    [mon]     => 5         // miesiąc (1-12)
    [year]    => 2024      // rok
    [yday]    => 121       // dzień roku (0-365)
    [weekday] => Monday    // nazwa dnia (ang.)
    [month]   => May       // nazwa miesiąca (ang.)
    [0]       => 1714481445 // timestamp
)

microtime()

Zwraca aktualny uniksowy znacznik czasu z mikrosekundami

mixed microtime([bool $asFloat = false])

Przykład

// Jako string (domyślnie)
echo microtime(); // "0.25163900 1714481247"

// Jako float (zalecane)
echo microtime(true); // 1714481247.2516

// Mierzenie czasu wykonania
$start = microtime(true);

// Kod do zmierzenia
for ($i = 0; $i < 1000000; $i++) {
    // jakieś operacje
}

$end = microtime(true);
$czas = $end - $start;

echo "Wykonanie trwało: " . round($czas, 4) . " sekund";

mktime()

Zwraca uniksowy znacznik czasu dla konkretnej daty

int mktime(
    int $hour = date("H"),
    int $minute = date("i"),
    int $second = date("s"),
    int $month = date("n"),
    int $day = date("j"),
    int $year = date("Y")
)

Zwraca liczbę sekund, które upłynęły od nastania Ery Unixu: 1 stycznia 1970, 0:00:00 GMT do podanej daty. Należy zwrócić uwagę na kolejność podawanych parametrów!

Poprawna kolejność parametrów to: godziny, minuty, sekundy, miesiąc, dzień, rok.

Aby wyświetlić np dzień tygodnia, w którym się urodziliście wystarczy dostosować poniższy kod

// Sprawdź dzień tygodnia swoich urodzin
$urodziny = mktime(0, 0, 0, 7, 15, 2000); // 15 lipca 2000
echo "Urodziłem się w " . date("l", $urodziny); // Saturday

// Konkretna data i czas
$sylwester = mktime(23, 59, 59, 12, 31, 2024);
echo date("Y-m-d H:i:s", $sylwester); // 2024-12-31 23:59:59

// mktime automatycznie koryguje nieprawidłowe daty
$nastepnyMiesiac = mktime(0, 0, 0, 13, 1, 2024); // miesiąc 13 -> styczeń 2025
echo date("Y-m-d", $nastepnyMiesiac); // 2025-01-01

strtotime()

Parsuje większość angielskich tekstowych opisów daty i czasu do uniksowego znacznika czasu

int strtotime ( string $czas [, int $teraz ] )

Funkcja przyjmuje tekst zawierający datę w formacie angielskim i stara się przeliczyć ją na uniksowy znacznik czasu, zachowuje się zgodnie ze składnią daty wg GNU. W przypadku fiaska, zwracane jest -1.

// Podstawowe użycie
echo strtotime("now");                    // aktualny timestamp
echo strtotime("2024-05-01");            // konkretna data
echo strtotime("01 May 2024");           // angielski format
echo strtotime("2024-05-01 14:30:00");   // data i czas

// Relatywne daty
echo strtotime("+1 day");                // jutro
echo strtotime("-1 week");               // tydzień temu
echo strtotime("+2 months");             // za 2 miesiące
echo strtotime("+1 week 2 days");        // za tydzień i 2 dni
echo strtotime("+1 week 2 days 4 hours 2 seconds");

// Słowa kluczowe
echo strtotime("next Monday");           // następny poniedziałek
echo strtotime("last Friday");           // ostatni piątek
echo strtotime("tomorrow");              // jutro
echo strtotime("yesterday");             // wczoraj
echo strtotime("midnight");              // północ dzisiaj
echo strtotime("noon");                  // południe dzisiaj

// Kombinacja
$base = strtotime("2024-01-01");
echo strtotime("+3 months", $base);      // 3 miesiące od 1 stycznia 2024

// Formatowanie wyniku
echo date("Y-m-d", strtotime("+7 days")); // data za tydzień

Lista formatów dostępna tutaj.

Klasy DateTime (nowoczesne podejście)

Zalety obiektowego podejścia:

• Łatwiejsze manipulowanie datami
• Obsługa stref czasowych
• Immutable warianty (DateTimeImmutable)
• Lepsze porównywanie dat
• Bezpieczniejsze dla dat przed 1970 i po 2038
• Czytelniejszy kod

Klasa DateTime

Tworzenie obiektu:

// Aktualna data i czas
$teraz = new DateTime();
echo $teraz->format('Y-m-d H:i:s');

// Z konkretną datą
$data = new DateTime('2024-05-01');
$data = new DateTime('2024-05-01 14:30:00');
$data = new DateTime('now');
$data = new DateTime('tomorrow');
$data = new DateTime('+1 week');

// Ze strefą czasową
$data = new DateTime('now', new DateTimeZone('Europe/Warsaw'));
$data = new DateTime('2024-05-01', new DateTimeZone('America/New_York'));

Formatowanie (format)

$data = new DateTime('2024-05-01 14:30:45');

echo $data->format('Y-m-d');           // 2024-05-01
echo $data->format('d.m.Y');           // 01.05.2024
echo $data->format('l, j F Y');        // Wednesday, 1 May 2024
echo $data->format('H:i:s');           // 14:30:45
echo $data->format('c');               // 2024-05-01T14:30:45+02:00 (ISO 8601)
echo $data->format('r');               // Wed, 01 May 2024 14:30:45 +0200 (RFC 2822)
echo $data->format('U');               // 1714481445 (timestamp)

Modyfikowanie dat (modify, add, sub)

$data = new DateTime('2024-05-01');

// modify() - używa składni strtotime
$data->modify('+1 day');
$data->modify('-2 weeks');
$data->modify('+3 months');
$data->modify('next Monday');

// add() - używa DateInterval
$data->add(new DateInterval('P1D'));      // +1 dzień
$data->add(new DateInterval('P7D'));      // +7 dni
$data->add(new DateInterval('P1M'));      // +1 miesiąc
$data->add(new DateInterval('PT2H'));     // +2 godziny
$data->add(new DateInterval('P1DT2H'));   // +1 dzień 2 godziny

// sub() - odejmowanie
$data->sub(new DateInterval('P1D'));      // -1 dzień

Format DateInterval:

• P – prefix (period)
• Y – lata (years)
• M – miesiące (months) lub minuty (po T)
• D – dni (days)
• T – separator czasu
• H – godziny (hours)
• M – minuty (minutes)
• S – sekundy (seconds)

'P1Y'        // 1 rok
'P3M'        // 3 miesiące
'P2W'        // 2 tygodnie
'P10D'       // 10 dni
'PT5H'       // 5 godzin
'PT30M'      // 30 minut
'PT45S'      // 45 sekund
'P1DT12H'    // 1 dzień i 12 godzin
'P1Y2M3DT4H5M6S' // 1 rok, 2 miesiące, 3 dni, 4 godziny, 5 minut, 6 sekund

Różnica między datami (diff)

$data1 = new DateTime('2024-01-01');
$data2 = new DateTime('2024-12-31');

$roznica = $data1->diff($data2);

echo $roznica->days;      // 365 (całkowita liczba dni)
echo $roznica->y;         // 0 (lata)
echo $roznica->m;         // 11 (miesiące)
echo $roznica->d;         // 30 (dni)
echo $roznica->h;         // 0 (godziny)
echo $roznica->i;         // 0 (minuty)
echo $roznica->s;         // 0 (sekundy)
echo $roznica->invert;    // 0 (dodatnia) lub 1 (ujemna)

// Formatowanie różnicy
echo $roznica->format('%y lat, %m miesięcy, %d dni');
// 0 lat, 11 miesięcy, 30 dni

Porównywanie dat

$data1 = new DateTime('2024-05-01');
$data2 = new DateTime('2024-06-01');

// Operatory porównania
if ($data1 < $data2) {
    echo "Data1 jest wcześniejsza";
}

if ($data1 == $data2) {
    echo "Daty są równe";
}

if ($data1 > $data2) {
    echo "Data1 jest późniejsza";
}

// Różnica w sekundach
$roznica = $data2->getTimestamp() - $data1->getTimestamp();
echo "Różnica: $roznica sekund";

DateTimeImmutable

Niemodyfikowalna wersja DateTime – każda operacja zwraca NOWY obiekt.

Zapobiega przypadkowym zmianom daty, bezpieczniejsze w kodzie współdzielonym.

// DateTime - modyfikuje oryginalny obiekt
$data = new DateTime('2024-05-01');
$nowData = $data->modify('+1 day');
echo $data->format('Y-m-d');      // 2024-05-02 (zmieniona!)
echo $nowData->format('Y-m-d');   // 2024-05-02 (ta sama!)

// DateTimeImmutable - tworzy nowy obiekt
$data = new DateTimeImmutable('2024-05-01');
$nowData = $data->modify('+1 day');
echo $data->format('Y-m-d');      // 2024-05-01 (NIEzmieniona!)
echo $nowData->format('Y-m-d');   // 2024-05-02 (nowy obiekt!)

Strefy czasowe (DateTimeZone)

// Tworzenie z konkretną strefą
$warszawa = new DateTime('now', new DateTimeZone('Europe/Warsaw'));
$newYork = new DateTime('now', new DateTimeZone('America/New_York'));

echo $warszawa->format('Y-m-d H:i:s T'); // 2024-05-01 14:30:00 CEST
echo $newYork->format('Y-m-d H:i:s T');  // 2024-05-01 08:30:00 EDT

// Zmiana strefy czasowej
$data = new DateTime('2024-05-01 14:30:00', new DateTimeZone('UTC'));
echo $data->format('Y-m-d H:i:s T'); // 2024-05-01 14:30:00 UTC

$data->setTimezone(new DateTimeZone('Europe/Warsaw'));
echo $data->format('Y-m-d H:i:s T'); // 2024-05-01 16:30:00 CEST

// Lista wszystkich stref czasowych
$zones = DateTimeZone::listIdentifiers();
print_r($zones);
// ['Africa/Abidjan', 'Africa/Accra', ..., 'Europe/Warsaw', ...]

Tworzenie DateTime z timestamp

$timestamp = 1714481247;

// Sposób 1
$data = new DateTime();
$data->setTimestamp($timestamp);

// Sposób 2 (lepszy)
$data = (new DateTime())->setTimestamp($timestamp);

// Sposób 3 (najlepszy w PHP 5.3+)
$data = DateTime::createFromFormat('U', $timestamp);

echo $data->format('Y-m-d H:i:s');

Tworzenie DateTime z formatu niestandardowego

// Parsowanie niestandardowego formatu
$data = DateTime::createFromFormat('d/m/Y', '01/05/2024');
echo $data->format('Y-m-d'); // 2024-05-01

$data = DateTime::createFromFormat('d.m.Y H:i', '01.05.2024 14:30');
echo $data->format('Y-m-d H:i:s'); // 2024-05-01 14:30:00

// Z wykrywaniem błędów
$data = DateTime::createFromFormat('Y-m-d', 'nieprawidłowa-data');
if ($data === false) {
    $errors = DateTime::getLastErrors();
    print_r($errors);
}

Przykłady:

Liczenie czasu generowania strony

$start = microtime(true);

// Kod do zmierzenia
for ($i = 0; $i < 10000; $i++) {
    $str = 'test';
}

$end = microtime(true);
echo 'Strona wygenerowana w ' . round($end - $start, 4) . ' sekund';

//Nowoczesny sposób
$start = new DateTimeImmutable();

// Kod do zmierzenia
for ($i = 0; $i < 10000; $i++) {
    $str = 'test';
}

$end = new DateTimeImmutable();
$roznica = $start->diff($end);

echo 'Strona wygenerowana w ' . $roznica->format('%s.%f sekund');

Tworzenie daty o godzinę w przód

$czas_akt = time();
$za_godz = $czas_akt + 3600;
echo date("r", $za_godz); // Wyświetli datę 'za godzinę'           

Data „za miesiąc”

$day = date('d');
$month = date('m');
$year = date('Y');

$month++;

if ($month == 13) {
    $month = 1;
    $year++;
}

echo "$day.$month.$year";

//Nowoczesny sposób
$data = new DateTime();
$data->modify('+1 month');
echo $data->format('d.m.Y');

// Lub z add()
$data = new DateTime();
$data->add(new DateInterval('P1M'));
echo $data->format('d.m.Y');

Odliczanie czasu do konkretnego wydarzenia:

function CountDown($hour, $minute, $second, $month, $day, $year) {
    $eventDate = mktime($hour, $minute, $second, $month, $day, $year);
    $today = time();
    $secondsTo = $eventDate - $today;
    
    $minutesTo = round($secondsTo / 60);
    $hoursTo = round($minutesTo / 60);
    $daysTo = round($hoursTo / 24);
    $weeksTo = round($daysTo / 7);
    $monthsTo = round($weeksTo / 4);
    $yearsTo = round($monthsTo / 12);
    
    return [
        'seconds' => $secondsTo,
        'minutes' => $minutesTo,
        'hours' => $hoursTo,
        'days' => $daysTo,
        'weeks' => $weeksTo,
        'months' => $monthsTo,
        'years' => $yearsTo
    ];
}

$countdown = CountDown(12, 0, 0, 12, 31, 2024);
print_r($countdown);

//Nowoczesny sposób
function countDown(string $targetDate): array {
    $teraz = new DateTimeImmutable();
    $cel = new DateTimeImmutable($targetDate);
    $roznica = $teraz->diff($cel);
    
    return [
        'days' => $roznica->days,
        'hours' => $roznica->h,
        'minutes' => $roznica->i,
        'seconds' => $roznica->s,
        'formatted' => $roznica->format('%a dni, %h godz, %i min, %s sek')
    ];
}

$countdown = countDown('2024-12-31 23:59:59');
echo "Do sylwestra zostało: {$countdown['formatted']}";

Baner zależny od pory dnia

function getBannerName() {
    $hour = date("G");
    
    if ($hour > 22 || $hour < 4) {
        return "banner_noc.gif";
    } elseif ($hour >= 4 && $hour < 12) {
        return "banner_rano.gif";
    } elseif ($hour >= 12 && $hour < 18) {
        return "banner_dzien.gif";
    } else {
        return "banner_wieczor.gif";
    }
}

echo '<img src="' . getBannerName() . '">';

//Nowoczesny sposób
function getBannerName(): string {
    $teraz = new DateTime();
    $godzina = (int)$teraz->format('G');
    
    return match(true) {
        $godzina >= 22 || $godzina < 4 => 'banner_noc.gif',
        $godzina >= 4 && $godzina < 12 => 'banner_rano.gif',
        $godzina >= 12 && $godzina < 18 => 'banner_dzien.gif',
        default => 'banner_wieczor.gif'
    };
}

echo '<img src="' . getBannerName() . '" alt="Banner">';

Sprawdzanie czy daty są z tego samego dnia

function sameDay($ts1, $ts2) {
    return date("Y-m-d", $ts1) === date("Y-m-d", $ts2);
}

$date1 = mktime(19, 30, 0, 12, 10, 2024);
$date2 = mktime(10, 12, 0, 12, 10, 2024);

if (sameDay($date1, $date2)) {
    echo "Daty są z tego samego dnia";
}

//Nowoczesny sposób
unction sameDay(DateTime $date1, DateTime $date2): bool {
    return $date1->format('Y-m-d') === $date2->format('Y-m-d');
}

$date1 = new DateTime('2024-12-10 19:30:00');
$date2 = new DateTime('2024-12-10 10:12:00');
$date3 = new DateTime('2024-12-11 19:30:00');

if (sameDay($date1, $date2)) {
    echo "Daty 1 i 2 są z tego samego dnia\n";
}

if (!sameDay($date1, $date3)) {
    echo "Daty 1 i 3 NIE są z tego samego dnia\n";
}

Wiek osoby

function obliczWiek(string $dataUrodzenia): int {
    $urodziny = new DateTime($dataUrodzenia);
    $teraz = new DateTime();
    $roznica = $urodziny->diff($teraz);
    
    return $roznica->y;
}

echo "Masz " . obliczWiek('2000-07-15') . " lat";

// Z dodatkowymi informacjami
function szczegolyWieku(string $dataUrodzenia): array {
    $urodziny = new DateTime($dataUrodzenia);
    $teraz = new DateTime();
    $roznica = $urodziny->diff($teraz);
    
    return [
        'lata' => $roznica->y,
        'miesiace' => $roznica->m,
        'dni' => $roznica->d,
        'calkowite_dni' => $roznica->days,
        'formatted' => $roznica->format('%y lat, %m miesięcy, %d dni')
    ];
}

$wiek = szczegolyWieku('2000-07-15');
echo "Żyjesz już: {$wiek['formatted']} ({$wiek['calkowite_dni']} dni)";

Dni robocze między datami

function dniRoboczeMiedzy(DateTime $start, DateTime $end): int {
    $dni = 0;
    $current = clone $start;
    
    while ($current <= $end) {
        $dzienTygodnia = (int)$current->format('N'); // 1-7 (Pn-Nd)
        
        if ($dzienTygodnia < 6) { // Pn-Pt
            $dni++;
        }
        
        $current->modify('+1 day');
    }
    
    return $dni;
}

$poczatek = new DateTime('2024-05-01');
$koniec = new DateTime('2024-05-31');

echo "Dni robocze w maju 2024: " . dniRoboczeMiedzy($poczatek, $koniec);

Pierwszy i ostatni dzień miesiąca

function pierwszyDzienMiesiaca(int $miesiac, int $rok): DateTime {
    return new DateTime("$rok-$miesiac-01");
}

function ostatniDzienMiesiaca(int $miesiac, int $rok): DateTime {
    $data = new DateTime("$rok-$miesiac-01");
    $data->modify('last day of this month');
    return $data;
}

$pierwszy = pierwszyDzienMiesiaca(5, 2024);
$ostatni = ostatniDzienMiesiaca(5, 2024);

echo "Maj 2024: " . $pierwszy->format('Y-m-d') . " - " . $ostatni->format('Y-m-d');
// Maj 2024: 2024-05-01 - 2024-05-31

Czy data jest w przeszłości/przyszłości

function czyPrzeszlosc(DateTime $data): bool {
    return $data < new DateTime();
}

function czyPrzyszlosc(DateTime $data): bool {
    return $data > new DateTime();
}

$wczoraj = new DateTime('yesterday');
$jutro = new DateTime('tomorrow');

var_dump(czyPrzeszlosc($wczoraj));  // true
var_dump(czyPrzyszlosc($jutro));    // true

Zadania do wykonania:

Zadanie 1: Napisz skrypt, który będzie pokazywał aktualna datę i czas w postaci:  Dzisiaj jest 30.10.2018 godzina 16:50:47

Zadanie 2: Napisz skrypt sprawdzający w jaki dzień tygodnia się urodziłeś/łaś oraz sprawdź ile czasu zostało do twoich urodzin.

Zadanie 6: Napisz funkcję, która sprawdzi, czy podana data jest weekendem.

Zadanie 7: Napisz funkcję, która zwróci liczbę pełnych tygodni między dwiema datami.