Conversión de tipos y "type juggling"

El tipado dinámico de PHP significa que a menudo convertirá un valor a un tipo distinto automáticamente, según el contexto — esto se llama type juggling (malabarismo de tipos). Es cómodo hasta que produce silenciosamente un resultado que no esperabas.

Conversión automática en comparaciones

<?php
var_dump(0 == "abc");     // false in PHP 8+, was true before PHP 8
var_dump("5" == 5);       // true — "5" is converted to 5 for comparison
var_dump("5" === 5);      // false — different types, no conversion allowed

== (igualdad flexible) permite el type juggling antes de comparar; === (igualdad estricta) exige que coincidan tanto el valor como el tipo, sin ninguna conversión. PHP 8 corrigió varios de los comportamientos más sorprendentes de == (como comparar un string numérico con 0), pero el hábito más seguro — sin importar la versión de PHP — es usar === por defecto y recurrir a == solo cuando realmente quieras la coerción de tipos.

Conversión explícita (casting)

<?php
$input = "42";
$number = (int) $input;

var_dump($number); // int(42)

$total = "19.99";
$float = (float) $total;

var_dump($float); // float(19.99)

Convertir con (int), (float), (string), (bool) o (array) transforma un valor de forma explícita, lo cual es mucho más predecible que depender del malabarismo de tipos implícito — especialmente para valores que provienen de fuera de tu código, como la entrada de un formulario (que siempre llega como strings) o el resultado de una base de datos.

Veracidad (truthiness): qué cuenta como falso

<?php
var_dump((bool) "");        // false
var_dump((bool) "0");       // false
var_dump((bool) 0);         // false
var_dump((bool) []);        // false
var_dump((bool) null);      // false
var_dump((bool) "0.0");     // true — only the exact string "0" is falsy
var_dump((bool) "false");   // true — a non-empty string, even this one

Esta lista — el string vacío, el string "0", el entero 0, un array vacío y null — son los únicos valores que PHP considera falsos. Todo lo demás, incluido el string "false" (¡que es un string no vacío y, por tanto, verdadero!), se evalúa como true. Esta es una de las fuentes más comunes de errores para desarrolladores que vienen de otros lenguajes.

Aritmética con strings numéricos

<?php
$total = "10" + "5";
var_dump($total); // int(15)

$mixed = "10 apples" + 5;

PHP convierte automáticamente un string con apariencia numérica a un número cuando se usa con un operador aritmético. A partir de PHP 8, un valor inicial no numérico como "10 apples" provoca un TypeError en lugar de adivinar silenciosamente — un cambio deliberado para detectar antes este tipo de errores.

Tipado estricto: desactivar el malabarismo en las firmas de funciones

<?php
declare(strict_types=1);

function addNumbers(int $a, int $b): int {
    return $a + $b;
}

addNumbers("5", 3); // TypeError: must be of type int, string given

declare(strict_types=1) al inicio de un archivo desactiva la coerción automática de tipos para los argumentos y valores de retorno de las funciones en ese archivo — una función tipada para aceptar int rechazará un string en lugar de convertirlo silenciosamente. La mayoría de las guías de estilo modernas de PHP recomiendan habilitar esto en todos los archivos, ya que convierte toda una categoría de errores silenciosos en un error inmediato y visible.