Tutorial PHP Type Casting: Guía Completa

Spanish (Español) translation by Luis Chiabrera (you can also view the original English article)

Cuando estés escribiendo un programa, necesitarás crear y manejar múltiples variables. Estas variables pueden almacenar los mismos o diferentes tipos de datos. Por ejemplo, algunos de ellos podrían tener un valor entero, mientras que otros podrían ser una cadena de texto o un decimal.

Diferentes lenguajes de programación tienen sus propios conjuntos de reglas para definir y declarar variables. Un lenguaje como C++ necesita que especifiques el tipo de variable antes de que puedas comenzar a usarla y no la convertirá implícitamente a algún otro tipo. PHP, por otro lado, tiene reglas algo relajadas en torno a los tipos de datos. No es necesario que especifiques con anterioridad el tipo de valor que almacenarás en una variable. También te permite almacenar un tipo diferente de valor en la misma variable sin ninguna conversión de tipo explícita más adelante.

PHP realiza esta conversión de tipos de datos automáticamente según el contexto en el que se utiliza una variable. En este tutorial de PHP, aprenderás qué reglas se siguen para esta conversión de tipos de datos y cómo puedes hacer una conversión de tipos de datos explícitamente cuando sea necesario.

Conversiones de tipos de datos en PHP permitidas

En este tutorial de PHP te mostraré que puedes convertir un tipo de valores en otro agregando el tipo deseado entre paréntesis antes de la variable que deseas convertir.

<?php

$text = "Apple";
$x = (int) $text;
$y = (boolean) $text;

echo gettype($x);
// Output: integer

echo gettype($y); 
// Output: boolean

?>

Hay seis principales conversiones de tipos de datos en PHP permitidas. Estas se enumeran a continuación:

Convertir a int usando (int) o (integer)
Convertir a bool usando (bool) o (boolean)
Convertir a float usando (float), (double), o (real)
Convertir a string usando (string)
Convertir a array usando (array)
Convertir a object usando (object)

Dos conversiones de tipos adicionales son la conversión binaria y la conversión nula. En versiones anteriores de PHP, podías convertir una variable en NULL con el prefijo (unset). Sin embargo, esto ha quedado obsoleto desde PHP 7.2.0 y eliminado desde PHP 8.0.0. La conversión binaria existe para soporte directo y, por ahora, se comporta igual que (string). Sin embargo, las cosas pueden cambiar en el futuro, por lo que no te recomendaría confiar en este comportamiento..

Cómo usar PHP para convertir a valores booleanos

Un booleano solo puede tener dos valores posibles. Será true o false. Los valores booleanos generalmente se pasan a estructuras de control para modificar el flujo de un programa. Puedes convertir cualquier variable en un valor booleano prefijándola con (bool) o (boolean). Sin embargo, esto no siempre es necesario porque PHP puede determinar a partir del contexto si deseas que un valor se evalúe como booleano.

El booleano false se evalúa naturalmente como false. Los siguientes se consideran false al convertir un valor a booleano:

El valor entero 0
Los valores decimales 0.0 y -0.0
Una cadena de texto vacía
La cadena de texto "0"
Una matriz sin elementos
El tipo NULL

Además, los objetos SimpleXML que se crean a partir de elementos vacíos sin atributos también se evalúan como false.

Cualquier otro valor se evaluará como true. Esto también incluye la cadena de texto "falso" y valores enteros como -1.

Initial Value	Cast to Boolean
`false`	false
`"false"`	true
`0`	false
`"0"`	false
`"zero"`	true
`""`	false
`-1`	true
`"empty"`	true
`"null"`	true
`array()`	false

Como puedes ver, solo la cadena de texto vacía y la cadena "0" se evalúan como false; cualquier otra cadena como "zero", "empty", "false" o "null" se evalúa como true.

Cómo usar PHP para convertir a valores enteros

Puedes convertir cualquier variable en un número entero prefijándolo con (int) o (integer). Otra forma de convertir un valor en un número entero es usar la función intval(). Por lo general, no necesitarás realizar explícitamente estas conversiones porque PHP observará el contexto en el que se usa la variable y la convertirá automáticamente si es necesario.

Hay ciertas reglas sobre la conversión de enteros que debes tener en cuenta para evitar sorpresas inesperadas.

Un booleano false se convierte 0, y un boolean true se convierte en 1.
Los números de coma flotante siempre se redondearán a cero.
NaN e Infinito siempre se evalúan a cero cuando se convierten a int.
Una cadena de texto que es totalmente numérica o numérica inicialmente se convierte en los valores numéricos correspondientes. Todas las demás cadenas se evalúan a cero.
El valor null siempre se convierte en cero..

Initial Value	Cast to Int
`false`	0
`true`	1
`"-1"`	-1
`"null"`	0
`"twenty"`	0
`"20.855 apples"`	20
`"1.2e8"`	120000000
`12.7`	12
`-5.9`	-5

Dos cosas para observar aquí son la conversión de la cadena "twenty" a 0 y la conversión de "20.855 apples" a 20. En esta segunda cadena, la parte decimal se eliminó porque estamos convirtiendo a números enteros.

Cómo usar PHP para convertir valores a números flotantes

Los números flotantes o de coma flotante también se conocen como dobles o números reales. A diferencia de int, que solo puede almacenar números enteros y no decimales, un flotante puede almacenar todo tipo de números. Puedes convertir cualquier variable en un flotante agregando (float), (double) o (real) antes de la misma.

Solo hay dos reglas que debes recordar sobre la conversión de valores a flotantes.

Una cadena numérica o numérica inicial se transformará en el valor flotante correspondiente. Todas las demás cadenas se evaluarán a cero.
Todos los demás tipos de valores se convierten primero en números enteros y luego en flotantes..

Initial Value	Cast to Float
`false`	0
`true`	1
`"-1"`	-1
`"null"`	0
`"twenty"`	0
`"20.855 apples"`	20.855
`"1.2e8"`	12000000

Esta vez, se mantuvo todo el número 20.855 porque la cadena se convierte en un flotante, y los flotantes pueden representar la parte decimal de un número.

Cómo usar PHP para convertir a valores de cadena de texto

Puedes convertir cualquier valor en una cadena de texto agregando (string) antes o llamando a la función strval(). PHP también realiza esta conversión automáticamente para expresiones que esperan una cadena. Esto incluye cosas como llamar echo o comparar una variable con una cadena.

Las convenciones seguidas por PHP al convertir cualquier cosa en una cadena se enumeran a continuación.

Un valor booleano false se convierte en una cadena vacía y un valor true se convierte en la cadena "1".
Los números enteros y flotantes se convierten en una representación textual de esos números.
Todas las matrices se convierten en la cadena "Array".
El valor NULL siempre se convierte en una cadena vacía.
Los objetos se convierten en una cadena con la ayuda del método mágico __toString().
Los recursos se convierten en cadenas según el formato "Resource id #X", donde X es un número como 1, 2, 3, etc., y PHP lo asigna al recurso en tiempo de ejecución.

Como puedes ver, convertir una matriz, un objeto o un recurso en una cadena no produce ningún resultado útil. Deberías considerar usar funciones como var_dump() si deseas ver los datos almacenados dentro de este tipo de valores.

Initial Value	Cast to String
`false`	`""`
`true`	`"1"`
`"false"`	`"false"`
`0`	`"0"`
`1.24984e8`	`"124984000"`
`-38`	`"-38"`
`["Apple", "Monkey", 38]`	`"Array"`
`[]`	`"Array"`
`null`	""

Cómo usar PHP para convertir valores a matrices

Una matriz se utiliza para almacenar un montón de elementos a los que se accederá más tarde. Los arreglos pueden contener cero, uno o más elementos. Por lo tanto, la conversión de valores de tipo entero, flotante, cadena, booleano y recurso crea una matriz con un solo elemento. Se puede acceder al elemento en el índice cero dentro de la nueva matriz.

Meter un NULL en una matriz te dará una matriz vacía.

Initial Value	Cast to Array
`false`	`[false]`
`true`	`[true]`
`"false"`	`[false]`
`"apple"`	`["apple"]`
`12984000`	`[12984000]`
`-38`	`[-38]`
`null`	`[]`

Cómo usar PHP para convertir un objeto en una matriz

La conversión de objetos a matrices es un poco más complicada. Los elementos de la matriz final son las propiedades del objeto. Las claves de esos elementos se derivan de los nombres de las variables miembro según las siguientes reglas.

Los nombres de las clases se anteponen a los nombres de las variables privadas. Se añade un byte NULL a ambos lados del prefijo.
Se antepone un asterisco (*) a los nombres de variables protegidas. En este caso, también se agrega un byte NULL a ambos lados del prefijo.
Los nombres de variables públicas se utilizan directamente como llaves.

<?php

class Person {
    public $Name;
    protected $Age;
    private $Income;
}

var_dump((array) new Person());
// array(3) { ["Name"]=> NULL ["*Age"]=> NULL ["PersonIncome"]=> NULL }

var_export((array) new Person());
// array ( 'Name' => NULL, '' . "\0" . '*' . "\0" . 'Age' => NULL, '' . "\0" . 'Person' . "\0" . 'Income' => NULL, )

?>


Como puedes ver en el ejemplo anterior, el byte NULL no es evidente cuando simplemente usas var_dump(), pero en realidad está presente dentro de las llaves de las matrices.

Cómo usar PHP para convertir valores a NULL, recursos, u objetos

En versiones anteriores de PHP, podías convertir un valor en NULL prefijándolo con (unset). Sin embargo, esto ha sido eliminado de PHP 8.0.0.

Las variables de recursos se utilizan para almacenar una referencia a algún recurso externo. Estos pueden ser archivos abiertos, conexiones a bases de datos, imágenes, etc. Los recursos nos brindan una forma de acceder internamente a objetos externos. Por lo tanto, no tiene ningún sentido convertir matrices, cadenas o flotantes en PHP a recursos.

La conversión de un número entero, flotante, matriz o cadena en un objeto da como resultado la creación de una nueva instancia de la clase PHP integrada stdClass. Un valor de resultados null en una nueva instancia vacía.

Una matriz se convierte en un objeto con llaves consideradas como nombres de propiedad y sus valores correspondientes como el valor de esas propiedades.

Todos los demás tipos de valores se convierten en un objeto con una variable miembro denominada scalar que almacena el valor.

<?php

$values = [false, true, null, "false", "monty", ["fruit" => "apple", "vegetable" => "potato"], 328];

foreach($values as $value) {
    var_dump($value, (object)$value);
    echo "\n";
}

/* Output

bool(false)
object(stdClass)#1 (1) {
  ["scalar"]=>
  bool(false)
}

bool(true)
object(stdClass)#1 (1) {
  ["scalar"]=>
  bool(true)
}

NULL
object(stdClass)#1 (0) {
}

string(5) "false"
object(stdClass)#1 (1) {
  ["scalar"]=>
  string(5) "false"
}

string(5) "monty"
object(stdClass)#1 (1) {
  ["scalar"]=>
  string(5) "monty"
}

array(2) {
  ["fruit"]=>
  string(5) "apple"
  ["vegetable"]=>
  string(6) "potato"
}
object(stdClass)#1 (2) {
  ["fruit"]=>
  string(5) "apple"
  ["vegetable"]=>
  string(6) "potato"
}

int(328)
object(stdClass)#1 (1) {
  ["scalar"]=>
  int(328)
}

*/

?>

Resumiendo

En este tutorial de PHP, he tratado de cubrir todos los aspectos básicos de la conversión de tipos de datos en PHP. Comencé el tutorial mencionando que PHP puede manejar automáticamente la conversión de tipos en la mayoría de las situaciones en las que se requiere. Luego enumeré diferentes tipos en los que puedes convertir valores en PHP. Sin embargo, PHP sigue ciertas reglas al hacer todo este tipo de conversión. Tenlos en cuenta y evitarás sorpresas inesperadas.