Zmienne, operatory i operacje na zmiennych w PHP

Wprowadzenie do zmiennych

Zmienna to podstawowy element każdego języka programowania – jest jak pojemnik, w którym przechowujemy dane (wartości), aby móc je później wykorzystać. W PHP każda zmienna poprzedzana jest znakiem dolara $. Nie trzeba wcześniej deklarować typu zmiennej ani używać specjalnego słowa kluczowego – wystarczy przypisać jej wartość za pomocą operatora =. Na przykład:

 <?php
 $x = 5;          // zmienna $x przechowuje liczbę 5 (typ integer)
 $tekst = "Hej!"; // zmienna $tekst przechowuje napis "Hej!" (typ string)
 ?>

Powyżej utworzyliśmy dwie zmienne: $x i $tekst. Pierwszej przypisaliśmy wartość liczbową 5, a drugiej ciąg znaków „Hej!”. PHP jest językiem dynamicznie typowanym, co oznacza, że nie musimy z góry określać typu danych, jaki zmienna będzie przechowywać – zmienna sama dostosowuje swój typ do aktualnie przypisanej wartości​

Oznacza to, że w trakcie działania programu ta sama zmienna może najpierw przechowywać liczbę, a później tekst. Na przykład:

 <?php
 $zmienna = 10;         // $zmienna jest teraz typu integer (wartość 10)
 $zmienna = "Hello";    // teraz $zmienna jest typu string (wartość "Hello")
 ?>

PHP automatycznie zmienił typ zmiennej $zmienna z liczby całkowitej na napis, gdy przypisaliśmy nową wartość. Dynamiczne (luźne) typowanie ułatwia szybkie tworzenie skryptów, ale wymaga staranności – programista musi pamiętać, jakiego typu wartości spodziewać się w danej zmiennej.

Nazewnictwo zmiennych (konwencje)

Przy tworzeniu zmiennych obowiązują pewne zasady nazewnictwa:

  • Nazwa zmiennej musi zaczynać się od litery lub znaku podkreślenia (np. $x, $_nazwa są poprawne).
  • Nie może zaczynać się od cyfry – np. nazwa $1liczba jest niepoprawna i spowoduje błąd składni
  • Po pierwszym znaku mogą występować dowolne litery, cyfry i podkreślniki. Nie wolno używać spacji ani znaków specjalnych.
  • Wielkość liter ma znaczenie – zmienne są czułe na wielkość liter (case-sensitive). To znaczy, że $zmienna, $Zmienna i $ZMIENNA to trzy różne zmienne

W praktyce warto nadawać zmiennym nazwy opisowe, które mówią coś o zawartości, np. $liczbaProduktów zamiast $x. Dzięki temu kod jest czytelniejszy. Należy unikać używania polskich znaków i zaczynania nazw od podkreślenia (to ostatnie zarezerwowane bywa dla zmiennych systemowych lub specjalnych).

Typy danych w PHP

Skoro wiemy, że zmienne przechowują wartości, warto poznać typy danych, jakie mogą reprezentować te wartości. PHP udostępnia kilka podstawowych typów danych:

  • Integer (liczba całkowita): typ przechowujący liczby całkowite (bez części ułamkowej), np. -3, 0, 42. Przykład użycia: $licznik = 10;.
  • Float (liczba zmiennoprzecinkowa): typ dla liczb z częścią ułamkową (rzeczywistych), np. 3.14, 0.001, -5.5. Przykład: $temperatura = 36.6;.
  • String (łańcuch znaków): typ tekstowy, przechowuje ciąg znaków (napis), np. "Hello world", "Jan Kowalski". Napis w PHP ujmujemy w cudzysłów ” „ lub apostrof ’ ’. Przykład: $imie = "Anna";.
  • Boolean (wartość logiczna): typ logiczny, może przyjmować jedną z dwóch wartości: true (prawda) lub false (fałsz). Służy do reprezentowania warunków, np. $isLogged = false; (zmienna logiczna oznaczająca, czy użytkownik jest zalogowany).
  • Null: specjalny typ oznaczający brak wartości. Zmienna typu null to zmienna, której nie przypisano żadnej wartości lub jawnie przypisano NULL. Przykład: $wynik = NULL;. (Uwaga: w PHP słowo kluczowe NULL nie rozróżnia wielkości liter, tzn. null oznacza to samo co NULL).
  • Array (tablica): typ złożony, który pozwala przechowywać wiele wartości pod jedną nazwą zmiennej. Tablica może zawierać elementy różnych typów. Wyobraź ją sobie jak uporządkowaną listę wartości, do których odwołujemy się za pomocą indeksów. Przykłady deklaracji tablicy: phpKopiujEdytuj$numery = [1, 2, 3]; // tablica z trzema liczbami $dane = ["Jan", 30, true]; // tablica mieszana: string, int, bool $slownik = ["klucz1" => "wartość1", "klucz2" => "wartość2"]; // tablica asocjacyjna Powyżej pierwsza tablica ma indeksy numeryczne (0,1,2 dla kolejnych elementów), a ostatnia to tablica asocjacyjna z własnymi kluczami tekstowymi. Omówienie tablic to osobny temat, ale już na tym etapie warto wiedzieć, że tablice w PHP są bardzo elastyczne.
  • Object (obiekt): typ reprezentujący obiekt – czyli instancję (konkretne wystąpienie) pewnej klasy w programowaniu obiektowym. Obiekt może zawierać własne właściwości (dane) i metody (funkcje). Przykładowo PHP posiada wbudowaną klasę DateTime. Możemy utworzyć jej obiekt: phpKopiujEdytuj$dzisiaj = new DateTime(); // tworzymy nowy obiekt klasy DateTime var_dump($dzisiaj); Ten kod utworzy w zmiennej $dzisiaj obiekt z aktualną datą i godziną. Funkcja var_dump wypisze szczegóły obiektu (m.in. nazwę klasy). Na razie nie musisz dokładnie rozumieć obiektów – ważne, by wiedzieć, że istnieją. Obiekty stają się istotne przy bardziej rozbudowanych programach.

Note: Istnieje także specjalny typ resource (zasób), używany do przechowywania uchwytów do zewnętrznych zasobów, takich jak połączenie z bazą danych czy otwarty plik. W podstawowym kursie PHP nie będziemy go omawiać – wspominamy tylko, że taki typ istnieje.

Operatory w PHP

Operatory to symbole służące do wykonywania operacji na zmiennych i wartościach. Dzięki operatorom możemy m.in. dodawać liczby, porównywać wartości czy łączyć ciągi znaków. Poniżej omówimy najważniejsze rodzaje operatorów w PHP, wraz z przykładami.

Operatory arytmetyczne

Operatory arytmetyczne służą do wykonywania podstawowych działań matematycznych na liczbach:

  • + (dodawanie) – sumuje dwie wartości.
  • - (odejmowanie) – odejmuje drugą wartość od pierwszej.
  • * (mnożenie) – mnoży przez siebie dwie wartości.
  • / (dzielenie) – dzieli pierwszą wartość przez drugą. Uwaga: jeśli oba operandy są liczbami całkowitymi, wynik dzielenia w PHP może być liczbą zmiennoprzecinkową (np. 5/2 da wynik 2.5).
  • % (modulo) – zwraca resztę z dzielenia pierwszej wartości przez drugą (np. 7 % 3 to 1, bo 7 = 2*3 + 1).
  • ** (potęgowanie) – podnosi pierwszą wartość do potęgi drugiej. Np. 2 ** 3 to 23=82^3 = 823=8. (Operator potęgowania jest dostępny od PHP 5.6).

Przykłady użycia operatorów arytmetycznych:

 <?php
 $a = 7;
 $b = 2;

 $sum = $a + $b;         // 7 + 2 = 9
 $difference = $a - $b;  // 7 - 2 = 5
 $product = $a * $b;     // 7 * 2 = 14
 $quotient = $a / $b;    // 7 / 2 = 3.5 (dzielenie, wynik float)
 $modulo = $a % $b;      // 7 % 2 = 1 (reszta z dzielenia 7 przez 2)
 $power = $a ** $b;      // 7 ** 2 = 49 (7 do potęgi 2) 
 ?>

W powyższym kodzie wykonaliśmy różne operacje arytmetyczne na zmiennych $a i $b. Wyniki zostały zapisane w nowych zmiennych ($sum, $difference itd.). Każda z tych zmiennych przyjmie odpowiednią wartość liczbową obliczoną z wykorzystaniem operatora.

Operatory przypisania

Podstawowym operatorem przypisania jest znak = – służy on do przypisania wartości do zmiennej. Wartość po prawej stronie znaku = zostaje obliczona, a następnie zapisana w zmiennej po lewej stronie. Przykład: $x = 5; (przypisanie liczby 5 do zmiennej $x).

PHP oferuje także skrócone operatory przypisania z operacją – łączą one przypisanie z innym działaniem. Oto najczęściej używane z nich:

  • += – dodaje prawą wartość do zmiennej i przypisuje wynik.
  • -= – odejmuje prawą wartość od zmiennej i przypisuje wynik.
  • *= – mnoży zmienną przez prawą wartość i przypisuje wynik.
  • /= – dzieli zmienną przez prawą wartość i przypisuje wynik.
  • %= – oblicza resztę z dzielenia zmiennej przez prawą wartość i przypisuje wynik.
  • .= – konkatenacja z przypisaniem: dodaje (dołącza) prawą wartość (łańcuch znaków) do zmiennej tekstowej.

Przykłady użycia skróconych operatorów przypisania:

 <?php
 $x = 10;
 $x += 5;   // to samo co $x = $x + 5;   teraz $x wynosi 15

 $y = 20;
 $y -= 8;   // to samo co $y = $y - 8;   teraz $y wynosi 12

 $z = 3;
 $z *= 4;   // to samo co $z = $z * 4;   teraz $z wynosi 12

 $w = 10;
 $w /= 2;   // to samo co $w = $w / 2;   teraz $w wynosi 5

 $liczba = 7;
 $liczba %= 3;  // to samo co $liczba = $liczba % 3; teraz $liczba wynosi 1

 $tekst = "Hello";
 $tekst .= " World";  // to samo co $tekst = $tekst . " World"; teraz $tekst = "Hello World"
 ?>

W powyższych przykładach widać, jak skrócone operatory działają. Na przykład, $x += 5; zwiększa wartość $x o 5. Z kolei $tekst .= " World"; dopisuje tekst ” World” na końcu istniejącego ciągu w zmiennej $tekst. Takie skrócone formy są wygodne i czynią kod bardziej czytelnym.

Operatory porównania

Operatory porównania służą do porównywania dwóch wartości. Wynikiem porównania jest wartość logiczna (typ boolean) – true (prawda) lub false (fałsz), w zależności od spełnienia porównania. Oto podstawowe operatory porównania w PHP:

  • == – równe (sprawdza, czy wartości po obu stronach są sobie równe). Uwaga: przy tym porównaniu PHP może automatycznie konwertować typy danych. Np. "5" == 5 zwróci true, bo ciąg „5” zostanie potraktowany jak liczba 5.
  • === – identyczne (sprawdza, czy wartości są równe oraz czy mają ten sam typ). Np. "5" === 5 zwróci false, ponieważ choć wartości „5” i 5 są numerycznie równe, to jedna jest stringiem, a druga integerem. Ten operator nie dokonuje konwersji typów – porównuje „ściśle”.
  • != – różne (true, jeśli wartości po obu stronach nie są równe). Istnieje też zapis <>" o tym samym znaczeniu. Np. 4 != 5 zwróci true (bo 4 jest różne od 5).
  • !== – nieidentyczne (true, jeśli wartości są różne lub mają różne typy). Np. "5" !== 5 zwróci true (bo choć wartości są podobne, typy się różnią).
  • > – większe niż (sprawdza, czy lewa wartość jest większa od prawej).
  • < – mniejsze niż.
  • >= – większe lub równe.
  • <= – mniejsze lub równe.

Przykłady porównań:

 <?php
 $a = 5;
 $b = "5";

 $wynik1 = ($a == $b);   // true, bo $b po konwersji na int jest równe 5
 $wynik2 = ($a === $b);  // false, bo $a jest int, a $b string (różne typy)

 $c = 10;
 $d = 8;
 $wynik3 = ($c > $d);    // true, 10 jest większe od 8
 $wynik4 = ($c <= $d);   // false, 10 nie jest mniejsze lub równe 8
 ?>

Zmienna $wynik1 przyjmie wartość true, ponieważ przy porównaniu == ciąg "5" został potraktowany jak liczba 5, więc 5 == 5. Natomiast $wynik2 będzie false, gdyż operator === wymaga zgodności typu – tutaj warunek nie jest spełniony. Zmienna $wynik3 to wynik porównania 10 > 8 (prawda), a $wynik4 to wynik 10 <= 8 (fałsz).

Operatory porównania są najczęściej używane w instrukcjach warunkowych (np. if) do podejmowania decyzji na podstawie porównania wartości.

Operatory logiczne

Operatory logiczne pozwalają łączyć wyrażenia logiczne (prawda/fałsz) i odwracać ich wartości. Wynikiem również jest wartość boolean (true/false). W PHP mamy następujące podstawowe operatory logiczne:

  • && – logiczne AND (i). Zwraca true, jeśli oba warunki są spełnione (prawdziwe). Np. $x > 0 && $x < 10 jest true tylko wtedy, gdy jednocześnie $x jest większe od 0 i mniejsze od 10.
  • || – logiczne OR (lub). Zwraca true, jeśli przynajmniej jeden z warunków jest spełniony. Np. $x < 0 || $x > 100 będzie true, jeśli $x jest mniejsze od 0 lub większe od 100.
  • ! – logiczne NOT (negacja). Stawia przed wartością logiczną i odwraca jej wartość: true staje się false, a false staje się true. Np. jeśli $isValid jest true, to !$isValid będzie false.

Istnieją też słowne odpowiedniki && i || (odpowiednio and i or), ale ze względu na różnice w pierwszeństwie działania zwykle poleca się korzystać z && i ||. Operator xor (exclusive or) zwraca true, gdy dokładnie jeden z dwóch warunków jest spełniony. W podstawowych zastosowaniach najczęściej używamy jednak AND, OR i NOT.

Przykład użycia operatorów logicznych:

 <?php
 $wiek = 25;
 $czyStudent = true;

 if ($wiek > 18 && $czyStudent) {
     echo "Osoba jest pełnoletnim studentem.";
 }

 if ($wiek < 0 || $wiek > 120) {
     echo "Wiek $wiek jest nieprawdopodobny.";
 }

 $logowanieOk = false;
 if (!$logowanieOk) {
     echo "Nie udało się zalogować.";
 }
 ?>

W pierwszym if warunek używa && – komunikat wyświetli się tylko, jeśli jednocześnie wiek > 18 i flaga $czyStudent jest true. Drugi if używa || – komunikat pojawi się, jeśli wiek jest poza zakresem 0–120 (czyli spełniony którykolwiek z warunków: wiek < 0 lub wiek > 120). Trzeci przykład pokazuje użycie ! do sprawdzenia negatywnego warunku – kod wewnątrz if wykona się, gdy $logowanieOk jest false (negacja false daje true, więc if zadziała).

Operator konkatenacji (łączenia stringów)

W PHP do łączenia łańcuchów znaków (czyli konkatenacji stringów) służy operator . (kropka). Działa on na dwóch operandach będących ciągami (lub takich, które da się na ciągi przekształcić) i zwraca ich połączenie. Przykład:

 <?php
 $imie = "Jan";
 $nazwisko = "Kowalski";
 $pelneImie = $imie . " " . $nazwisko;
 echo $pelneImie;  // wyświetli "Jan Kowalski"
 ?>

Tutaj zmienna $pelneImie otrzymała wynik połączenia stringów: wartości $imie, znaku spacji " ", oraz wartości $nazwisko. W rezultacie zawiera tekst "Jan Kowalski". Operator . nie dodaje automatycznie spacji ani innych znaków – jeśli chcemy je wstawić między łączone części, musimy to zrobić jawnie (jak powyżej poprzez " ").

Wspomniany wcześniej skrócony operator .= pozwala dopisać coś do istniejącego już łańcucha w zmiennej. Np. $tekst .= "!!!"; dopisze na końcu tekstu trzy wykrzykniki.

Operatory inkrementacji i dekrementacji

Inkrementacja i dekrementacja to operacje odpowiednio zwiększania i zmniejszania wartości zmiennej o 1. W PHP używamy do tego operatorów ++ (inkrementacja o jeden) oraz -- (dekrementacja o jeden).

Te operatory można stosować przed lub po nazwie zmiennej:

  • ++$x – preinkrementacja: najpierw zwiększa wartość $x o 1, a następnie zwraca tę zwiększoną wartość.
  • $x++ – postinkrementacja: najpierw zwraca bieżącą wartość $x, a dopiero potem zwiększa $x o 1.
  • --$x – predekrementacja: zmniejsza wartość o 1, potem zwraca.
  • $x-- – postdekrementacja: zwraca bieżącą wartość, potem zmniejsza o 1.

Jeśli operator inkrementacji/dekrementacji jest użyty samodzielnie w instrukcji (tj. w osobnej linijce), różnica między formą pre i post praktycznie nie ma znaczenia – w obu przypadkach zmienna zostanie zwiększona lub zmniejszona. Różnica pojawia się, gdy używamy wyniku operacji w większym wyrażeniu.

Przykłady:

 <?php
 $x = 3;
 echo $x++; // wypisze 3, potem $x stanie się 4
 echo $x;   // wypisze 4 (aktualna wartość po inkrementacji)

 $y = 3;
 echo ++$y; // wypisze 4, bo najpierw $y zwiększono do 4
 echo $y;   // wypisze 4 (wartość $y pozostaje 4)
 ?>

W przypadku zmiennej $x użyliśmy postinkrementacji. Gdy wywołaliśmy echo $x++, operator zwrócił starą wartość (3), a potem zwiększył $x do 4. Dlatego natychmiastowy echo wyświetlił 3, a kolejny echo $x; pokazał już 4. W przypadku $y zastosowaliśmy preinkrementację ++$y, która od razu zwiększa wartość przed użyciem, więc echo ++$y; wyświetliło 4 (bo $y z 3 wzrosło na 4 i tę wartość zwrócono). Podsumowując: jeśli inkrementacja/dekrementacja jest osobno w linii, śmiało można użyć $x++; lub ++$x; – efekt (zmiana wartości) będzie taki sam. Natomiast w złożonych wyrażeniach należy uważać na tę różnicę.

Analogicznie działają --$zmienna i $zmienna--, z tą różnicą, że zmniejszają wartość zmiennej o jeden.

Operacje na zmiennych

W tej sekcji omówimy, jak sprawdzać typ zmiennej, konwertować jedne typy na inne (tzw. rzutowanie) oraz jakie funkcje pomocnicze oferuje PHP do pracy ze zmiennymi.

PHP, jako język o słabym typowaniu, w wielu przypadkach automatycznie zmienia typ zmiennej w zależności od kontekstu (np. gdy dodajemy do siebie różne typy, PHP próbuje je ujednolicić)​

ckziumragowo.pl. Czasem jednak chcemy jawnie dokonać konwersji typu lub sprawdzić typ zmiennej przed użyciem. Do tego służą odpowiednie mechanizmy.

Rzutowanie typów (jawna konwersja)

Rzutowanie (casting) pozwala nam explicite zmienić typ wartości przechowywanej w zmiennej. Dokonujemy tego poprzez podanie w nawiasie nazwy typu przed wartością lub zmienną. W PHP dostępne są m.in. następujące operatory rzutowania: (int) – na typ całkowity, (float) (lub (double)) – na typ zmiennoprzecinkowy, (string) – na łańcuch, (bool) – na boolean, (array) – na tablicę, (object) – na obiekt. Przykłady:

 <?php
 $wartosc = "123";           
 $liczba = (int) $wartosc;      // rzutowanie string "123" na int 123

 $numerTekst = 45;
 $tekst = (string) $numerTekst;  // rzutowanie int 45 na string "45"

 $zdanie = "test";
 $tab = (array) $zdanie; // rzutowanie string na array (tablica z jednym elementem "test")

 $logiczne = (bool)0; // rzutowanie 0 na boolean (da false)
 ?>

Po takim rzutowaniu zmienna zmieni swój typ na żądany (o ile konwersja ma sens – np. rzutowanie napisu, który nie jest liczbą, na int da wartość 0). Rzutowanie nie wypisuje żadnego komunikatu – zmienia tylko wewnętrzną reprezentację wartości. Możemy użyć rzutowania “w locie” w wyrażeniach, np. (float)$a + (float)$b żeby upewnić się, że dodawanie nastąpi na liczbach zmiennoprzecinkowych.

Warto zaznaczyć, że PHP często sam dokonuje konwersji typów w tle. Na przykład jeśli spróbujesz dodać napis i liczbę, PHP przekonwertuje napis na liczbę (o ile to możliwe). Jeśli napis nie zaczyna się od cyfry, wynik takiej konwersji będzie 0. Na przykład:

 <?php
 $wynik = "5" + 3; // "5" w kontekście liczbowym staje się 5, więc wynik 8 (int)
 $tekst = "Liczba: " . 123;  // 123 w kontekście łańcucha staje się "123", wynik "Liczba: 123"
 ?>

W pierwszej linijce ciąg znaków "5" został automatycznie zmieniony na liczbę 5, dzięki czemu dodawanie z 3 dało 8. W drugiej linijce użyliśmy kropki do konkatenacji – liczba 123 została zamieniona na string "123" i dołączona do tekstu. Taka implicit (niejawna) konwersja bywa wygodna, ale może prowadzić do nieoczekiwanych wyników, jeśli nie jesteśmy świadomi zasad. Dlatego w razie wątpliwości lepiej korzystać z jawnego rzutowania lub funkcji pomocniczych.

Funkcje pomocnicze do obsługi zmiennych

PHP udostępnia wiele wbudowanych funkcji do sprawdzania i konwersji typów, które pomagają w debugowaniu i pisaniu poprawnego kodu. Omówimy teraz kilka przydatnych funkcji: var_dump(), gettype(), is_numeric() oraz intval().

  • var_dump(mixed $var) – ta funkcja wyświetla strukturę i typ przekazanej zmiennej (oraz jej wartość). Jest niezwykle pomocna przy sprawdzaniu, co aktualnie znajduje się w zmiennej. Np. var_dump($x); może wyświetlić coś w stylu int(5) lub string(4) "Test", co oznacza odpowiednio „liczba całkowita 5” lub „łańcuch 4-znakowy 'Test'”. var_dump potrafi też wypisać zawartość tablicy czy obiektu. Przykład: phpKopiujEdytuj<?php $a = 42; $b = "tekst"; var_dump($a); // wynik: int(42) var_dump($b); // wynik: string(5) "tekst" ?> Tutaj var_dump($a) pokazał, że $a jest typu int i ma wartość 42, a var_dump($b) ujawnił string długości 5 o zawartości „tekst”.
  • gettype(mixed $var) – zwraca nazwę typu zmiennej w postaci łańcucha. Np. gettype($a) może zwrócić "integer" lub "string", "boolean" itp. Użycie: phpKopiujEdytuj<?php $x = 3.14; echo gettype($x); // wyświetli np. "double" (synonim "float") ?> Funkcja gettype jest przydatna, gdy chcemy programistycznie (np. w kodzie warunkowym) sprawdzić, jakiego typu jest zmienna. Należy pamiętać, że nazwa zwracana to dokładna nazwa typu w języku angielskim (np. integer, double, string, boolean, NULL, array, object).
  • is_numeric(mixed $var) – sprawdza, czy zmienna jest liczbą lub łańcuchem numerycznym. Zwraca true, jeśli $var jest typu int lub float, albo jeżeli jest stringiem, który da się rozpoznać jako liczba (np. „123”, „4.56”, nawet „7e3” w notacji naukowej). W przeciwnym razie zwraca false. Przykłady: phpKopiujEdytuj<?php $x = "150"; $y = "abc"; var_dump(is_numeric($x)); // bool(true) - "150" jest numeryczne var_dump(is_numeric($y)); // bool(false) - "abc" nie jest liczbą var_dump(is_numeric(3.14)); // bool(true) - 3.14 to liczba (float) ?> Dzięki is_numeric możemy łatwo zweryfikować, czy np. dane wejściowe od użytkownika, które zwykle są tekstem, zawierają poprawną liczbę.
  • intval(mixed $var) – konwertuje przekazaną wartość na liczbę całkowitą (int) i zwraca tę wartość. Jeżeli $var jest stringiem, funkcja spróbuje odczytać z niego liczbę. Jeżeli się nie uda, wynikiem będzie 0. Dla typów liczbowych nastąpi obcięcie części ułamkowej (dla float) lub po prostu zwrócenie wartości (dla int). Przykłady: phpKopiujEdytuj<?php echo intval("123"); // 123 (string -> int) echo intval("12.9"); // 12 (float zapisany jako string -> int) echo intval(3.7); // 3 (float -> int, ucięcie części dziesiętnej) echo intval("abc"); // 0 (nie da się z "abc" uzyskać liczby) echo intval(true); // 1 (true jako int to 1, false to 0) ?> intval() bywa użyteczne przy bezpiecznym przekształcaniu danych tekstowych na liczby, np. ID użytkownika pobrane z formularza (tekst) na typ liczbowy. Podobnie działają funkcje floatval($var) – na typ float, czy strval($var) – na string.

Wspomniane funkcje to tylko kilka z wielu. PHP posiada także funkcje takie jak is_int(), is_string(), is_bool(), is_array() itd., które sprawdzają, czy zmienna jest danego typu. Istnieje również funkcja settype($var, $typeName), która ustawia zmiennej konkretny typ (to alternatywa dla rzutowania). W praktyce jednak początkujący programista najczęściej używa var_dump do podejrzenia zmiennych w trakcie nauki, oraz ewentualnie is_numeric/intval podczas walidacji danych wejściowych.

Przykłady praktyczne

Poniżej znajduje się kilka praktycznych przykładów kodu w PHP ilustrujących użycie zmiennych i operatorów w typowych sytuacjach. Każdy przykład pokazuje krótki fragment kodu oraz wyjaśnienie, co on robi.

Przykład 1: Walidacja danych wejściowych (sprawdzenie wieku użytkownika)

Załóżmy, że pobieramy od użytkownika jego wiek (np. z formularza HTML, gdzie wszystko przychodzi jako tekst). Chcemy sprawdzić, czy wpisana wartość jest poprawną liczbą, a następnie ustalić, czy użytkownik jest pełnoletni.

 <?php
 $wiek = "17";  // przykładowa wartość z formularza (ciąg znaków)

 if (!is_numeric($wiek)) {
     echo "Podano niepoprawny wiek.";
 } else {
    // Skonwertuj tekst na liczbę całkowitą
     $wiekLiczba = intval($wiek);
     if ($wiekLiczba >= 18) {
         echo "Użytkownik jest pełnoletni.";
     } else {
         echo "Użytkownik jest niepełnoletni.";
     }
 }
?>

Omówienie: Na początku zakładamy, że wiek użytkownika jest zapisany w zmiennej $wiek jako tekst (np. "17"). Najpierw używamy is_numeric($wiek), aby sprawdzić, czy ta wartość wygląda jak liczba. Jeżeli is_numeric zwróci false (a negacja ! zmieni to na true), wtedy wchodzimy do bloku if i wypisujemy komunikat o niepoprawnym wieku – oznacza to, że użytkownik wpisał np. „dziewiętnaście” albo jakieś losowe znaki, które nie są cyframi.

Jeśli natomiast is_numeric($wiek) zwróci true (czyli ciąg reprezentuje liczbę), przechodzimy do bloku else. Tam najpierw zamieniamy wartość na typ liczbowy całkowity za pomocą intval($wiek) i wynik przypisujemy do $wiekLiczba. Teraz możemy bezpiecznie porównywać liczbowo. Sprawdzamy if ($wiekLiczba >= 18). Jeśli warunek jest spełniony (wiek większy lub równy 18), wypisujemy komunikat o pełnoletności. W przeciwnym razie (wiek poniżej 18) informujemy, że użytkownik jest niepełnoletni.

Ten przykład pokazuje jednocześnie użycie zmiennych, operatora konkatenacji (w komunikatach możemy łączyć tekst, np. dodać zmienną w środku stringu ujętego w podwójne cudzysłowy), operatorów porównania (>=) i logicznego zaprzeczenia (!), a także funkcji is_numeric i intval do obsługi typów.

Przykład 2: Proste obliczenia arytmetyczne (suma i średnia)

W kolejnym przykładzie wykonamy proste obliczenia – obliczymy sumę oraz średnią dwóch liczb. Załóżmy, że mamy dwie zmienne z wynikami testów i chcemy policzyć łączny wynik oraz średnią.

 <?php
 $wynik1 = 85;  // wynik z pierwszego testu
 $wynik2 = 90;  // wynik z drugiego testu

 $suma = $wynik1 + $wynik2;
 $srednia = $suma / 2;

 echo "Wyniki testów: $wynik1 i $wynik2.\n";
 echo "Suma: $suma\n";
 echo "Średnia: $srednia\n";
 ?>

Omówienie: Zmiennym $wynik1 i $wynik2 przypisaliśmy wartości liczbowe 85 i 90. Następnie używając operatora + obliczyliśmy sumę tych dwóch wyników i zapisaliśmy ją w zmiennej $suma. Kolejna linia wykorzystuje operator / do obliczenia średniej – dzielimy sumę przez 2 i zapisujemy wynik w $srednia. Na koniec za pomocą echo wypisujemy komunikaty. Zauważ, że w stringach ujętych w podwójny cudzysłów możemy bezpośrednio wstawić nazwę zmiennej, a PHP zastąpi ją jej wartością (nazywa się to interpolacją zmiennych w łańcuchach). W rezultacie pojawią się konkretne liczby. Dodaliśmy \n (znak nowej linii) dla czytelności wyjścia. Wynik działania powyższego kodu to:

Wyniki testów: 85 i 90.
Suma: 175
Średnia: 87.5

Ten przykład ilustruje zastosowanie operatorów arytmetycznych oraz przypisania w praktyce – wykonaliśmy dodawanie i dzielenie, korzystając z wyników w dalszej części programu.

Przykład 3: Instrukcja warunkowa z użyciem operatorów logicznych

Na koniec zobaczmy przykład wykorzystujący zmienne logiczne i operatory porównania oraz logiczne do podjęcia decyzji. Załóżmy, że chcemy sprawdzić, czy temperatura jest w komfortowym zakresie (np. pomiędzy 18 a 25 stopni) i wyświetlić odpowiedni komunikat.

 <?php
 $temperatura = 30;
 if ($temperatura >= 18 && $temperatura <= 25) {
     echo "Temperatura ($temperatura °C) jest w komfortowym zakresie.";
 } else {
     echo "Temperatura ($temperatura °C) jest poza komfortowym zakresem.";
 }
 ?>

Omówienie: Mamy zmienną $temperatura z wartością 30. W instrukcji if sprawdzamy złożony warunek: używamy operatora logicznego &&, aby upewnić się, że oba podwarunki są spełnione. Warunek $temperatura >= 18 && $temperatura <= 25 będzie true tylko wtedy, gdy temperatura jest jednocześnie nie mniejsza niż 18 i nie większa niż 25 stopni. Ponieważ w naszym przypadku temperatura wynosi 30, pierwszy podwarunek co prawda jest spełniony (30 >= 18), ale drugi już nie (30 <= 25 jest fałszywe). W efekcie cały warunek w if jest false, więc wykonywany jest blok w else. Skrypt wypisze: „Temperatura (30 °C) jest poza komfortowym zakresem.”.

Gdyby zmienna $temperatura miała wartość np. 20, oba podwarunki byłyby prawdziwe i zobaczylibyśmy komunikat z bloku if. Ten przykład pokazuje, jak łączyć porównania za pomocą operatorów logicznych, aby tworzyć bardziej złożone warunki decyzyjne.

To już koniec tego wprowadzenia. Omówiliśmy podstawy zmiennych w PHP – jak je deklarować, jakie typy danych mogą przechowywać – oraz różne rodzaje operatorów, dzięki którym możemy wykonywać operacje na zmiennych. Poznaliśmy również mechanizmy konwersji typów i kilka przydatnych funkcji do badania zawartości zmiennych. Zachęcam do samodzielnego eksperymentowania z kodem: zmieniania wartości zmiennych, dodawania własnych przykładów, sprawdzania, co się stanie w różnych scenariuszach. Im więcej ćwiczeń, tym lepsze zrozumienie tych podstaw, które stanowią fundament dalszej nauki PHP. Powodzenia w programowaniu!