Funkcje w PHP

Wprowadzenie do funkcji w PHP

Funkcja to wydzielony fragment kodu, który wykonuje określone zadanie i który można wielokrotnie wykorzystać w programie. Dzięki funkcjom możemy uniknąć powtarzania tych samych fragmentów kodu w różnych miejscach – zamiast tego definiujemy logikę raz, nadajemy jej nazwę i wywołujemy w razie potrzeby. Użycie funkcji poprawia czytelność i organizację kodu, ułatwia jego utrzymanie oraz testowanie.

W PHP funkcje odgrywają kluczową rolę. Język ten udostępnia setki funkcji wbudowanych (np. do obsługi ciągów znaków, pracy z bazą danych, przetwarzania dat czy operacji matematycznych). Programista może również definiować własne funkcje dostosowane do specyficznych potrzeb aplikacji. Dobrym podejściem jest stosowanie funkcji zawsze wtedy, gdy pewien fragment logiki może być wydzielony i potencjalnie wykorzystany ponownie lub gdy chcemy nadać czytelną nazwę sekwencji operacji.

Każda funkcja może przyjmować argumenty (zwane też parametrami wejściowymi) oraz może zwracać wynik swojego działania. Argumenty pozwalają przekazywać funkcji dane do przetworzenia, a mechanizm zwracania wartości umożliwia funkcji oddanie rezultatu, który może być wykorzystany dalej w programie. W kolejnych sekcjach omówimy, jak definiować własne funkcje w PHP, jak korzystać z funkcji wbudowanych, a także przedstawimy dobre praktyki związane z ich używaniem. Na koniec znajdziesz zestaw praktycznych zadań, które pomogą utrwalić zdobytą wiedzę.

Funkcje definiowane przez użytkownika

Definiowanie funkcji i argumenty

W PHP definicję nowej funkcji rozpoczynamy od słowa kluczowego function, po którym następuje nazwa funkcji oraz para nawiasów okrągłych z ewentualną listą parametrów. Na końcu znajduje się blok kodu w nawiasach klamrowych { ... }, czyli ciało funkcji zawierające instrukcje do wykonania. Prosta składnia wygląda następująco:

 function nazwaFunkcji($parametr1, $parametr2) {
    // ciało funkcji - tutaj umieszczamy kod, który zostanie wykonany przy wywołaniu funkcji
    // można użyć $parametr1 i $parametr2 wewnątrz funkcji
 }

Nazwę funkcji wybieramy samodzielnie – powinna jasno wskazywać, co dana funkcja robi. W nazwach dopuszczalne są litery (A-Z, a-z), cyfry oraz znak podkreślenia _ (nie może ona jednak zaczynać się od cyfry). Przykładowo, utwórzmy funkcję o nazwie dodaj, która oblicza sumę dwóch liczb:

 function dodaj($a, $b) {     $suma = $a + $b;
     return $suma;
 }

Powyższa funkcja dodaj przyjmuje dwa argumenty ($a i $b), sumuje je i zwraca wynik za pomocą instrukcji return (omówionej szerzej poniżej). Teraz możemy wywołać tę funkcję w kodzie, przekazując jej konkretne dwie liczby:

 $wynik = dodaj(5, 3);
 echo $wynik;  // wyświetli 8

W momencie wywołania dodaj(5, 3) wartość 5 zostaje przypisana do parametru $a, a 3 do parametru $b. Wewnątrz funkcji zmienne $a i $b są dostępne i przyjmują przekazane wartości.

Funkcje mogą także posiadać wartości domyślne parametrów. Oznacza to, że pewien argument jest opcjonalny – jeśli wywołujący funkcję go nie poda, zostanie użyta wartość domyślna zdefiniowana w deklaracji funkcji. Aby ustawić wartość domyślną, po nazwie parametru umieszczamy znak = i stałą wartość domyślną. Przykładowo:

 function przywitaj($imie = "Gość") {
     echo "Witaj, $imie!";
 }

Funkcję przywitaj() można wywołać zarówno z argumentem, jak i bez niego:

 przywitaj("Alicja");  // wyświetli: Witaj, Alicja!
 przywitaj();          // wyświetli: Witaj, Gość!

W drugim wywołaniu nie podaliśmy żadnego imienia, więc funkcja użyła wartości domyślnej "Gość". Uwaga: parametry z wartościami domyślnymi powinny znajdować się na końcu listy parametrów. Najpierw deklarujemy parametry wymagane (bez wartości domyślnej), a dopiero potem opcjonalne – pozwala to unikać niejednoznaczności podczas wywoływania funkcji.

Zasięg zmiennych i słowo kluczowe global

Każda zmienna w PHP ma określony zasięg (scope), czyli obszar programu, w którym jest widoczna. Zmienne utworzone wewnątrz funkcji są lokalne dla tej funkcji – nie można odwołać się do nich poza ciałem tej funkcji. Analogicznie, zmienne zdefiniowane poza funkcją (w tzw. zasięgu globalnym) nie są bezpośrednio dostępne wewnątrz funkcji. Aby przekazać dane do funkcji, należy użyć argumentów w wywołaniu lub specjalnych mechanizmów (jak słowo kluczowe global).

Przykład ilustrujący zasięg zmiennych:

  $x = 10;       // zmienna globalna
  function pokazX() {
      echo $x;
  }
  pokazX();  // Notice: Undefined variable: x

W powyższym kodzie próba wyświetlenia $x wewnątrz funkcji zakończyła się błędem, ponieważ $x zdefiniowane na zewnątrz nie jest widoczne wewnątrz pokazX(). Poprawnym sposobem jest przekazanie wartości przez argument:

 $x = 10;
 function pokazLiczbe($liczba) {
     echo $liczba;
 }
 pokazLiczbe($x);  // poprawne wywołanie, wyświetli 1

PHP oferuje również obejście w postaci słowa kluczowego global, które pozwala wewnątrz funkcji odwołać się do zmiennych zdefiniowanych w zasięgu globalnym. Jeśli zadeklarujemy wewnątrz funkcji global $x;, wówczas zmienna $x z przestrzeni globalnej stanie się dostępna lokalnie:

 $x = 10; function pokazXGlobal() {
     global $x;
     echo $x;
 }
 pokazXGlobal();  // wyświetli 10

Deklaracja global $x; spowodowała, że referencja do globalnej zmiennej $x została włączona do lokalnego zasięgu funkcji. Należy jednak korzystać z tego mechanizmu ostrożnie.

Uwaga: Używanie zmiennych globalnych jest na ogół odradzane w większych programach. Nadużywanie global utrudnia śledzenie przepływu danych i zależności w kodzie, co może prowadzić do błędów trudnych do zlokalizowania. Zamiast polegać na globalnych zmiennych, lepiej przekazywać potrzebne wartości do funkcji przez parametry i zwracać wyniki za pomocą return. Dzięki temu kod jest bardziej przejrzysty i modułowy.

Typowanie argumentów i wartości zwracanej

PHP jest językiem o dynamicznym typowaniu, co oznacza że zmienne mogą przechowywać dane różnych typów (liczby, ciągi znaków, tablice itd.) i typ może zmieniać się w trakcie działania programu. Od wersji PHP 7 wprowadzono jednak możliwość jawnego określania typów argumentów i wartości zwracanej przez funkcję. Dzięki temu kod staje się bardziej odporny na błędy i łatwiejszy do zrozumienia, ponieważ z góry wiadomo, jakiego typu danych funkcja oczekuje i co zwraca.

Aby zadeklarować typ parametru, wystarczy przed nazwą parametru w definicji funkcji podać typ (np. int, string, float, bool, array, nazwę klasy/obiektu itp.). Analogicznie, aby określić typ zwracanej wartości, po zamknięciu nawiasów argumentów dodajemy dwukropek : i nazwę typu. Przykłady:

 function pomnoz(int $x, int $y): int {
     return $x * $y;
 }

 function sklejNapis(string $a, string $b): string {
     return $a . $b;
 }

W powyższych funkcjach zadeklarowano, że pomnoz przyjmuje dwa argumenty typu całkowitego (int) i zwraca wartość całkowitą, zaś sklejNapis oczekuje dwóch łańcuchów znaków (string) i zwraca również łańcuch. Jeśli przy próbie wywołania funkcji zostaną przekazane dane niezgodnego typu (np. zamiast liczby całkowitej przekażemy napis "dziesięć"), PHP spróbuje dokonać automatycznej konwersji typu. Gdyby to się nie powiodło lub było niemożliwe, zostanie zgłoszony błąd (wyjątek typu TypeError).

Warto wspomnieć, że od PHP 7 można typować większość rodzajów danych, w tym typy skalarskie jak wyżej. Od PHP 7.1 dodano też typ void dla funkcji, które nie zwracają żadnej wartości (np. tylko coś wyświetlają lub zapisują do bazy). Od PHP 8 wprowadzono także możliwość definiowania tzw. typów złożonych (unii), np. function test(int|string $x): int|false { ... }, co oznacza akceptację argumentu będącego intem lub stringiem i zwracanie typu int lub false. Jednak na poziomie początkującym zwykle wystarczy podstawowe typowanie pojedynczymi typami.

Korzystanie z typowania nie jest obowiązkowe, ale jest zalecaną praktyką. Dzięki niemu wiele pomyłek (np. przekazanie złego typu danych do funkcji) zostanie wychwyconych wcześniej. W zaawansowanych przypadkach można dodatkowo włączyć tryb ścisły (strict typing), aby wyłączyć całkowicie automatyczne konwersje typów i wymagać dokładnej zgodności typów – wymaga to deklaracji declare(strict_types=1) na początku pliku. Dla naszych potrzeb na razie zakładamy domyślny tryb (łagodny), w którym drobne różnice typów mogą być konwertowane automatycznie przez PHP.

Zwracanie wartości (return)

Wiele funkcji ma za zadanie przetworzyć otrzymane argumenty i zwrócić pewien wynik. W PHP do zwracania wartości z funkcji służy słowo kluczowe return. Gdy interpretator napotka w ciele funkcji instrukcję return, przerywa wykonywanie funkcji i przekazuje wskazaną wartość jako wynik wywołania tej funkcji.

Przykład:

  function pomnozPrzezDwa($liczba) {
      $wynik = $liczba * 2;
      return $wynik;
  }
  $x = pomnozPrzezDwa(4);
  echo $x;  // wyświetli 8

Tutaj funkcja pomnozPrzezDwa zwraca wynik mnożenia argumentu przez 2. Po wywołaniu pomnozPrzezDwa(4) otrzymujemy wartość 8, która zostaje przypisana do zmiennej $x. Następnie możemy ją wykorzystać (w tym przypadku wyświetlić).

Kilka istotnych uwag dotyczących return:

  • Po wykonaniu return funkcja natychmiast się kończy. Kod znajdujący się w funkcji po tej instrukcji (o ile by istniał) nie zostanie wykonany.
  • Jeżeli funkcja ma zwracać jakąś wartość, upewnij się, że używasz return. Częsty błąd początkujących to wypisanie wyniku funkcją echo zamiast zwrócenia go – przez co poza funkcją nie można tej wartości dalej przetworzyć.
  • Funkcja, która nie zawiera żadnej instrukcji return (lub wywoła return bez podania wartości) zwróci domyślnie null. null oznacza „brak wartości”.
  • Za pomocą return można zwrócić dowolny typ danych – liczbę, string, boolean, tablicę, obiekt itp. Jeżeli chcemy zwrócić więcej niż jedną wartość, najczęściej pakuje się je w tablicę lub obiekt i zwraca taką strukturę (PHP nie pozwala zwrócić kilku oddzielnych wartości naraz inaczej niż przez opakowanie ich).
  • Użycie return nie jest obowiązkowe – jeśli nasza funkcja ma tylko wykonać pewne czynności (np. wyświetlić komunikat, zapisać coś do pliku czy bazy danych) i nie ma „wyniku” sensu stricto, może nic nie zwracać (wtedy domyślnie zwróci null). Można też jawnie zadeklarować taki zamiar poprzez typ zwracany void (wspomniany wyżej).

Argumenty zmiennej długości (...$args)

Czasami nie wiemy z góry, ile argumentów będzie potrzebować nasza funkcja. PHP umożliwia definiowanie funkcji, które przyjmują zmienną liczbę argumentów. Służy do tego składnia z trzema kropkami (...) przed ostatnim parametrem funkcji. Taki parametr nazywa się parametrem rest (wariadycznym) i traktowany jest wewnątrz funkcji jako tablica zawierająca wszystkie przekazane dodatkowe argumenty.

Przykład funkcji wykorzystującej zmienną liczbę argumentów:

 function sumaWszystkich(...$liczby) {
     $suma = 0;
     foreach ($liczby as $liczba) {
         $suma += $liczba;
     }
     return $suma;
 }

Funkcja sumaWszystkich zadziała niezależnie od tego, ile argumentów do niej przekażemy:

 echo sumaWszystkich(2, 4);       // 6
 echo sumaWszystkich(1, 2, 3, 4); // 10

W pierwszym wywołaniu $liczby wewnątrz funkcji będzie tablicą [2, 4], w drugim – [1, 2, 3, 4]. Dzięki pętli foreach funkcja dodaje kolejno wszystkie elementy tej tablicy.

Można łączyć zwykłe parametry z parametrem wariadycznym, pamiętając jednak, że parametr z ... musi być ostatni na liście. Na przykład:

 function wypiszWiele($prefix, ...$slowa) {
     foreach ($slowa as $s) {
         echo "$prefix $s\n";
     }
 }
 wypiszWiele("Hello", "World", "PHP", "funkcje");
 // Wynik:
 // Hello World
 // Hello PHP
 // Hello funkcje

Tutaj pierwszy parametr $prefix przyjmuje stały tekst, a reszta przekazanych argumentów trafia do tablicy $slowa.

Warto wspomnieć, że PHP udostępnia też mechanizm odwrotny – rozpakowywanie argumentów – czyli przekazanie zawartości tablicy jako osobnych argumentów do funkcji. Odbywa się to również za pomocą operatora ..., ale stosowanego przy wywołaniu funkcji. Przykład:

 $dane = [10, 20, 30];
 echo sumaWszystkich(...$dane); // równoważne wywołaniu sumaWszystkich(10, 20, 30)

Jednak w kontekście definiowania funkcji najważniejsze jest umiejętność przyjmowania zmiennej liczby argumentów poprzez konstrukcję ...$nazwaTablicy.

Funkcje anonimowe i strzałkowe (arrow functions)

Oprócz zwykłych, nazwanych funkcji, PHP umożliwia tworzenie funkcji anonimowych. Są to funkcje, którym nie nadano nazwy, przez co nie są wywoływane tradycyjnie poprzez nazwę, lecz traktowane jak wartość (przypisywane do zmiennych, przekazywane jako argumenty do innych funkcji itp.). Funkcje anonimowe nazywane są także domknięciami (ang. closures) i często wykorzystuje się je jako tzw. callbacki (funkcje wywoływane zwrotnie, np. przez funkcje sortujące lub przetwarzające kolekcje).

Definiowanie funkcji anonimowej przypomina definicję zwykłej funkcji, ale pomija się nazwę po słowie function. Przykład:

 $powitanie = function($imie) {
     return "Cześć, $imie!";
 };
 // wywołanie funkcji anonimowej przypisanej do zmiennej:
 echo $powitanie("Jan");  // wyświetli: Cześć, Jan!

Tutaj utworzyliśmy funkcję anonimową przyjmującą jeden parametr $imie i zwracającą sformatowany napis powitalny. Funkcja ta została przypisana do zmiennej $powitanie, co umożliwia jej późniejsze wywoływanie jak normalnej funkcji (używając $powitanie(...)). Zauważ, że po definicji wystąpił średnik ; – ponieważ cała definicja function($imie) { ... } jest wyrażeniem przypisywanym do zmiennej.

Funkcje anonimowe mogą korzystać ze zmiennych z zewnętrznego zakresu (np. spoza funkcji) za pomocą klauzuli use. Na przykład:

 $kurs = 4.5;
 $mnoznik = function($x) use ($kurs) {
     return $x * $kurs;
 };
 echo $mnoznik(10);  // wyświetli 45

Tutaj zmienna $kurs została zadeklarowana poza funkcją anonimową. Dzięki use ($kurs) wewnątrz ciała funkcji anonimowej możemy odwołać się do tej zmiennej i użyć jej wartości (zostaje ona zamknięta w kontekście funkcji anonimowej). Bez use próba użycia $kurs wewnątrz funkcji zakończyłaby się błędem (zmienna niezdefiniowana lokalnie).

Od PHP 7.4 wprowadzono wygodniejszą formę krótkich funkcji anonimowych, tzw. funkcje strzałkowe (arrow functions). Składnia funkcji strzałkowej to:

 fn(argumenty) => wyrażenie;

Funkcja strzałkowa może zawierać tylko jedno wyrażenie (bez średnika na końcu), którego wynik zostaje automatycznie zwrócony (nie używamy w niej słowa return). Funkcje strzałkowe są szczególnie przydatne dla krótkich operacji, np. przekazywanych jako callback. Przykład odpowiednika poprzedniej funkcji mnożącej, ale zapisanej jako arrow function:

$kurs = 4.5;
$mnoznikArrow = fn($x) => $x * $kurs;
echo $mnoznikArrow(10);  // wyświetli 4

Zwróć uwagę, że w arrow function nie musieliśmy używać use – zmienne z zewnętrznego zakresu (takie jak $kurs) są automatycznie dostępne wewnątrz (przekazywane przez wartość). Funkcja strzałkowa jest tutaj znacznie krótsza i czytelna dla tak prostego działania. Jej ograniczeniem jest jednak to, że nie obsłuży wielolinijkowego kodu ani bardziej złożonej logiki – do takich celów wciąż trzeba użyć tradycyjnej funkcji anonimowej lub nazwanej.

Podsumowując, funkcje anonimowe i strzałkowe pozwalają traktować logikę programu jak dane: możemy je przekazywać do innych funkcji (np. sortujących, filtrujących), przechowywać w zmiennych czy definiować wewnątrz innych funkcji. Dla początkujących ważne jest zrozumienie, że są one narzędziem do tworzenia elastycznego kodu, ale podstawy programowania funkcji najlepiej opanować najpierw na funkcjach nazwanych.

Funkcje wbudowane w PHP

PHP dostarcza bardzo bogaty zestaw funkcji wbudowanych, które są gotowe do użycia bez potrzeby pisania ich samodzielnie. Standardowa biblioteka PHP obejmuje tysiące funkcji realizujących rozmaite zadania – od prostych operacji na ciągach znaków, przez obsługę tablic, operacje matematyczne, daty i czas, po zaawansowane działania na bazach danych, plikach czy grafice. Zamiast samemu implementować daną funkcjonalność, najczęściej warto najpierw sprawdzić, czy PHP nie oferuje już odpowiedniej funkcji.

Poniżej przedstawiamy kilka kategorii wbudowanych funkcji wraz z przykładami:

Funkcje dla ciągów znaków (string)

  • strlen($tekst) – zwraca długość (liczbę znaków) w napisie.
  • strtolower($tekst) / strtoupper($tekst) – zamienia odpowiednio cały tekst na małe albo wielkie litery.
  • substr($tekst, $od, $dlugosc) – wycina fragment napisu (podciąg) zaczynając od pozycji $od (licząc od 0) o podanej długości.
  • str_replace($szukaj, $zamien, $tekst) – wyszukuje wszystkie wystąpienia podciągu $szukaj w tekście i zamienia je na $zamien, zwracając zmodyfikowany tekst.
  • explode($separator, $tekst) / implode($separator, $tablica) – rozbija tekst na tablicę, używając separatora (np. spację, przecinek), lub odwrotnie – łączy elementy tablicy w jeden string, wstawiając między nie podany separator.

Przykłady użycia funkcji ciągów znaków:

 $tekst = "Witaj Świecie";  echo strlen($tekst); // 13 (długość napisu, uwaga na  polskie znaki w UTF-8)
 echo strtolower("PHP FUNKCJE"); // "php funkcje"
 echo substr("abcdef",   2, 3);  // "cde"
 echo str_replace("Świecie", "PHP", $tekst);  // "Witaj PHP"

Funkcje tablicowe (array)

  • count($tablica) – zwraca liczbę elementów w tablicy.
  • sort($tablica) – sortuje tablicę rosnąco (zmienia kolejność elementów w przekazanej tablicy). Istnieją też warianty rsort (sortowanie malejąco) oraz funkcje sortujące z zachowaniem kluczy, np. asort, ksort.
  • array_push($tablica, $wartość) – dodaje element na koniec tablicy.
  • in_array($wartość, $tablica) – sprawdza, czy dana wartość znajduje się w tablicy (zwraca true lub false).
  • array_merge($tab1, $tab2, ...) – scala dwie lub więcej tablic w jedną.
  • array_unique($tablica) – zwraca nową tablicę bez zduplikowanych wartości (usuwa powtarzające się elementy).

Przykłady użycia funkcji tablicowych:

 $dane = [3, 1, 2];  sort($dane); print_r($dane);   // Array ( [0] => 1 [1] => 2 [2] => 3 ) 
 echo count($dane); // 3 
 array_push($dane, 5);
 print_r($dane); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 5 )
 var_dump(in_array(2, $dane)); // bool(true)

Funkcje matematyczne i numeryczne

  • abs($liczba) – wartość bezwzględna (moduł) liczby.
  • round($liczba, $precyzja) – zaokrągla liczbę do określonej liczby miejsc po przecinku (drugi argument jest opcjonalny; domyślnie 0, czyli do całości).
  • ceil($liczba) – zaokrąglenie w górę do najbliższej liczby całkowitej (np. ceil(4.1) da 5).
  • floor($liczba) – zaokrąglenie w dół (np. floor(4.9) da 4).
  • max($a, $b, ...) / min($a, $b, ...) – zwraca największą/najmniejszą z podanych wartości lub elementów tablicy (istnieją też warianty przyjmujące tablicę).
  • rand($min, $max) – zwraca losową liczbę całkowitą z zakresu od $min do $max (w PHP 7 funkcja rand jest aliasem mt_rand, od PHP 8 zaleca się użycie random_int dla kryptograficznie bezpiecznych losowości).
  • sqrt($liczba) – pierwiastek kwadratowy liczby.
  • pow($podstawa, $wykładnik) – potęgowanie (np. pow(2, 3) to 2³ = 8). W praktyce operator ** (np. 2 ** 3) może być prostszym zapisem potęgowania.

Przykłady:

 echo abs(-15);         // 15
 echo round(3.456, 2);  // 3.46
 echo max(2, 8, 5);     // 8
 echo floor(7.9);       // 7
 echo rand(1, 6);       // losowa liczba od 1 do 6 (np. 4)

Funkcje daty i czasu

  • time() – zwraca aktualny czas w postaci znacznika czasowego Unix (liczba sekund od 1 stycznia 1970 UTC).
  • date($format, $timestamp) – formatuje podany znacznik czasu (lub aktualny czas, jeśli nie podano drugiego argumentu) zgodnie z podanym formatem. Np. date("Y-m-d") zwróci aktualną datę w formacie RRRR-MM-DD.
  • strtotime($ciąg) – przekształca tekstową reprezentację daty/czasu na znacznik czasowy. Np. strtotime("2025-04-04") zwróci znacznik czasu odpowiadający północy 4 kwietnia 2025.
  • mktime($godz, $min, $sek, $mies, $dzień, $rok) – tworzy znacznik czasowy dla podanych danych (godzina, minuta, sekunda, miesiąc, dzień, rok).

Przykłady:

 echo time();  // np. 1735689600 (liczba sekund od epoki Unix)
 echo date("Y-m-d");  // np. "2025-04-04"
 $ts = strtotime("2025-12-31");
 echo date("d.m.Y", $ts);  // "31.12.2025"

PHP oferuje również obiektowy interfejs do obsługi dat (klasa DateTime), ale na poziomie podstawowym powyższe funkcje wbudowane często są wystarczające.

Inne przydatne funkcje

Na koniec warto wspomnieć o kilku przydatnych funkcjach „sprawdzających” i pomocniczych:

  • isset($zmienna) – zwraca true jeśli zmienna jest zdefiniowana i nie ma wartości null. Używane często, by upewnić się, że np. otrzymano pewne dane (sprawdzenie, czy coś istnieje).
  • empty($zmienna) – zwraca true jeśli zmienna jest niewartościowa lub pusta. Za „puste” PHP uznaje m.in. 0, 0.0, "" (pusty string), "0" (string „0”), NULL, false, pustą tablicę. Innymi słowy, empty sprawdza czy zmienna nie ma znaczącej zawartości.
  • is_numeric($x), is_string($x), is_array($x), itp. – cała rodzina funkcji sprawdzających typ zmiennej. Np. is_numeric zwraca true jeśli dana wartość jest liczbą lub napisem liczbowym, is_array sprawdza czy zmienna jest tablicą, itd.
  • var_dump($zmienna) – wyświetla strukturalną zawartość zmiennej wraz z jej typem. Bardzo przydatne do debugowania (sprawdzania, co zawiera zmienna). Np. var_dump($tablica); wypisze cały skład tablicy, a var_dump($x); poda, jaki to typ i jaka wartość.
  • print_r($zmienna) – podobna do var_dump, ale formatuje wynik nieco inaczej (często czytelniej dla tablic i obiektów, lecz bez informacji o typie prymitywnych wartości).
  • die($msg) / exit($msg) – natychmiast kończy wykonanie skryptu PHP, opcjonalnie wypisując podany komunikat. Używane np. w przypadku krytycznych błędów, gdy nie ma sensu dalej wykonywać kodu.

Przykłady działania niektórych z powyższych:

 $a = 0;
 $b = "tekst";
 $c = [1, 2, 3];
 var_dump(isset($a));       // bool(true) - $a istnieje (została zdefiniowana)
 var_dump(empty($a));       // bool(true) - $a jest "puste" (0 jest traktowane jako puste)
 var_dump(isset($nieMa));   // bool(false) - $nieMa nie zostało nigdy ustawione
 var_dump(is_string($b));   // bool(true) - $b jest typu string
 var_dump(is_array($c));    // bool(true) - $c jest tablicą

Jak widać, PHP dostarcza ogrom możliwości poprzez funkcje wbudowane. Pełną dokumentację wszystkich funkcji (opis działania, listę parametrów, przykłady użycia) znajdziesz na oficjalnej stronie PHP Manual. Dokumentacja jest dostępna w języku angielskim, a wiele części również w języku polskim. W praktyce, kiedy potrzebujesz wykonać konkretne zadanie, warto poszukać w dokumentacji lub Internecie odpowiedniej funkcji. Na stronach manuala PHP funkcje są pogrupowane kategoriami (np. funkcje tablicowe, daty, strumienie itp.), a wyszukiwarka pozwoli szybko znaleźć informacje o interesującej nas funkcji. Korzystanie z dokumentacji to kluczowa umiejętność programisty PHP.

Dobre praktyki

Nazewnictwo funkcji

Odpowiednie nazwy funkcji znacznie ułatwiają zrozumienie kodu. Powinny one jasno wskazywać, co dana funkcja robi. Najczęściej nazwy funkcji to czasowniki lub wyrażenia opisujące akcję, np. obliczSume, pobierzDane, zapiszPlik, sendEmail. Unikaj nazw zbyt krótkich lub niejednoznacznych (np. doIt – nic nie mówi o celu funkcji). Dobrą praktyką jest również konsekwencja w stylu nazewnictwa:

  • Możesz używać notacji camelCase (np. policzSrednia, znajdzElement), gdzie kolejne słowa w nazwie pisane są łącznie, a od drugiego słowa wielką literą.
  • Alternatywnie niektórzy stosują snake_case z podkreślnikami (np. policz_srednia). Ważne, by w obrębie projektu trzymać się wybranego stylu.
  • Nazwy funkcji nie powinny zaczynać się od cyfr ani kolidować z zarezerwowanymi słowami kluczowymi PHP.
  • Warto unikać polskich znaków diakrytycznych w nazwach (ogólnie przyjęło się pisać identyfikatory bez znaków narodowych, często w języku angielskim – choć w materiałach dydaktycznych, dla prostoty, używamy języka polskiego w nazwach).

Przykład złej i dobrej nazwy:

 function z() { ... } // zła nazwa - nic nie mówi
 function policzPoleKwadratu($a) { ... } // dobra nazwa - wiemy, że funkcja liczy pole kwadratu o boku $a

Unikanie efektów ubocznych

Efekt uboczny (side effect) to zmiana stanu programu lub środowiska dokonana wewnątrz funkcji, która wykracza poza jej bezpośredni wynik. Przykładem efektu ubocznego może być modyfikacja globalnej zmiennej, zapis do pliku, wysłanie danych do przeglądarki (echo/print), itp., podczas gdy głównym celem funkcji jest np. przetworzenie i zwrócenie pewnej wartości.

Dobre praktyki sugerują, aby – o ile to możliwe – funkcje unikały efektów ubocznych, a skupiały się na przetwarzaniu danych wejściowych i zwracaniu wyniku. Funkcja, która przy tych samych argumentach zawsze daje ten sam rezultat i nie wpływa na resztę systemu, nazywana jest funkcją czystą (pure function). Takie funkcje są łatwiejsze do testowania i rozumienia.

Oczywiście nie zawsze da się całkowicie wyeliminować efekty uboczne. Czasem funkcja ma właśnie za zadanie np. coś wyświetlić (co jest efektem ubocznym, bo wpływa na output programu) albo zapisać log do pliku. Ważne jednak, by:

  • Być świadomym, które funkcje wprowadzają efekty uboczne, i ograniczać ich użycie w niekontrolowany sposób.
  • Unikać nieoczekiwanej modyfikacji danych spoza funkcji. Jeśli funkcja potrzebuje jakiejś wartości, lepiej przekazać ją jako argument zamiast polegać na zmiennej globalnej wewnątrz funkcji.
  • Jeżeli funkcja zmienia stan zewnętrzny (np. globalną tablicę, obiekt przekazany przez referencję, plik na dysku), dobrze jest to zaznaczyć w jej nazwie lub dokumentacji, aby użytkownik miał jasność co do zachowania funkcji.

Przykładowo, zamiast pisać funkcję, która zarówno przetwarza dane, jak i od razu je wyświetla, lepiej rozważyć podział na dwie funkcje: jedna zwraca przetworzone dane, a druga (lub kod wywołujący) zajmuje się ich wyświetleniem. Dzięki temu część obliczeniowa jest czysta (bez efektów ubocznych), a wyświetlanie jest odseparowane.

Stosowanie się do powyższych zasad sprawi, że kod z funkcjami będzie bardziej czytelny, łatwiejszy w utrzymaniu i mniej podatny na błędy.