Jakie są typy zmiennych w PHP?

Question

Accepted Answer

PHP jest **dynamicznie typowany** — zmienne (poprzedzone `$`) nie deklarują typu i mogą zawierać dowolną wartość. PHP ma kilka wbudowanych typów obejmujących typy skalarne, typy złożone i wartości specjalne.

## Zmienne i typy skalarne

```php
<?php
$count = 42;          // int
$price = 9.99;        // float
$name = "Ann";        // string
$active = true;       // bool

$count = "now a string";   // dynamically typed — the same variable can change type
```

Zmienne zawsze zaczynają się od `$` i wnioskują ich typ z przypisanej wartości. Cztery typy skalarne to `int`, `float`, `string`, `bool`.

## Typy złożone i specjalne

```php
$list = [1, 2, 3];               // array (PHP's all-purpose collection)
$map = ["name" => "Ann"];        // associative array (key → value)
$obj = new User();                // object (instance of a class)
$fn = fn($x) => $x * 2;           // callable (closure/function)
$nothing = null;                  // null — "no value"
```

Tablice są wszechstronnym typem kolekcji w PHP (zarówno listy indeksowane, jak i mapy klucz-wartość), a także istnieją obiekty, callables i `null`.

## Sprawdzanie i konwersja typów

```php
gettype($count);        // "integer"
is_int($count);          // true
is_string($name);        // true

(int) "42";              // 42 — explicit cast
(string) 42;             // "42"
intval("42px");          // 42
```

## Type juggling — powszechna pułapka

```php
// PHP automatically converts types in operations ("type juggling")
"5" + 3;        // 8  (string "5" coerced to int)
"5" . 3;         // "53" (. concatenates → both become strings)

// loose vs strict comparison
0 == "hello";    // historically true in old PHP (now false in PHP 8) — type juggling traps
0 === "0";       // false — STRICT comparison checks type too (preferred!)
"1" == 1;        // true (loose) — but "1" === 1 is false
```

Automatyczne **type juggling** w PHP powoduje zaskakujące porównania. Rozwiązanie: preferuj **porównanie ścisłe (`===`)**, które sprawdza typ i wartość, unikając pułapek porównania luźnego (`==`).

## Dlaczego to ważne

Zrozumienie typów zmiennych w PHP jest fundamentalną wiedzą używaną na co dzień.

Kluczowe punkty: PHP jest dynamicznie typowany (zmienne mogą zawierać dowolną wartość, typy są wnioskowane z przypisania), z typami skalarnymi, wszechstronną **tablicą** (służącą zarówno jako lista, jak i mapa — najczęściej używana struktura danych w PHP), obiektami i null.

Najważniejsze jest zrozumienie **type juggling** — automatycznej konwersji typów w PHP w operacjach i porównaniach, która powoduje znane i zaskakujące wyniki — oraz praktyki stosowania **porównania ścisłego (`===`)** zamiast luźnego (`==`), aby uniknąć tych pułapek.

Różnica między `+` (numeryczne) i `.` (konkatenacja stringów) oraz jawne rzutowanie są również codziennymi podstawami.

Ta fundamentalna wiedza o typach stanowi podstawę poprawnego kodu PHP i pomaga uniknąć znanych pułapek porównań w tym języku.