Jaké jsou typy proměnných v PHP?

Question

Accepted Answer

PHP je **dynamicky typovaný** — proměnné (předsazené `$`) nedeklarují typ a mohou obsahovat libovolnou hodnotu. PHP má několik vestavěných typů pokrývajících skalární typy, složené typy a speciální hodnoty.

## Proměnné a skalární typy

```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
```

Proměnné vždy začínají `$` a jejich typ se odvodí z přiřazené hodnoty. Čtyři skalární typy jsou `int`, `float`, `string`, `bool`.

## Složené a speciální typy

```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"
```

Pole jsou všestranným typem kolekce v PHP (indexované seznamy i páry klíč-hodnota) a existují také objekty, callables a `null`.

## Kontrola a konverze typů

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

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

## Typová žonglérie — běžná zrada

```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
```

Automatická **typová žonglérie** PHP způsobuje překvapivá porovnání. Řešení: preferujte **přísné porovnání (`===`)**, které kontroluje typ i hodnotu, a vyhýbejte se volnému porovnání (`==`).

## Proč na tom záleží

Rozhod PHP typů proměnných je základní, každodenní znalostí.

Klíčové body: PHP je dynamicky typovaný (proměnné obsahují libovolnou hodnotu, typy se odvodí z přiřazení), se skalárními typy, všestranným **polem** (sloužícím jako seznam i mapa — nejčastěji používaná datová struktura v PHP), objekty a null.

Nejdůležitější je pochopení **typové žonglérie** — automatické konverze typů PHP v operacích a porovnáních, která způsobuje notoricky překvapivé výsledky — a praxe používat **přísné porovnání (`===`)** místo volného (`==`), aby se vyhnuly těmto nástrahám.

Rozdíl mezi `+` (numerický) a `.` (zřetězení řetězců) a explicitní přetypování jsou také každodenní základy.

Tato základní typová znalost podporuje správný PHP kód a pomáhá vyhnout se známým chybám porovnávání tohoto jazyka.