Fundamentos Lección 9 de 75 12 min de lectura

Type Casting y Type Juggling

PHP es un lenguaje de tipado dinámico, lo que significa que las variables pueden cambiar de tipo durante la ejecución. Entender cómo PHP maneja estas conversiones es crucial para evitar bugs sutiles.

Type Juggling (conversión automática)

PHP convierte tipos automáticamente según el contexto. Esto se llama type juggling o type coercion.

PHP 
<?php

// En operaciones aritméticas, los strings se convierten a números
$resultado = '5' + 3;    // 8 (int)
$resultado = '5.5' + 3;  // 8.5 (float)
$resultado = '5 euros' + 3; // 8 (int, ignora el texto)

// En contexto de string, los números se convierten a string
$texto = 'Tengo ' . 5 . ' años'; // "Tengo 5 años"

// En contexto booleano
if ("texto") { } // true (string no vacío)
if (0) { }       // false (cero)
if ("0") { }     // false (string "0" es especial)
if ([]) { }      // false (array vacío)
Cuidado con las comparaciones

El type juggling causa resultados inesperados en comparaciones débiles: 0 == "texto" es true, "10" == "1e1" es true. Por eso siempre debes usar ===.

Type Casting (conversión explícita)

Puedes forzar la conversión de tipos usando la sintaxis de casting:

PHP 
<?php

$valor = '42';

// Casting a diferentes tipos
$entero = (int) $valor;      // 42
$entero = (integer) $valor;  // 42 (alias)

$decimal = (float) $valor;   // 42.0
$decimal = (double) $valor;  // 42.0 (alias)

$texto = (string) 42;        // "42"

$bool = (bool) $valor;       // true
$bool = (boolean) $valor;    // true (alias)

$array = (array) $valor;     // ["42"]

$objeto = (object) ["a" => 1]; // stdClass con propiedad $a = 1

Conversión a entero

PHP 
<?php

// Desde float (trunca, no redondea)
echo (int) 4.9;     // 4
echo (int) -4.9;    // -4

// Desde string
echo (int) "42";        // 42
echo (int) "42.9";      // 42
echo (int) "42 años";   // 42 (lee hasta encontrar no-número)
echo (int) "años 42";   // 0 (empieza con texto)

// Desde boolean
echo (int) true;    // 1
echo (int) false;   // 0

// Desde null
echo (int) null;    // 0

Conversión a boolean

PHP 
<?php

// Valores que se convierten a FALSE
var_dump((bool) 0);        // false
var_dump((bool) 0.0);      // false
var_dump((bool) "");       // false
var_dump((bool) "0");      // false (¡especial!)
var_dump((bool) []);       // false
var_dump((bool) null);     // false

// Todo lo demás es TRUE
var_dump((bool) 1);        // true
var_dump((bool) -1);       // true
var_dump((bool) "texto");  // true
var_dump((bool) "false");  // true (¡es un string no vacío!)
var_dump((bool) [0]);      // true (array no vacío)

Funciones de conversión

Además del casting, PHP ofrece funciones para convertir tipos:

PHP 
<?php

$valor = '42.5';

// Funciones de conversión
$entero = intval($valor);     // 42
$decimal = floatval($valor);  // 42.5
$texto = strval(42);          // "42"
$bool = boolval($valor);      // true

// intval() acepta una base
$hex = intval("FF", 16);      // 255
$binario = intval("1010", 2); // 10

// settype() modifica la variable original
$numero = '100';
settype($numero, "integer");
var_dump($numero); // int(100)

Strict Types (PHP 7+)

Puedes desactivar el type juggling en funciones usando declare(strict_types=1):

PHP 
<?php

declare(strict_types=1);

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

echo sumar(5, 3);     // 8 ✓

// Sin strict_types, esto funcionaría (convertiría "5" a 5)
// Con strict_types, lanza TypeError
echo sumar("5", 3);   // TypeError!
Recomendación profesional

Usa declare(strict_types=1) en todos tus archivos PHP. Te obligará a ser explícito con los tipos y detectarás errores antes de que lleguen a producción.

Casos prácticos

Sanitizar entrada de usuario

PHP 
<?php

// Los datos de formularios siempre son strings
$edad = $_POST['edad'] ?? '';  // "25" o ""

// Convertir a entero de forma segura
$edadInt = (int) $edad;

// O validar primero
if (is_numeric($edad)) {
    $edadInt = (int) $edad;
} else {
    $edadInt = 0; // o lanzar error
}

// Para IDs y cantidades, asegurar que sea positivo
$id = max(0, (int) $_GET['id']);

Trabajar con APIs JSON

PHP 
<?php

$json = '{"id": "123", "active": "true", "price": "19.99"}';
$data = json_decode($json, true);

// Los valores vienen como strings, convertir según necesidad
$id = (int) $data['id'];           // 123
$activo = $data['active'] === 'true'; // true (no usar (bool)!)
$precio = (float) $data['price'];   // 19.99

Errores comunes

PHP 
<?php

// ERROR: Convertir "false" a boolean
$valor = 'false';
if ((bool) $valor) {
    echo 'Esto se ejecuta!'; // "false" es un string no vacío = true
}

// CORRECTO:
if ($valor === 'true') {
    // ...
}

// ERROR: Asumir que los strings numéricos son seguros
$input = '5e2'; // ¿Es "5e2" o 500?
echo (int) $input;   // 5
echo (float) $input; // 500.0 (notación científica)

// ERROR: Comparar diferentes tipos
$id = 0;
$input = 'admin';
if ($id == $input) {
    echo '¡Acceso concedido!'; // 0 == "admin" es true!
}

// CORRECTO: Usar comparación estricta
if ($id === $input) {
    // Nunca entrará aquí
}

Ejercicios

Ejercicio 1: Convertir entrada de usuario

Simula una entrada de formulario: $edadInput = "25". Convierte este string a entero y verifica que la conversion fue exitosa mostrando el tipo con gettype().

Ver solucion 
<?php

declare(strict_types=1);

$edadInput = '25';

echo "Antes: " . gettype($edadInput) . " - valor: $edadInput\n";

$edad = (int) $edadInput;

echo "Despues: " . gettype($edad) . " - valor: $edad\n";

Ejercicio 2: Conversion a boolean

Crea variables con los valores "0", 0, "" y "false". Convierte cada una a boolean usando (bool) y muestra el resultado con var_dump().

Ver solucion 
<?php

declare(strict_types=1);

$stringCero = '0';
$numeroCero = 0;
$stringVacio = '';
$stringFalse = 'false';

echo "\"0\" como bool: ";
var_dump((bool) $stringCero);

echo "0 como bool: ";
var_dump((bool) $numeroCero);

echo "\"\" como bool: ";
var_dump((bool) $stringVacio);

echo "\"false\" como bool: ";
var_dump((bool) $stringFalse);

Ejercicio 3: Calcular precio total

Tienes $precio = "19.99" y $cantidad = "3" como strings (simulando datos de un formulario). Convierte ambos al tipo apropiado y calcula el total.

Ver solucion 
<?php

declare(strict_types=1);

$precio = '19.99';
$cantidad = '3';

$precioFloat = (float) $precio;
$cantidadInt = (int) $cantidad;

$total = $precioFloat * $cantidadInt;

echo "Precio: $precioFloat\n";
echo "Cantidad: $cantidadInt\n";
echo "Total: $total\n";

¡Has completado la sección de Fundamentos!

Ya dominas los bloques básicos de PHP. Ahora aprenderás a controlar el flujo de tu programa con condicionales y bucles.

Continuar a Estructuras de Control