Care sunt tipurile de variabile în PHP?

Question

Accepted Answer

PHP este **dinamic tipizat** — variabilele (prefixate cu `$`) nu declară un tip și pot conține orice valoare. PHP are mai multe tipuri încorporate care acoperă tipuri scalare, tipuri compuse și valori speciale.

## Variabile și tipurile scalare

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

Variabilele încep întotdeauna cu `$` și își inferează tipul din valoarea atribuită. Cele patru tipuri scalare sunt `int`, `float`, `string`, `bool`.

## Tipuri compuse și tipuri speciale

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

Matricele (array-urile) sunt tipul de colecție versatil al PHP (atât liste indexate, cât și hărți cheie-valoare), iar există obiecte, callables și `null`.

## Verificarea și convertirea tipurilor

```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 — o capcană obișnuită

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

**Type juggling** automatul din PHP provoacă comparații surprinzătoare. Soluția: preferă **comparația strictă (`===`)** care verifică tipul și valoarea, evitând capcanele comparației loose (`==`).

## De ce contează

Înțelegerea tipurilor de variabile din PHP este cunoștință fundamentală, zilnică.

Punctele cheie: PHP este dinamic tipizat (variabilele conțin orice valoare, tipurile sunt inferite din atribuire), cu tipuri scalare, **array**-ul versatil (servind atât ca listă, cât și ca hartă — cea mai utilizată structură de date din PHP), obiecte și null.

Cea mai importantă, cunoașterea **type juggling**-ului — conversiunea automată de tip din PHP în operații și comparații, care provoacă rezultate surprinzătoare celebre — și practica de utilizare a **comparației stricte (`===`)** în loc de loose (`==`) pentru a evita aceste capcane este esențială pentru scrierea unui PHP corect și fără erori.

Distincția dintre `+` (numeric) și `.` (concatenare string), și casting-ul explicit, sunt, de asemenea, baze zilnice.

Această cunoștință fundamentală de tip susține codul PHP corect și ajută la evitarea capcanelor de comparație binecunoscute ale limbajului.