PHP 8.5 dostępny w cyber_Folks. Zobacz, co się zmienia

Światowa premiera PHP 8.5, zaplanowana na 20 listopada 2025 roku przynosi szereg usprawnień dla użytkownika. Z najnowszej wersji interpretera PHP możesz już korzystać w cyber_Folks na serwerach VPS i dedykowanych. Wersja 8.5 oferuje nowe funkcje ułatwiające tworzenie aplikacji webowych. W porównaniu z PHP 8.4, które już samo w sobie przyniosło znaczące ulepszenia m.in. dalszą poprawę wydajności JIT, rozbudowę typowania oraz usprawnienia w Fiberach, PHP 8.5 idzie o krok dalej, koncentrując się na stabilności, automatyzacji i zwiększeniu ergonomii kodu.

Z tego artykułu dowiesz się:

PHP 8.5 – co się zmienia?

PHP 8.5 to kolejna odsłona języka PHP, w której skupiono się na poprawie wydajności, wzbogaceniu języka o nowe konstrukcje, lepszej ergonomii programowania oraz narzędziach ułatwiających rozwój i utrzymanie aplikacji webowych.

W porównaniu z wersją 8.4, która przyniosła m.in. rozszerzenia w mechanizmach typowania, własności klas i mechanizmach wewnętrznych języka – PHP 8.5 skupia się na dalszym podnoszeniu jakości środowiska developerskiego. Wśród głównych nowości znajdziemy operator pipe (|>), nowe funkcje tablicowe (array_first, array_last), ulepszoną obsługę błędów fatalnych, dostęp do bieżącego error/exception handlera i lepszą interoperacyjność z API URL zgodnymi ze standardami RFC 3986/WHATWG.

Choć nie dokonuje rewolucji w języku, to właśnie dzięki tym usprawnieniom kod staje się czytelniejszy, bardziej funkcyjny i prostszy dodebugowania. 

Światowa premiera PHP 8.5 zaplanowana jest na 20 listopada 2025 roku.

PHP 8.5 kontynuuje trend przyspieszania działania aplikacji, wprowadzając kolejne optymalizacje, które realnie skracają czas wykonywania skryptów. Z naszych testów wynika, że PHP 8.5 działa średnio o 19% szybciej niż PHP 8.4, co wprost przekłada się na krótszy czas ładowania stron. A szybciej ładująca się strona to zadowolony użytkownik. Badania pokazują, że nawet niewielkie opóźnienia potrafią wpływać na poziom frustracji i porzucanie witryn. Zwiększona wydajność PHP 8.5 przekłada się więc bezpośrednio na:

• lepsze doświadczenia użytkowników,
• niższy współczynnik odrzuceń,
• dłuższy czas spędzany na stronie,
• wyższą konwersję.

Google premiuje strony, które ładują się szybko i oferują użytkownikom płynne, komfortowe korzystanie z witryny. Wydajność serwisu stała się więc jednym z istotnych elementów branych pod uwagę w rankingach wyszukiwarki.

Operator Pipe (|>) – czytelne łańuchowanie wywołań funkcji

PHP 8.5 wprowadza operator pipe (|>), który umożliwia tworzenie bardziej przejrzystych łańcuchów wywołań funkcji oraz przetwarzanie wartości w formie „strumienia”. To jedna z najbardziej docenianych nowości, szczególnie tam, gdzie stosuje się wiele transformacji jednej wartości.

Operator działa tak, że wynik wyrażenia po lewej stronie jest automatycznie przekazywany jako argument do funkcji znajdującej się po prawej stronie. Dzięki temu kod staje się czytelniejszy i łatwiejszy do debugowania niż w przypadku zagnieżdżonych wywołań.

$result = "Hello World"
    |> strtoupper(...)
    |> str_shuffle(...)
    |> trim(...);

// "LWHO LDLROE"

źródło: php.watch/versions/8.5/pipe-operator

Placeholder (...) określa miejsce, w którym zostanie wstawiona wartość przekazywana z lewej strony operatora. Nie tworzy on first-class callable, lecz stanowi specjalną składnię wywołania funkcji z placeholderem. Podczas kompilacji PHP optymalizuje takie łańcuchy do kodu porównywalnego z tradycyjnymi wywołaniami zagnieżdżonymi.

Pułapki i ograniczenia operatora pipe (|>)

Choć operator pipe w PHP 8.5 znacząco poprawia czytelność kodu i pozwala budować wyraźne „strumienie” przetwarzania danych, ma też szereg ograniczeń, o których warto pamiętać. Znajomość tych pułapek uchroni programistów przed błędami i nieoczywistymi zachowaniami aplikacji.

1. Tylko jeden wymagany argument w funkcji

Pipe operator działa poprawnie wyłącznie wtedy, gdy callable po prawej stronie może przyjąć dokładnie jeden wymagany parametr. Powód jest prosty — pipe zawsze przekazuje wartość jako pierwszy argument i nie da się zmienić jego pozycji.

Przykład niedozwolony:

"abc" |> strpos(..., "b"); 
// Błąd — strpos wymaga dwóch parametrów

Jeśli funkcja przyjmuje więcej parametrów niż jeden, pozostałe muszą mieć wartości domyślne.

2. Brak wsparcia dla funkcji wymagających argumentów przez referencję

Pipe operator działa na wartościach pośrednich bez zapisywania ich do zmiennej.
Przez to nie współpracuje z funkcjami, które wymagają przekazania argumentu przez referencję:

explode("-", "a-b-c") |> array_pop(...);
// Error: param musi być przekazany przez referencję

Wyjątek: funkcje oznaczone @prefer-ref. Są tylko dwie takie funkcje w core PHP:

• array_multisort()
• extract()

One przyjmują referencję opcjonalnie, dlatego działają:

['foo' => 'bar'] |> extract(...);
// OK

3. Nie zmienisz kolejności podstawiania argumentu

Pipe operator zawsze traktuje wartość z lewej strony jako pierwszy argument funkcji. Nie ma sposobu, aby wstrzyknąć ją jako drugi czy trzeci parametr.

Nie zadziała:

"Hello" |> str_replace("H", "J", ...);
// PHP wstawi "Hello" na pierwsze miejsce → błędne wywołanie

4. Funkcje bez parametrów zwykle nie zadziałają

Wbudowane funkcje, które nie przyjmują żadnych parametrów, nie mogą być użyte w pipe chain.

Dla tych funkcji PHP po prostu zignoruje przekazany argument — ale to prowadzi do trudnych do wykrycia błędów.

"Hello" |> phpinfo(...); 
// Działa… ale całkowicie ignoruje "Hello"

5. Callables z void zwracają null – i „psują” dalszy łańcuch

Funkcja zwracająca void może być użyta, ale przekazuje dalej null.
Jeśli pojawi się w środku łańcucha, reszta operacji będzie wykonywana na null.

$result = "Hello"
    |> logger(...)   // void → null
    |> strtoupper(...); // strtoupper(null) → TypeError przy strict_types=1

Dlatego void callables stosujemy tylko na końcu.

6. Operator pipe ma nietypową precedencję

To jedna z bardziej podchwytliwych rzeczy:

• najpierw wykonują się działania arytmetyczne, null-coalesce i ternary,
• dopiero potem pipe.

Przykład:

echo 10 + 6 |> dechex(...) |> hexdec(...);
// wynik: 16

Natomiast z nawiasami:

echo 10 + (6 |> dechex(...)) |> hexdec(...);
// wynik: 22

Złe nawiasowanie może całkowicie zmienić logikę kodu…

7. Brak kompatybilności wstecznej

Kod korzystający z pipe operatora:

$value |> strtoupper(...);

podczas uruchomienia w PHP 8.4 lub starszym:

Parse error: syntax error, unexpected token ">"

8. Pipe nie jest szybszy – tylko czytelniejszy

Pipe operator nie wprowadza żadnych usprawnień wydajnościowych. PHP kompiluje go do opcodów niemal identycznych ze standardowymi wywołaniami funkcji.

Dzięki mechanizmowi copy-on-write, pipe nie zużywa dodatkowej pamięci i działa tak samo wydajnie jak przypisania do tej samej zmiennej. To ważne sprostowanie dla developerów zakładających, że nowy operator „przyspieszy kod”.

Funkcje tablicowe array_first() i array_last()

PHP 8.5 wprowadza dwie nowe funkcje tablicowe: array_first() i array_last(), umożliwiające szybki i czytelny dostęp do pierwszego lub ostatniego elementu tablicy. Stanowią one naturalne uzupełnienie funkcji array_key_first() i array_key_last(), które pojawiły się w PHP 7.3 – jednak tym razem operujemy bezpośrednio na wartościach, a nie kluczach.

Do tej pory, aby pobrać pierwszy lub ostatni element tablicy, programiści musieli stosować mniej intuicyjne konstrukcje, takie jak reset(), end() czy indeksowanie ręczne. Prowadziło to często do obniżenia czytelności, ryzyka modyfikacji wskaźnika tablicy lub błędów typu undefined offset.

Nowe funkcje pozwalają pisać kod w sposób bardziej czytelny i bezpieczny:

• pobierają pierwszą lub ostatnią wartość z tablicy,
• umożliwiają użycie opcjonalnego callbacka filtrującego,
• pozwalają określić wartość domyślną, zwracaną przy pustej tablicy lub braku dopasowania.

Dzięki temu praca z tablicami staje się prostsza, a kod bardziej odporny na błędy.

array_first()

Zwraca pierwszą wartość z tablicy. Jeśli tablica jest pusta lub żaden element nie przejdzie opcjonalnego filtra callbacka – funkcja zwraca null, chyba że podamy wartość domyślną.

Przykłady:

array_first([1, 2, 3]);             // 1
array_first([2, 3]);                // 2
array_first(['a' => 2, 'b' => 1]);  // 2
array_first([null, 2, 3]);          // null
array_first([]);                    // null
array_first([$obj, 2, 3]);          // $obj
array_first([1]);                   // 1
array_first([true]);                // true

array_last()

Zwraca ostatnią wartość tablicy.
Działa analogicznie do array_first(), łącznie z obsługą callbacka i wartości domyślnej.

Przykłady użycia array_last()

array_last([1, 2, 3]);             
// 3

array_last([2, 3]);                
// 3

array_last(['a' => 2, 'b' => 1]);  
// 1

array_last([null, 2, 3]);          
// 3

array_last([]);                    
// null (tablica pusta)

array_last([$obj, 2, 3]);          
// 3

array_last([1]);                   
// 1

array_last([false]);               
// false

array_last([true, false, true]);   
// true

Przykłady użycia callbacków i wartości domyślnej

To właśnie callback i default value są największą przewagą nowych funkcji nad starszymi metodami:

array_first([0, null, false, 5], fn($x) => $x);   
// 5  — pierwsza wartość

array_last([1, 3, 6, 9], fn($x) => $x % 3 === 0);  
// 9 — ostatnia wartość podzielna przez 3

array_first([], null, default: 'brak');  
// 'brak' — wartość domyślna przy pustej tablicy

Funkcje get_error_handler() i get_exception_handler()

PHP od wielu lat umożliwia definiowanie własnych procedur obsługi błędów i wyjątków, które uruchamiają się w momencie wystąpienia błędu lub nieprzechwyconego wyjątku. Można je także nadpisywać i przywracać poprzednie ustawienia, co zapewnia elastyczność obsługi błędów w aplikacjach.

Do wersji PHP 8.4 brakowało jednak sposobu, aby sprawdzić, jaki handler jest aktualnie aktywny. Programiści mogli ustawiać własne funkcje, ale nie byli w stanie łatwo odpytać środowiska o bieżącą konfigurację, co utrudniało debugowanie oraz pisanie zaawansowanych frameworków i narzędzi.

PHP 8.5 uzupełnia tę lukę, wprowadzając dwie nowe funkcje introspekcyjne:

• get_error_handler()
• get_exception_handler()

Obie funkcje umożliwiają programistom sprawdzenie aktualnie aktywnych handlerów bez stosowania obejść czy manipulowania globalnym stanem. To duże ułatwienie przy debugowaniu, testach jednostkowych oraz implementacji systemów logowania i monitoringu.

get_error_handler()

Funkcja zwraca aktualnie ustawiony handler błędów PHP. Może to być:

• nazwa funkcji (string),
• tablica [object, method],
• obiekt z metodą __invoke(),
• instancja Closure,
• null, jeżeli używany jest domyślny mechanizm PHP.

set_error_handler(fn() => null);
get_error_handler(); // object(Closure)#1 (3) {...}

żródło: php.watch/versions/8.5/get_error_handler-get_exception_handler

get_exception_handler()

Analogicznie funkcja ta zwraca aktualnie ustawiony handler wyjątków ustawiony przez set_exception_handler().
Może to być:

• nazwa funkcji,
• tablica [object, method],
• obiekt wywoływalny (__invoke()),
• instancja Closure,
• null, jeśli PHP korzysta z domyślnego handlera wyjątków.

set_error_handler(fn() => null);
get_error_handler(); // object(Closure)#1 (3) {...}

żródło: php.watch/versions/8.5/get_error_handler-get_exception_handler

Co zyskują programiści?

Dzięki tym funkcjom:

• łatwiej jest debugować zachowanie aplikacji w przypadku błędów,
• frameworki mogą introspekować swoje wewnętrzne mechanizmy obsługi błędów,
• narzędzia monitorujące (np. APM, loggery) mogą sprawdzać, czy handler został nadpisany,
• można unikać konfliktów między bibliotekami nadpisującymi handler.

To niewielka, ale bardzo praktyczna zmiana, szczególnie dla twórców frameworków, środowisk uruchomieniowych i narzędzi deweloperskich.

Stack trace dla fatalnych błędów

Stack trace to jedna z najważniejszych informacji diagnostycznych w PHP. Pozwala prześledzić kolejność wywołań funkcji, metod i plików, które doprowadziły do błędu. W dużych aplikacjach, wielowarstwowych frameworkach i systemach produkcyjnych ma to kluczowe znaczenie podczas śledzenia źródeł problemów.

W PHP 8.5 mechanizm ten został znacząco usprawniony:
fatalne błędy (tzw. “fatal errors” – E_ERROR) otrzymują pełny, czytelny stack trace, zamiast skróconych lub niepełnych informacji, jakie PHP dostarczał we wcześniejszych wersjach.

Dzięki temu programiści otrzymują znacznie lepszy wgląd w to, co doprowadziło do krytycznego błędu, a diagnoza problemów staje się szybsza i prostsza.

Powiązanie z nowymi funkcjami

Ulepszenia te współpracują z innymi funkcjami wprowadzonymi w PHP 8.5, takimi jak:

• get_error_handler()
• get_exception_handler()

Dzięki nim programista może sprawdzić, jakie handlery są aktywne i jak zachowa się aplikacja w momencie błędu. To szczególnie pomocne przy debugowaniu frameworków i bibliotek, które nadpisują własne mechanizmy obsługi błędów.

Klasy i funkcje powiązane z stack trace

Exception::getTrace()

Zwraca tablicę, która opisuje wszystkie wywołania funkcji i metod prowadzące do rzucenia wyjątku.
Każdy element tablicy zawiera m.in.:

• nazwę funkcji lub metody,
• klasę (jeśli dotyczy),
• plik i numer linii,
• argumenty przekazane do funkcji.

Exception::getTraceAsString()

Zwraca stack trace w formie tekstowej (string), gotowy do logowania.
To czytelniejsza wersja śledzenia, popularna w systemach logowania i monitoringu.

debug_backtrace()

Funkcja uruchamiana w dowolnym miejscu kodu, nie tylko w kontekście błędów lub wyjątków.
Dzięki temu można pobrać bieżący stack trace np. podczas logowania, testów lub inspekcji przepływu danych w aplikacji.

Linia poleceń php –ini=diff

PHP 8.5 wprowadza nową opcję linii poleceń: --ini=diff, która znacząco ułatwia analizowanie konfiguracji środowiska. Po uruchomieniu interpreter porównuje bieżące ustawienia konfiguracyjne z domyślnymi wartościami wbudowanymi w PHP i wyświetla jedynie te dyrektywy, które zostały zmienione.

To ogromne ułatwienie zarówno dla programistów, jak i administratorów, którzy dotychczas musieli ręcznie porównywać pliki konfiguracyjne albo stosować zewnętrzne narzędzia. Dzięki php --ini=diff można natychmiast ustalić:

• które opcje z php.ini zostały zmodyfikowane,
• które zmiany pochodzą z dodatkowych plików konfiguracyjnych (np. conf.d),
• jakie ustawienia zostały nadpisane na poziomie modułów,
• oraz jakie dyrektywy zostały nadane za pomocą parametrów CLI (php -d foo=bar).

Opcja ta jest szczególnie przydatna podczas:

• diagnostyki problemów środowiskowych,
• porównywania konfiguracji między serwerami,
• debugowania różnic między środowiskami dev/stage/prod,
• audytu bezpieczeństwa i wydajności.

Dzięki temu narzędziu łatwo zauważyć różnice typu:

• inne memory_limit,
• zmienione error_reporting,
• ręcznie ustawione disable_functions,
• niestandardowe limity, ścieżki i flagi.

--ini=diff to niewielkie, ale bardzo praktyczne udogodnienie, które potrafi zaoszczędzić wiele czasu podczas administracji serwerem lub troubleshooting aplikacji.

Nowa dyrektywa max_memory_limit – twardy sufit dla memory_limit

Jedną z praktycznych nowości w PHP 8.5 jest wprowadzenie dyrektywy max_memory_limit, która pozwala ustawić globalny, nieprzekraczalny limit pamięci dla skryptów PHP. To rozszerzenie istniejącego mechanizmu memory_limit, ale działające jako twardy sufit, którego nie można przekroczyć nawet przy użyciu ini_set().

Dlaczego to ważne?

memory_limit od lat określa, ile maksymalnie pamięci może zużyć pojedyncze żądanie PHP.
Co istotne – jest to dyrektywa typu INI_ALL, co oznacza że:

• można ją ustawić w php.ini,
• można ją ustawić w plikach konfiguracyjnych modułów,
• można ją zmieniać parametrami CLI,
• można ją zmieniać w trakcie działania skryptu (ini_set()).

Ustawienie memory_limit = -1 całkowicie wyłączało limit, co bywało ryzykowne – szczególnie na hostingach współdzielonych, w kontenerach i środowiskach o ograniczonych zasobach.

PHP 8.5 rozwiązuje ten problem.

Czym jest max_memory_limit?

max_memory_limit to globalny limit pamięci, którego nie można przekroczyć.
Działa jak górny pułap dla memory_limit.

Najważniejsze cechy:

• domyślnie ustawione na -1 (czyli limit wyłączony – zachowuje kompatybilność),
• nie można zmieniać w trakcie działania skryptu, ponieważ to dyrektywa typu INI_SYSTEM,
• każda próba ustawienia memory_limit powyżej tej wartości kończy się:
  • ostrzeżeniem,
  • przycięciem wartości do max_memory_limit.

To daje pełną kontrolę administracyjną nad pamięcią, nawet jeśli aplikacja próbuje „ominąć” limity za pomocą ini_set().

Przykład działania

Załóżmy, że administrator ustawił:

max_memory_limit = 256M
memory_limit = 128M

Sprawdzenie wartości:

ini_get('max_memory_limit'); // "256M"
ini_get('memory_limit');     // "128M"

Zwiększenie memory_limit w dopuszczalnym zakresie

ini_set('memory_limit', '156M'); // OK – 156M < 256M
ini_set('memory_limit', '256M'); // OK – równe max_memory_limit

Próba ustawienia memory_limit powyżej maksymalnej wartości

ini_set('memory_limit', '300M');

Powoduje:

Warning: Failed to set memory_limit to 314572800 bytes. 
Setting to max_memory_limit instead (currently: 268435456 bytes)

memory_limit zostaje ustawione na 256M — czyli twardy limit.

Próba ustawienia „braku limitu”

ini_set('memory_limit', '-1');

Otrzymujemy:

Warning: Failed to set memory_limit to unlimited. 
memory_limit (currently: 268435456 bytes) cannot be set to unlimited 
if max_memory_limit (%d bytes) is not unlimited

PHP 8.5 na serwerach cyber_Folks. Co to oznacza?

Na naszych serwerach dedykowanych i VPS z panelem DirectAdmin dostępne jest już PHP w wersji 8.5. Nowości wprowadzone w tej wersji poprawiają wydajność aplikacji, zwiększają stabilność środowiska oraz ułatwiają pracę programistom.

Lepsza efektywność pamięci
Optymalizacje w zarządzaniu pamięcią – szczególnie przy operacjach na tablicach i podczas pracy z bardziej złożonymi strukturami – zmniejszają zużycie zasobów serwera i poprawiają ogólną responsywność aplikacji.

Mniejszy narzut obsługi błędów
Usprawnienia w mechanizmach generowania i przetwarzania błędów, w tym pełne stack trace dla fatalnych błędów, obniżają overhead serwera i ułatwiają szybkie diagnozowanie problemów.

Nowa dyrektywa max_memory_limit
Pozwala precyzyjnie kontrolować zużycie pamięci na poziomie całego systemu PHP. Dzięki temu skrypty nie mogą przekroczyć ustalonego limitu, nawet przy próbie podniesienia memory_limit w runtime, co zwiększa stabilność hostingu i chroni przed niekontrolowanym wzrostem użycia RAM.

Szybsze działanie i krótszy TTFB
Optymalizacje w interpreterze i usprawnienia w czasie wykonania skryptów sprawiają, że serwery szybciej generują odpowiedzi, co przekłada się na krótszy time-to-first-byte i lepsze wrażenia użytkowników.

Wydajniejsze debugowanie
Pełne stack trace dla błędów krytycznych oraz nowe funkcje introspekcyjne (get_error_handler(), get_exception_handler()) skracają czas analizy i rozwiązywania problemów.

Usprawnienia w składni i narzędziach
Nowy operator pipe (|>), funkcje array_first() i array_last(), opcja php --ini=diff oraz nowe API URI ułatwiają pisanie krótszego, bardziej czytelnego i bezpieczniejszego kodu – co pośrednio przekłada się na wydajność aplikacji.

Aplikacje działają szybciej, stabilniej i wydajniej, a serwer zużywa mniej zasobów. PHP 8.5 to realna poprawa jakości hostingu i świetna okazja, by wycisnąć maksimum z infrastruktury – zarówno pod kątem wydajności, jak i wygody tworzenia aplikacji.

Więcej o zmianach przeczytasz na oficjalnej stronie PHP.

Źrodło:

php.watch/versions/8.5