Lekcja 4: Zmienne i typy danych w PHP

Witaj w czwartej lekcji kursu PHP! Po zapoznaniu się z podstawową składnią PHP, tagami i komentarzami, nadszedł czas na zgłębienie jednego z najbardziej fundamentalnych konceptów w każdym języku programowania: zmiennych i typów danych. Zmienne pozwalają na przechowywanie informacji, które mogą być używane i modyfikowane w trakcie działania skryptu, a typy danych określają rodzaj tych informacji i operacje, jakie można na nich wykonywać. Zrozumienie tych pojęć jest kluczowe do pisania dynamicznych i użytecznych programów w PHP.

Czym są zmienne w PHP?

Zmienne w programowaniu można sobie wyobrazić jako nazwane "pojemniki" lub "etykiety" w pamięci komputera, które przechowują wartości. Te wartości mogą być liczbami, tekstem, tablicami danych, obiektami i wieloma innymi rodzajami informacji. Główną cechą zmiennych jest to, że ich wartość może się zmieniać (stąd nazwa "zmienna") w trakcie wykonywania programu.

W PHP zmienne są reprezentowane przez znak dolara ($), po którym następuje nazwa zmiennej. Nazwy zmiennych muszą spełniać określone zasady:

• Nazwa zmiennej musi zaczynać się od litery lub znaku podkreślenia (_). Nie może zaczynać się od cyfry.
• Po pierwszym znaku nazwa zmiennej może zawierać litery (a-z, A-Z), cyfry (0-9) oraz znak podkreślenia (_).
• Nazwy zmiennych są wrażliwe na wielkość liter (case-sensitive). Oznacza to, że $mojaZmienna, $mojazmienna i $MOJAZMIENNA to trzy różne zmienne.
• Nie ma ograniczenia co do długości nazwy zmiennej, ale zaleca się stosowanie nazw opisowych i niezbyt długich.
• Nazwy zmiennych nie mogą zawierać spacji ani znaków specjalnych innych niż podkreślenie.

Przykłady poprawnych nazw zmiennych:

<?php
$wiek;
$imieUzytkownika;
$_adresEmail;
$cena_produktu;
$MAX_LICZBA_UZYTKOWNIKOW; // Często używane dla stałych, ale poprawne też dla zmiennych
$a1;
?>

Przykłady niepoprawnych nazw zmiennych:

<?php
// $1a; // Zaczyna się od cyfry
// $adres-email; // Zawiera myślnik (dozwolone jest tylko podkreślenie)
// $nazwa użytkownika; // Zawiera spację
?>

Deklaracja i Inicjalizacja Zmiennych

PHP jest językiem o dynamicznym typowaniu. Oznacza to, że nie musisz jawnie deklarować typu zmiennej przed jej użyciem, ani nawet deklarować samej zmiennej w tradycyjnym sensie, jak w niektórych innych językach (np. C++ czy Java). Zmienna jest tworzona automatycznie w momencie pierwszego przypisania do niej wartości.

Przypisanie wartości do zmiennej odbywa się za pomocą operatora przypisania (=).

<?php
$nazwa = "PHP Kurs"; // Zmienna $nazwa jest tworzona i inicjalizowana wartością tekstową "PHP Kurs"
$rok = 2025;         // Zmienna $rok jest tworzona i inicjalizowana liczbą całkowitą 2025
$cena = 99.99;       // Zmienna $cena jest tworzona i inicjalizowana liczbą zmiennoprzecinkową 99.99
$czyAktywny = true;  // Zmienna $czyAktywny jest tworzona i inicjalizowana wartością logiczną true

echo $nazwa; // Wyświetli "PHP Kurs"
echo "<br>";
echo $rok;   // Wyświetli 2025
?>

Można również przypisać wartość jednej zmiennej do drugiej:

<?php
$pierwszaZmienna = "Jakaś wartość";
$drugaZmienna = $pierwszaZmienna; // $drugaZmienna teraz przechowuje kopię wartości "Jakaś wartość"

echo $drugaZmienna;
?>

Jeśli spróbujesz użyć zmiennej, której nie przypisano wartości, PHP wygeneruje ostrzeżenie (Notice: Undefined variable) i potraktuje ją tak, jakby miała wartość null (w zależności od kontekstu może to być też 0 lub pusty ciąg znaków).

Zasięg Zmiennych (Scope)

Zasięg zmiennej określa, gdzie w skrypcie dana zmienna jest dostępna (widoczna). PHP ma kilka rodzajów zasięgu:

• Lokalny (Local Scope): Zmienne zadeklarowane wewnątrz funkcji są dostępne tylko wewnątrz tej funkcji. Nie są widoczne poza nią.
• Globalny (Global Scope): Zmienne zadeklarowane poza wszelkimi funkcjami mają zasięg globalny. Domyślnie nie są one dostępne wewnątrz funkcji. Aby uzyskać do nich dostęp wewnątrz funkcji, należy użyć słowa kluczowego global lub tablicy superglobalnej $GLOBALS.
• Statyczny (Static Scope): Zmienne zadeklarowane wewnątrz funkcji za pomocą słowa kluczowego static zachowują swoją wartość między kolejnymi wywołaniami tej funkcji.

Szczegółowo o zasięgu zmiennych, zwłaszcza w kontekście funkcji, powiemy więcej w lekcji poświęconej funkcjom.

Typy Danych w PHP

PHP obsługuje osiem podstawowych typów danych, które można podzielić na trzy kategorie:

1. Typy Skalarne (Scalar Types)

Typy skalarne przechowują pojedynczą wartość.

• bool (Boolean - Typ Logiczny): Może przyjmować jedną z dwóch wartości: true (prawda) lub false (fałsz). Wartości te nie są wrażliwe na wielkość liter (TRUE, True, true są równoważne). Używane w instrukcjach warunkowych i operacjach logicznych.

  <?php
  $jestZalogowany = true;
  $maUprawnienia = false;
  
  if ($jestZalogowany) {
      echo "Użytkownik jest zalogowany.<br>";
  }
  ?>
  

  Podczas konwersji na typ logiczny, następujące wartości są uważane za false: sama wartość false, liczba całkowita 0, liczba zmiennoprzecinkowa 0.0, pusty ciąg znaków "" i ciąg "0", tablica bez elementów, specjalny typ NULL oraz obiekty SimpleXML utworzone z pustych tagów. Wszystkie inne wartości są uważane za true.
• int (Integer - Liczba Całkowita): Reprezentuje liczby całkowite, zarówno dodatnie, jak i ujemne (np. -10, 0, 5, 12345). Rozmiar typu int zależy od platformy (zazwyczaj 32-bitowy lub 64-bitowy). Liczby całkowite można zapisywać w systemie dziesiętnym, ósemkowym (z prefiksem 0), szesnastkowym (z prefiksem 0x) lub dwójkowym (z prefiksem 0b).

  <?php
  $wiek = 30;
  $punkty = -100;
  $rokProdukcji = 2023;
  $liczbaOsemkowa = 0123; // 83 w systemie dziesiętnym
  $liczbaSzesnastkowa = 0xFF; // 255 w systemie dziesiętnym
  $liczbaDwojkowa = 0b1010; // 10 w systemie dziesiętnym
  
  echo $liczbaSzesnastkowa; // Wyświetli 255
  ?>
  

• float (Floating-point number - Liczba Zmiennoprzecinkowa, także double lub real): Reprezentuje liczby rzeczywiste, czyli liczby z częścią ułamkową (np. 3.14, -0.001, 2.5e3 czyli 2500). Precyzja liczb zmiennoprzecinkowych jest ograniczona.

  <?php
  $cena = 19.99;
  $temperatura = -5.5;
  $pi = 3.14159;
  $duzaLiczba = 1.2e9; // 1.2 * 10^9
  
  echo $cena;
  ?>
  

  Należy uważać przy porównywaniu liczb zmiennoprzecinkowych pod kątem równości ze względu na potencjalne problemy z precyzją. Zamiast bezpośredniego porównania $a == $b, często lepiej jest sprawdzać, czy moduł ich różnicy jest mniejszy od bardzo małej wartości (epsilon).
• string (Ciąg Znaków): Reprezentuje sekwencję znaków. Ciągi znaków w PHP mogą być definiowane na kilka sposobów:
  • Apostrofy (Single quotes): 'To jest ciąg znaków'. Wewnątrz apostrofów większość sekwencji specjalnych (np. \n dla nowej linii) nie jest interpretowana, a zmienne nie są parsowane. Jedynymi wyjątkami są \' (apostrof) i \\ (ukośnik wsteczny).
  • Cudzysłowy (Double quotes): "To jest ciąg znaków z $zmienna". Wewnątrz cudzysłowów zmienne są parsowane (ich wartość jest wstawiana do ciągu), a sekwencje specjalne (np. \n - nowa linia, \t - tabulator, \$ - znak dolara) są interpretowane.
  • Heredoc: Składnia heredoc (<<<IDENTYFIKATOR ... IDENTYFIKATOR;) pozwala na definiowanie wieloliniowych ciągów znaków. Działa podobnie do cudzysłowów – zmienne są parsowane, a sekwencje specjalne interpretowane. Identyfikator otwierający i zamykający muszą być takie same, a identyfikator zamykający musi znajdować się na początku nowej linii, bez żadnych białych znaków przed nim (chyba że używamy składni z wcięciem od PHP 7.3).
  • Nowdoc: Składnia nowdoc (<<<'IDENTYFIKATOR' ... IDENTYFIKATOR;) jest podobna do heredoc, ale działa jak ciągi w apostrofach – zmienne i sekwencje specjalne nie są interpretowane. Identyfikator otwierający jest w apostrofach.

  <?php
  $imie = "Jan";
  $tekst1 = 'Witaj, świecie!';
  $tekst2 = "Witaj, $imie!"; // Zmienna $imie zostanie sparsowana
  $tekst3 = 'Witaj, $imie!'; // Zmienna $imie NIE zostanie sparsowana, wyświetli dosłownie $imie
  $tekst4 = "To jest znak nowej linii: \n i tabulatora: \t.";
  
  echo $tekst2; // Wyświetli "Witaj, Jan!"
  echo "<br>";
  echo $tekst3; // Wyświetli "Witaj, $imie!"
  
  $htmlHeredoc = <<<HTML
  <div class="wiadomosc">
    <p>Witaj, <strong>$imie</strong>!</p>
    <p>To jest tekst wieloliniowy używający składni heredoc.</p>
  </div>
  HTML;
  echo $htmlHeredoc;
  
  $sqlNowdoc = <<<'SQL'
  SELECT * FROM uzytkownicy
  WHERE email = '$email_uzytkownika'; -- $email_uzytkownika nie zostanie sparsowane
  SQL;
  echo "<pre>" . htmlspecialchars($sqlNowdoc) . "</pre>";
  ?>
  

  Do łączenia ciągów znaków używa się operatora kropki (.).

2. Typy Złożone (Compound Types)

Typy złożone pozwalają na przechowywanie wielu wartości.

• array (Tablica): Uporządkowana mapa, która przechowuje kolekcję wartości. Każda wartość jest powiązana z kluczem. Klucze mogą być liczbami całkowitymi (indeksy, tablice indeksowane) lub ciągami znaków (tablice asocjacyjne). Tablice mogą przechowywać elementy różnych typów, w tym inne tablice (tworząc tablice wielowymiarowe). Szczegółowo omówimy tablice w dedykowanej lekcji.

  <?php
  // Tablica indeksowana (klucze to liczby całkowite, domyślnie od 0)
  $kolory = ["czerwony", "zielony", "niebieski"];
  // lub $kolory = array("czerwony", "zielony", "niebieski"); // Starsza składnia
  echo $kolory[1]; // Wyświetli "zielony"
  
  // Tablica asocjacyjna (klucze to ciągi znaków)
  $osoba = [
      "imie" => "Anna",
      "wiek" => 28,
      "miasto" => "Warszawa"
  ];
  echo $osoba["imie"]; // Wyświetli "Anna"
  ?>
  

• object (Obiekt): Instancja klasy. Obiekty grupują dane (właściwości) i funkcje (metody), które na nich operują. Programowanie obiektowe (OOP) w PHP zostanie szczegółowo omówione w drugiej części kursu.

  <?php
  class Samochod {
      public $marka;
      public $model;
  
      public function __construct($marka, $model) {
          $this->marka = $marka;
          $this->model = $model;
      }
  
      public function wyswietlInfo() {
          return "Marka: " . $this->marka . ", Model: " . $this->model;
      }
  }
  
  $mojSamochod = new Samochod("Toyota", "Corolla");
  echo $mojSamochod->wyswietlInfo(); // Wyświetli "Marka: Toyota, Model: Corolla"
  ?>
  

• callable (Wywoływalny): Specjalny typ danych wprowadzony w PHP 5.4, który wskazuje, że zmienna może być wywołana jak funkcja. Może to być nazwa funkcji jako ciąg znaków, tablica zawierająca obiekt i nazwę metody, lub funkcja anonimowa (closure).

  <?php
  function przywitaj($imie) {
      echo "Witaj, $imie!";
  }
  
  $funkcjaDoWykonania = 'przywitaj';
  if (is_callable($funkcjaDoWykonania)) {
      $funkcjaDoWykonania("Tomasz"); // Wywoła funkcję przywitaj()
  }
  
  $closure = function($nazwa) {
      return "To jest closure dla: " . $nazwa;
  };
  echo "<br>" . $closure("Test");
  ?>
  

• iterable (Iterowalny): Pseudo-typ wprowadzony w PHP 7.1. Akceptuje dowolną tablicę lub obiekt implementujący interfejs Traversable. Oznacza to, że można po nim iterować za pomocą pętli foreach. Używany głównie w deklaracjach typów dla argumentów funkcji i wartości zwracanych.

3. Typy Specjalne (Special Types)

• null (NULL): Specjalny typ danych, który ma tylko jedną możliwą wartość: NULL (nie jest wrażliwy na wielkość liter). Zmienna ma typ NULL, jeśli:
  • Została jej przypisana stała NULL.
  • Nie została jej jeszcze przypisana żadna wartość.
  • Została "usunięta" za pomocą funkcji unset().

  <?php
  $pustaZmienna = NULL;
  $niezdefiniowanaZmienna; // Również będzie traktowana jako NULL w wielu kontekstach
  
  if (is_null($pustaZmienna)) {
      echo "Zmienna jest NULL.<br>";
  }
  
  $doUsuniecia = "wartość";
  unset($doUsuniecia);
  // echo $doUsuniecia; // Spowoduje błąd Notice: Undefined variable
  ?>
  

• resource (Zasób): Specjalna zmienna przechowująca odwołanie (uchwyt) do zewnętrznego zasobu, takiego jak otwarty plik, połączenie z bazą danych, czy zasób obrazu. Zasoby są tworzone i używane przez specjalne funkcje. Nie można na nich wykonywać standardowych operacji arytmetycznych czy porównań w typowy sposób.

  <?php
  // Przykład otwarcia pliku (zasób typu file)
  $uchwytPliku = fopen("plik.txt", "r");
  if ($uchwytPliku) {
      echo "Plik otwarty pomyślnie.<br>";
      // ... operacje na pliku ...
      fclose($uchwytPliku); // Ważne jest zamykanie zasobów
  } else {
      echo "Nie udało się otworzyć pliku.<br>";
  }
  ?>
  

Sprawdzanie Typu Zmiennej

PHP dostarcza szereg funkcji wbudowanych do sprawdzania typu zmiennej. Są one bardzo przydatne, zwłaszcza w języku dynamicznie typowanym, gdzie typ zmiennej może się zmieniać.

• gettype($zmienna): Zwraca ciąg znaków reprezentujący typ zmiennej (np. "boolean", "integer", "double", "string", "array", "object", "resource", "NULL", "unknown type").
• is_bool($zmienna): Sprawdza, czy zmienna jest typu logicznego.
• is_int($zmienna) lub is_integer($zmienna) lub is_long($zmienna): Sprawdza, czy zmienna jest liczbą całkowitą.
• is_float($zmienna) lub is_double($zmienna) lub is_real($zmienna): Sprawdza, czy zmienna jest liczbą zmiennoprzecinkową.
• is_string($zmienna): Sprawdza, czy zmienna jest ciągiem znaków.
• is_array($zmienna): Sprawdza, czy zmienna jest tablicą.
• is_object($zmienna): Sprawdza, czy zmienna jest obiektem.
• is_null($zmienna): Sprawdza, czy zmienna ma wartość NULL.
• is_resource($zmienna): Sprawdza, czy zmienna jest zasobem.
• is_numeric($zmienna): Sprawdza, czy zmienna jest liczbą lub ciągiem numerycznym.
• is_scalar($zmienna): Sprawdza, czy zmienna jest typu skalarnego (bool, int, float, string).
• isset($zmienna): Sprawdza, czy zmienna została zadeklarowana i nie jest NULL.
• empty($zmienna): Sprawdza, czy zmienna jest uważana za "pustą". Wartość jest uważana za pustą, jeśli nie istnieje lub jej wartość jest równa false (zobacz listę wartości konwertowanych na false przy opisie typu bool).

<?php
$liczba = 123;
$tekst = "Witaj";
$wartoscLogiczna = true;
$tab = [1, 2, 3];
$nic = NULL;

echo gettype($liczba) . "<br>"; // integer
echo gettype($tekst) . "<br>"; // string

if (is_int($liczba)) {
    echo "Zmienna liczba jest liczbą całkowitą.<br>";
}

if (empty($nieistniejacaZmienna)) {
    echo "Zmienna nieistniejacaZmienna jest pusta.<br>";
}

if (isset($tekst)) {
    echo "Zmienna tekst jest ustawiona.<br>";
}
?>

Konwersja (Rzutowanie) Typów (Type Casting)

PHP często automatycznie konwertuje typy danych w zależności od kontekstu, w jakim są używane (tzw. type juggling lub loose typing). Na przykład, jeśli dodasz liczbę całkowitą do ciągu znaków, który zaczyna się od cyfr, PHP spróbuje przekonwertować ten ciąg na liczbę.

<?php
$liczbaJakoTekst = "5";
$wynik = $liczbaJakoTekst + 10; // PHP przekonwertuje "5" na liczbę całkowitą 5
echo $wynik; // Wyświetli 15
echo "<br>Typ wyniku: " . gettype($wynik); // integer

$tekst = "10 małych kotków";
$suma = $tekst + 5; // PHP przekonwertuje "10 małych kotków" na liczbę 10 (ignorując resztę)
echo "<br>" . $suma; // Wyświetli 15 (PHP 8: Warning: A non-numeric value encountered)
?>

Chociaż automatyczna konwersja typów może być wygodna, czasami może prowadzić do nieoczekiwanych rezultatów. Dlatego ważne jest, aby rozumieć, jak działa, i w razie potrzeby jawnie konwertować typy.

Jawna konwersja typów (rzutowanie) odbywa się poprzez umieszczenie nazwy docelowego typu w nawiasach przed zmienną lub wartością, którą chcemy przekonwertować:

• (int) lub (integer) - rzutowanie na liczbę całkowitą
• (bool) lub (boolean) - rzutowanie na typ logiczny
• (float) lub (double) lub (real) - rzutowanie na liczbę zmiennoprzecinkową
• (string) - rzutowanie na ciąg znaków
• (array) - rzutowanie na tablicę
• (object) - rzutowanie na obiekt
• (unset) - rzutowanie na NULL (przestarzałe od PHP 7.2.0, używaj (null))

<?php
$liczbaFloat = 123.789;
$liczbaInt = (int) $liczbaFloat;
echo $liczbaInt; // Wyświetli 123 (część ułamkowa jest obcinana)

$tekstLiczby = "999";
$liczbaZTekstu = (int) $tekstLiczby;
echo "<br>" . ($liczbaZTekstu + 1); // Wyświetli 1000

$wartosc = 0;
$wartoscLogiczna = (bool) $wartosc;
var_dump($wartoscLogiczna); // Wyświetli bool(false)

$tekst = "Hello";
// $rzutNaTablice = (array) $tekst; // Tworzy tablicę z jednym elementem: $rzutNaTablice[0] = "Hello"
// var_dump($rzutNaTablice);
?>

Można również użyć funkcji settype($zmienna, $typ), aby zmienić typ zmiennej na stałe.

Deklaracje Typów (Type Hinting / Type Declarations)

Od PHP 5 wprowadzono możliwość deklarowania typów dla parametrów funkcji (type hinting), a od PHP 7 również dla wartości zwracanych przez funkcje oraz dla właściwości klas (od PHP 7.4). Pozwala to na pisanie bardziej przewidywalnego i łatwiejszego do debugowania kodu, ponieważ PHP będzie sprawdzać, czy przekazywane i zwracane wartości są odpowiedniego typu.

<?php
// Deklaracja typu dla parametru i wartości zwracanej (PHP 7+)
function dodajLiczbyCalkowite(int $a, int $b): int {
    return $a + $b;
}

echo dodajLiczbyCalkowite(5, 10); // 15
// echo dodajLiczbyCalkowite(5.5, 10); // Spowoduje błąd TypeError w trybie ścisłym,
                                   // lub PHP spróbuje rzutować 5.5 na 5 w trybie domyślnym (coercive)

// Domyślnie PHP jest w trybie "coercive" (przymusowym), co oznacza, że spróbuje
// przekonwertować typ, jeśli to możliwe. Aby włączyć tryb ścisły, użyj:
declare(strict_types=1); // Musi być pierwszą instrukcją w pliku

function przywitaj(string $imie): string {
    return "Witaj, " . $imie;
}

echo "<br>" . przywitaj("Alicja");
?>

Deklaracje typów są bardzo ważnym elementem nowoczesnego programowania w PHP i będziemy do nich wracać przy omawianiu funkcji i programowania obiektowego.

Podsumowanie Lekcji

W tej obszernej lekcji nauczyliśmy się, czym są zmienne w PHP, jak je nazywać, deklarować i inicjalizować. Zrozumieliśmy, że PHP jest językiem dynamicznie typowanym. Zapoznaliśmy się z ośmioma podstawowymi typami danych: skalarnymi (bool, int, float, string), złożonymi (array, object, callable, iterable) oraz specjalnymi (null, resource). Omówiliśmy również, jak sprawdzać typ zmiennej za pomocą funkcji is_* i gettype(), a także jak jawnie konwertować (rzutować) typy. Na koniec wprowadziliśmy pojęcie deklaracji typów, które zwiększają solidność kodu.

Zrozumienie zmiennych i typów danych jest absolutnie fundamentalne. W następnej lekcji przyjrzymy się operatorom w PHP, które pozwalają na wykonywanie różnych operacji na tych zmiennych i wartościach.