PHP es dinámicamente tipado — las variables (prefijadas con $) no declaran un tipo y pueden contener cualquier valor. PHP tiene varios tipos integrados que cubren tipos escalares, tipos compuestos y valores especiales.
= ;
= ;
= ;
= ;
= ;
Las variables siempre comienzan con $ e infieren su tipo del valor asignado. Los cuatro tipos escalares son int, float, string, bool.
$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"
Los arrays son el tipo de colección versátil de PHP (tanto listas indexadas como mapas clave-valor), y existen los objetos, callables y null.
gettype($count); // "integer"
is_int($count); // true
is_string($name); // true
(int) "42"; // 42 — explicit cast
(string) 42; // "42"
intval("42px"); // 42
// 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
El type juggling automático de PHP causa comparaciones sorprendentes. La solución: preferir comparación estricta (===) que verifica tipo y valor, evitando las trampas de la comparación flexible (==).
Comprendre los tipos de variables de PHP es conocimiento fundamental del día a día.
Los puntos clave: PHP es dinámicamente tipado (las variables pueden contener cualquier valor, los tipos se infieren de la asignación), con tipos escalares, el versátil array (que funciona tanto como lista como mapa — la estructura de datos más usada de PHP), objetos y null.
Más importante aún, conocer sobre type juggling — la conversión automática de tipos de PHP en operaciones y comparaciones, que causa resultados sorprendentes notoriamente — y la práctica de usar comparación estricta (===) sobre la flexible (==) para evitar esas trampas es esencial para escribir PHP correcto y libre de errores.
La distinción entre + (numérico) y . (concatenación de strings), y el casting explícito, también son básicos del día a día.
Este conocimiento de tipos fundamental respalda el código PHP correcto y ayuda a evitar las trampas de comparación bien conocidas del lenguaje.