Lekcja 10: Funkcje - Definiowanie i Wywoływanie Własnych Funkcji

Witaj w dziesiątej lekcji kursu PHP! Po solidnym zrozumieniu tablic i wbudowanych funkcji tablicowych, nadszedł czas na jeden z najważniejszych konceptów w programowaniu: funkcje. Funkcje pozwalają na grupowanie zestawu instrukcji w nazwany blok kodu, który można wielokrotnie wywoływać z różnych miejsc programu. Dzięki funkcjom kod staje się bardziej modularny, zorganizowany, czytelny i łatwiejszy w utrzymaniu, ponieważ unika się powtarzania tego samego kodu (zasada DRY - Don't Repeat Yourself). W tej lekcji nauczymy się, jak definiować i wywoływać własne funkcje w PHP.

Czym jest funkcja?

Funkcja to samodzielny blok kodu, który wykonuje określone zadanie. Może przyjmować dane wejściowe (nazywane argumentami lub parametrami) i może zwracać wartość wynikową. W PHP spotkaliśmy się już z wieloma funkcjami wbudowanymi, takimi jak count(), date(), print_r(), czy in_array(). Teraz nauczymy się tworzyć własne, dostosowane do naszych potrzeb.

Główne zalety używania funkcji to:

• Reużywalność kodu: Raz zdefiniowaną funkcję można wywoływać wielokrotnie, bez potrzeby kopiowania jej kodu.
• Modularyzacja: Dzielenie złożonego problemu na mniejsze, zarządzalne części (każda zaimplementowana jako funkcja).
• Czytelność: Dobrze nazwane funkcje sprawiają, że kod jest łatwiejszy do zrozumienia, ponieważ opisują, co dany fragment kodu robi.
• Łatwość testowania i debugowania: Mniejsze, odizolowane funkcje są łatwiejsze do testowania i debugowania niż duży, monolityczny blok kodu.
• Abstrakcja: Funkcje ukrywają szczegóły implementacyjne, pozwalając skupić się na tym, co funkcja robi, a nie jak to robi.

Definiowanie Funkcji

W PHP funkcję definiuje się za pomocą słowa kluczowego function, po którym następuje nazwa funkcji, lista parametrów w nawiasach okrągłych (), oraz blok kodu funkcji w nawiasach klamrowych { }.

Ogólna składnia definicji funkcji:

<?php
function nazwaFunkcji(parametr1, parametr2, ...) {
    // Ciało funkcji - kod do wykonania
    // ...
    return wartosc_zwracana; // Opcjonalnie
}
?>

Nazewnictwo funkcji:

• Nazwy funkcji w PHP muszą zaczynać się od litery lub znaku podkreślenia _, po których mogą następować litery, cyfry lub znaki podkreślenia.
• Nazwy funkcji nie są wrażliwe na wielkość liter (case-insensitive). Oznacza to, że mojaFunkcja(), MojaFunkcja() i mojafunkcja() odnoszą się do tej samej funkcji. Jednak dobrą praktyką jest konsekwentne używanie jednej konwencji nazewnictwa, np. camelCase (mojaFunkcja) lub snake_case (moja_funkcja).
• Nie można redefiniować wbudowanych funkcji PHP ani używać nazw, które są już zajęte przez inne funkcje w tym samym zakresie.

Parametry funkcji:

• Parametry (nazywane też argumentami formalnymi) to zmienne lokalne funkcji, które otrzymują wartości przekazane podczas wywołania funkcji.
• Funkcja może nie mieć żadnych parametrów, jeden lub więcej.
• Są one wymienione w nawiasach po nazwie funkcji, oddzielone przecinkami.

Instrukcja return:

• Funkcja może (ale nie musi) zwracać wartość za pomocą instrukcji return.
• Gdy PHP napotka instrukcję return, natychmiast kończy wykonywanie funkcji i przekazuje podaną wartość z powrotem do miejsca, z którego funkcja została wywołana.
• Funkcja może zwrócić wartość dowolnego typu, w tym tablice i obiekty.
• Jeśli funkcja nie ma instrukcji return, lub ma return; bez wartości, domyślnie zwraca NULL.
• W jednej funkcji może być wiele instrukcji return (np. w różnych gałęziach instrukcji warunkowych), ale tylko jedna z nich zostanie wykonana podczas pojedynczego wywołania funkcji.

<?php
// Prosta funkcja bez parametrów i bez wartości zwracanej (zwraca NULL)
function powitajSwiat() {
    echo "Witaj, świecie!<br>";
}

// Funkcja z jednym parametrem
function powitajUzytkownika($imie) {
    echo "Witaj, " . htmlspecialchars($imie) . "!<br>";
}

// Funkcja z dwoma parametrami, zwracająca wartość
function dodajLiczby($liczba1, $liczba2) {
    $suma = $liczba1 + $liczba2;
    return $suma;
}

// Funkcja, która może zwrócić różne wartości w zależności od warunku
function sprawdzWiek($wiek) {
    if ($wiek >= 18) {
        return "Pełnoletni";
    } else {
        return "Niepełnoletni";
    }
    // Ten kod nigdy się nie wykona, bo return kończy funkcję
    // echo "To się nie wyświetli";
}
?>

Wywoływanie Funkcji

Aby wykonać kod zawarty w funkcji, należy ją wywołać (call/invoke). Robi się to poprzez podanie nazwy funkcji, po której następują nawiasy okrągłe (). Jeśli funkcja oczekuje argumentów, należy je przekazać wewnątrz nawiasów, oddzielone przecinkami. Te przekazane wartości nazywane są argumentami aktualnymi.

<?php
// Definicje funkcji (mogą być zdefiniowane wcześniej w kodzie lub w innym pliku)
function powitajSwiat() {
    echo "Witaj, świecie! (z funkcji)<br>";
}

function powitajUzytkownika($imie) {
    echo "Witaj, " . htmlspecialchars($imie) . "! (z funkcji)<br>";
}

function dodajLiczby($liczba1, $liczba2) {
    $suma = $liczba1 + $liczba2;
    return $suma;
}

// Wywołanie funkcji bez parametrów
powitajSwiat(); // Wyświetli: Witaj, świecie! (z funkcji)

// Wywołanie funkcji z jednym argumentem
powitajUzytkownika("Alicja"); // Wyświetli: Witaj, Alicja! (z funkcji)
$nazwa = "Piotr";
powitajUzytkownika($nazwa); // Wyświetli: Witaj, Piotr! (z funkcji)

// Wywołanie funkcji zwracającej wartość i przypisanie wyniku do zmiennej
$wynikDodawania = dodajLiczby(5, 7);
echo "Wynik dodawania 5 + 7 = $wynikDodawania<br>"; // Wynik dodawania 5 + 7 = 12

$a = 10;
$b = 20;
$sumaAB = dodajLiczby($a, $b);
echo "Suma $a + $b = $sumaAB<br>"; // Suma 10 + 20 = 30

// Można też użyć wyniku funkcji bezpośrednio w innym wyrażeniu
echo "100 + 200 = " . dodajLiczby(100, 200) . "<br>"; // 100 + 200 = 300
?>

Funkcja musi być zdefiniowana przed jej pierwszym wywołaniem, chyba że jest to funkcja zdefiniowana warunkowo lub funkcja wewnątrz innej funkcji (co jest rzadsze). PHP nie wymaga deklarowania funkcji przed ich użyciem w sensie takim jak w C/C++, ale interpreter musi "widzieć" definicję funkcji w momencie, gdy próbuje ją wywołać.

Zakres Zmiennych (Variable Scope)

Zakres zmiennej określa, gdzie w kodzie zmienna jest dostępna (widoczna).

• Zmienne globalne: Zdefiniowane poza wszelkimi funkcjami. Są dostępne tylko w zakresie globalnym, czyli poza funkcjami.
• Zmienne lokalne: Zdefiniowane wewnątrz funkcji (w tym parametry funkcji). Są dostępne tylko wewnątrz tej funkcji. Każde wywołanie funkcji tworzy nowy zestaw zmiennych lokalnych.

Domyślnie, zmienne globalne nie są dostępne wewnątrz funkcji, a zmienne lokalne nie są dostępne poza funkcją, w której zostały zdefiniowane.

<?php
$globalnaZmienna = "Jestem globalna";

function mojaFunkcjaZakres() {
    $lokalnaZmienna = "Jestem lokalna";
    echo "Wewnątrz funkcji: lokalnaZmienna = $lokalnaZmienna<br>";
    
    // Próba dostępu do zmiennej globalnej (nie zadziała bezpośrednio)
    // echo "Wewnątrz funkcji: globalnaZmienna = $globalnaZmienna<br>"; // Wygeneruje Notice: Undefined variable
}

mojaFunkcjaZakres();

echo "Poza funkcją: globalnaZmienna = $globalnaZmienna<br>";
// echo "Poza funkcją: lokalnaZmienna = $lokalnaZmienna<br>"; // Wygeneruje Notice: Undefined variable
?>

Dostęp do zmiennych globalnych wewnątrz funkcji

Aby uzyskać dostęp do zmiennej globalnej wewnątrz funkcji, można użyć:

1. Słowa kluczowego global: Deklaruje, że zmienna wewnątrz funkcji odnosi się do zmiennej globalnej o tej samej nazwie.
2. Superglobalnej tablicy $GLOBALS: Jest to tablica asocjacyjna zawierająca wszystkie zmienne globalne, gdzie kluczem jest nazwa zmiennej.

<?php
$licznikGlobalny = 0;

function zwiekszLicznikGlobal() {
    global $licznikGlobalny; // Deklaracja użycia globalnej zmiennej
    $licznikGlobalny++;
    echo "Licznik (global w funkcji): $licznikGlobalny<br>";
}

function zwiekszLicznikGlobals() {
    $GLOBALS["licznikGlobalny"]++;
    echo "Licznik (GLOBALS w funkcji): " . $GLOBALS["licznikGlobalny"] . "<br>";
}

zwiekszLicznikGlobal();    // Licznik (global w funkcji): 1
zwiekszLicznikGlobal();    // Licznik (global w funkcji): 2
zwiekszLicznikGlobals();   // Licznik (GLOBALS w funkcji): 3

echo "Licznik globalny po wywołaniach funkcji: $licznikGlobalny<br>"; // 3
?>

Uwaga: Nadmierne używanie zmiennych globalnych jest często uważane za złą praktykę, ponieważ utrudnia śledzenie przepływu danych i może prowadzić do nieoczekiwanych efektów ubocznych. Lepszym podejściem jest przekazywanie potrzebnych danych do funkcji jako argumenty i zwracanie wyników za pomocą return.

Zmienne Statyczne (Static Variables)

Normalnie, gdy funkcja kończy działanie, wszystkie jej zmienne lokalne są usuwane. Czasami jednak chcemy, aby funkcja "pamiętała" wartość zmiennej między kolejnymi wywołaniami. Do tego służą zmienne statyczne, deklarowane za pomocą słowa kluczowego static.

Zmienna statyczna jest inicjalizowana tylko przy pierwszym wywołaniu funkcji. Przy kolejnych wywołaniach zachowuje swoją poprzednią wartość.

<?php
function licznikStatyczny() {
    static $licznik = 0; // Inicjalizowana tylko raz
    $licznik++;
    echo "Licznik statyczny: $licznik<br>";
}

function licznikNormalny() {
    $licznik = 0; // Inicjalizowana przy każdym wywołaniu
    $licznik++;
    echo "Licznik normalny: $licznik<br>";
}

echo "<h3>Licznik statyczny:</h3>";
licznikStatyczny(); // Licznik statyczny: 1
licznikStatyczny(); // Licznik statyczny: 2
licznikStatyczny(); // Licznik statyczny: 3

echo "<h3>Licznik normalny:</h3>";
licznikNormalny();  // Licznik normalny: 1
licznikNormalny();  // Licznik normalny: 1
licznikNormalny();  // Licznik normalny: 1
?>

Zmienne statyczne są przydatne np. do implementacji liczników wywołań, prostego cache'owania wewnątrz funkcji lub w funkcjach rekurencyjnych.

Argumenty Funkcji - Szczegóły

Wartości Domyślne Argumentów

Można zdefiniować wartości domyślne dla argumentów funkcji. Jeśli podczas wywołania funkcji argument nie zostanie podany, użyta zostanie jego wartość domyślna.

Argumenty z wartościami domyślnymi powinny być umieszczane na końcu listy parametrów.

<?php
function przywitaj($imie, $powitanie = "Witaj") {
    echo htmlspecialchars($powitanie) . ", " . htmlspecialchars($imie) . "!<br>";
}

przywitaj("Anna");                // Witaj, Anna!
przywitaj("Marek", "Cześć");     // Cześć, Marek!
// przywitaj(); // Błąd: za mało argumentów, $imie jest wymagane

function ustawKolor($kolor = "czerwony", $rozmiar = 12) {
    echo "Kolor: $kolor, Rozmiar: $rozmiar px<br>";
}

ustawKolor();               // Kolor: czerwony, Rozmiar: 12 px
ustawKolor("niebieski");    // Kolor: niebieski, Rozmiar: 12 px
ustawKolor("zielony", 16);  // Kolor: zielony, Rozmiar: 16 px
// ustawKolor(,14); // Błąd, nie można pominąć argumentu bez wartości domyślnej w środku
?>

Przekazywanie Argumentów przez Wartość (Domyślnie)

Domyślnie, argumenty do funkcji w PHP są przekazywane przez wartość. Oznacza to, że funkcja otrzymuje kopię wartości zmiennej przekazanej jako argument. Wszelkie modyfikacje parametru wewnątrz funkcji nie wpływają na oryginalną zmienną poza funkcją.

<?php
function sprobujZmodyfikowac($liczba) {
    $liczba += 10;
    echo "Wewnątrz funkcji, liczba = $liczba<br>";
}

$mojaLiczba = 5;
echo "Przed funkcją, mojaLiczba = $mojaLiczba<br>"; // 5
sprobujZmodyfikowac($mojaLiczba);
// Wewnątrz funkcji, liczba = 15
echo "Po funkcji, mojaLiczba = $mojaLiczba<br>";    // 5 (oryginał niezmieniony)
?>

Przekazywanie Argumentów przez Referencję

Jeśli chcemy, aby funkcja mogła modyfikować oryginalną zmienną, musimy przekazać argument przez referencję. Robi się to poprzez dodanie ampersanda (&) przed nazwą parametru w definicji funkcji.

<?php
function zmodyfikujPrzezReferencje(&$liczba) { // & oznacza przekazywanie przez referencję
    $liczba += 10;
    echo "Wewnątrz funkcji (ref), liczba = $liczba<br>";
}

$oryginalnaLiczba = 5;
echo "Przed funkcją (ref), oryginalnaLiczba = $oryginalnaLiczba<br>"; // 5
zmodyfikujPrzezReferencje($oryginalnaLiczba);
// Wewnątrz funkcji (ref), liczba = 15
echo "Po funkcji (ref), oryginalnaLiczba = $oryginalnaLiczba<br>";    // 15 (oryginał ZMIENIONY)

// Uwaga: Przez referencję można przekazywać tylko zmienne, nie literały.
// zmodyfikujPrzezReferencje(100); // Błąd: Only variables can be passed by reference
?>

Przekazywanie przez referencję jest często używane, gdy funkcja musi zmodyfikować dużą strukturę danych (np. tablicę) bez kosztu kopiowania jej, lub gdy funkcja ma "zwrócić" więcej niż jedną wartość (choć lepszym sposobem na to jest zwrócenie tablicy lub obiektu).

Typowanie Argumentów (Type Hinting / Type Declarations)

Od PHP 5 można określać oczekiwany typ argumentów funkcji. Nazywa się to typowaniem argumentów (type hinting lub type declarations). Jeśli przekazany argument nie jest oczekiwanego typu, PHP wygeneruje błąd (TypeError w PHP 7+).

Można typować dla:

• Nazw klas i interfejsów
• self (w kontekście klasy, oznacza tę samą klasę)
• parent (w kontekście klasy, oznacza klasę nadrzędną)
• array (tablica)
• callable (funkcja lub metoda, którą można wywołać)
• bool, int, float, string (typy skalarne, od PHP 7.0)
• iterable (coś, po czym można iterować, np. tablica lub obiekt implementujący Traversable, od PHP 7.1)
• object (dowolny obiekt, od PHP 7.2)
• mixed (dowolny typ, od PHP 8.0)
• void (dla funkcji, które nie powinny nic zwracać, jako typ zwracany, od PHP 7.1)
• Nazwy unii typów (np. int|string, od PHP 8.0)
• null (w połączeniu z unią, np. ?string lub string|null, aby zezwolić na NULL)

<?php
function przetworzTablice(array $dane) {
    echo "Przetwarzam tablicę: <pre>";
    print_r($dane);
    echo "</pre>";
}

function dodajInt(int $a, int $b) {
    return $a + $b;
}

function wyswietlTekst(?string $tekst) { // ?string oznacza string lub NULL
    if ($tekst === null) {
        echo "Tekst nie został podany.<br>";
    } else {
        echo "Tekst: " . htmlspecialchars($tekst) . "<br>";
    }
}

przetworzTablice([1, 2, 3]);
// przetworzTablice("to nie tablica"); // Spowoduje TypeError

echo "Suma int: " . dodajInt(5, 10) . "<br>"; // 15
// echo "Suma int: " . dodajInt(5.5, 10); // Spowoduje TypeError (w trybie ścisłym) lub konwersję (w trybie słabym)

wyswietlTekst("Ala ma kota");
wyswietlTekst(null);
// wyswietlTekst(123); // Spowoduje TypeError

// Tryb ścisły typowania (strict_types)
// Aby PHP rzucało TypeError zamiast próbować konwertować typy skalarne,
// można włączyć tryb ścisły na początku pliku:
// declare(strict_types=1);
?>

Typowanie argumentów i wartości zwracanych (o czym poniżej) znacznie poprawia niezawodność i czytelność kodu, pomagając wykrywać błędy na wcześniejszym etapie.

Typowanie Wartości Zwracanych (Return Type Declarations)

Od PHP 7.0 można również deklarować oczekiwany typ wartości zwracanej przez funkcję. Robi się to poprzez dodanie dwukropka : i nazwy typu po liście parametrów, a przed otwierającym nawiasem klamrowym {.

<?php
// declare(strict_types=1); // Włączenie trybu ścisłego dla przykładu

function obliczSume(float $a, float $b): float {
    return $a + $b;
}

function pobierzUzytkownika(int $id): ?array { // Może zwrócić tablicę lub NULL
    if ($id === 1) {
        return ["id" => 1, "imie" => "Jan"];
    }
    return null;
}

function nicNieZwracaj(): void { // Funkcja nie powinna nic zwracać
    echo "Ta funkcja nic nie zwraca.<br>";
    // return "coś"; // Spowodowałoby błąd, jeśli void jest zadeklarowane
}

$wynikFloat = obliczSume(2.5, 3.7);
echo "Wynik float: $wynikFloat<br>";

$user = pobierzUzytkownika(1);
var_dump($user);
echo "<br>";

$userNieistniejacy = pobierzUzytkownika(2);
var_dump($userNieistniejacy);
echo "<br>";

nicNieZwracaj();
?>

Zmienna Liczba Argumentów (Variadic Functions)

Od PHP 5.6 można tworzyć funkcje, które przyjmują zmienną liczbę argumentów, używając składni ... (trzy kropki) przed ostatnim parametrem. Wszystkie dodatkowe argumenty zostaną zebrane w tablicę.

<?php
function sumujWszystko(...$liczby): float {
    $suma = 0;
    foreach ($liczby as $liczba) {
        $suma += $liczba;
    }
    return $suma;
}

echo sumujWszystko(1, 2, 3) . "<br>";          // 6
echo sumujWszystko(10, 20, 30, 40.5) . "<br>"; // 100.5
echo sumujWszystko() . "<br>";                // 0

function logujWiadomosci(string $typ, string ...$wiadomosci) {
    echo "Typ logu: $typ<br>";
    foreach ($wiadomosci as $wiadomosc) {
        echo " - " . htmlspecialchars($wiadomosc) . "<br>";
    }
}

logujWiadomosci("BŁĄD", "Nie można połączyć z bazą danych", "Sprawdź konfigurację");
logujWiadomosci("INFO", "Użytkownik zalogowany");
?>

Przed PHP 5.6 do obsługi zmiennej liczby argumentów używało się funkcji func_num_args(), func_get_arg() i func_get_args(), ale składnia ... jest nowocześniejsza i bardziej czytelna.

Podsumowanie Lekcji

W tej lekcji nauczyliśmy się, jak definiować i wywoływać własne funkcje w PHP. Zrozumieliśmy kluczowe koncepcje, takie jak parametry, instrukcja return, oraz fundamentalne znaczenie zakresu zmiennych (globalnych, lokalnych i statycznych). Omówiliśmy również bardziej zaawansowane aspekty pracy z argumentami funkcji, w tym wartości domyślne, przekazywanie przez wartość vs przez referencję, typowanie argumentów i wartości zwracanych, oraz obsługę zmiennej liczby argumentów (variadic functions).

Funkcje są podstawowym narzędziem do budowania dobrze zorganizowanego, reużywalnego i łatwego w utrzymaniu kodu. Ich efektywne wykorzystanie jest niezbędne dla każdego programisty. W następnej lekcji przyjrzymy się bardziej zaawansowanym rodzajom funkcji, takim jak funkcje anonimowe (closures) i funkcje strzałkowe, które otwierają nowe możliwości w programowaniu w PHP.