PHP: Manipulación de Tipos

Last updated: Fri, 22 Aug 2008

Manipulación de Tipos

PHP no requiere (o soporta) la definición explícita de tipos en la declaración de variables; el tipo de una variable es determinado por el contexto en el que la variable es usada. Lo que quiere decir que si asigna un valor tipo string a la variable $var , $var se convierte en una cadena. Si luego asigna un valor integer a $var , ésta se convierte en un entero.

Un ejemplo de la conversión automática de tipos de PHP es el operador de adición '+'. Si cualquiera de los operandos es un valor float, entonces ambos operandos son evaluados como flotantes, y el resultado será un flotante. De lo contrario, los operandos serán interpretados como enteros, y el resultado será también un entero. Note que esto no modifica los tipos de los operandos como tal; el único cambio está en la forma como los operandos son evaluados y en el tipo de la expresión misma.


<?php
$foo = "0";  // $foo es una cadena (ASCII 48)
$foo += 2;   // $foo es ahora un entero (2)
$foo = $foo + 1.3;  // $foo es ahora un flotante (3.3)
$foo = 5 + "10 Cerditos"; // $foo es entero (15)
$foo = 5 + "10 Cerdos";   // $foo es entero (15)
?>

Si los dos últimos ejemplos lucen extraños, consulte Conversión de cadenas a números.

Para forzar a que una variable sea evaluada como de cierto tipo, consulte la sección sobre Moldeamiento de tipos. Si desea cambiar el tipo de una variable, vea la función settype().

Para probar cualquiera de los ejemplos en esta sección, use la función var_dump().

Note: El comportamiento de una conversión automática a matriz no se encuentra definido en el momento.
Asimismo, ya que PHP soporta el uso de índices en cadenas por medio de desplazamientos usando la misma sintaxis que la indexación de matrices, el siguiente ejemplo permanece válido para todas las versiones de PHP:

<?php $a = 'carro'; // $a es una cadena $a[0] = 'b'; // $a sigue siendo una cadena echo $a; // barro ?>

Vea la sección titulada Acceso a cadenas por caracter para más información.

Moldeamiento de Tipos

El moldeamiento de tipos en PHP funciona de forma muy similar a como ocurre en C: el nombre del tipo deseado es escrito entre paréntesis antes de la variable a ser moldeada.


<?php
$foo = 10;   // $foo es un entero
$bar = (boolean) $foo;   // $bar es un booleano
?>

Los moldeamientos permitidos son:

(int), (integer) - moldeamiento a integer
(bool), (boolean) - moldeamiento a boolean
(float), (double), (real) - moldeamiento a float
(string) - moldeamiento a string
(binary) - moldeamiento a string binario (PHP 6)
(array) - moldeamiento a array
(object) - moldeamiento a object

El moldeamiento (binary) y el soporte del prefijo b fueron agregados en PHP 5.2.1

Note que las tabulaciones y los espacios son permitidos al interior de los paréntesis, así que las siguientes expresiones son funcionalmente equivalentes:


<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>

Moldeamiento de cadenas literales y variables a cadenas binarias:


<?php
$binario = (binary)$cadena;
$binario = b"cadena binaria";
?>

Note: En lugar de moldear una variable a cadena, puede también rodear la variable con comillas dobles.

<?php $foo = 10; // $foo es un entero $cad = "$foo"; // $cad es una cadena $fst = (string) $foo; // $fst es también una cadena // Esto imprime "son lo mismo" if ($fst === $cad) { echo "son lo mismo"; } ?>

Puede que no sea obvio qué sucede exactamente cuando se moldea entre ciertos tipos. Para más información, consulte las secciones:

Variables

Tipos

Last updated: Fri, 22 Aug 2008

add a note User Contributed Notes
Manipulación de Tipos

alexgr at gmail dot com
20-Jun-2008 12:43


For a Cast to a User Defined Object you can define a cast method:



class MyObject {

    /**

     * @param MyObject $object

     * @return MyObject

     */

    static public function cast(MyObject $object) {

        return $object;

    }

}



In your php page code you can:

$myObject = MyObject::cast($_SESSION["myObject"]);



Then, PHP will validate the value and your IDE will help you.

miracle at 1oo-percent dot de
20-Feb-2006 02:26


If you want to convert a string automatically to float or integer (e.g. "0.234" to float and "123" to int), simply add 0 to the string - PHP will do the rest.



e.g.



$val = 0 + "1.234";

(type of $val is float now)



$val = 0 + "123";

(type of $val is integer now)

23-Jun-2005 02:47


If you have a boolean, performing increments on it won't do anything despite it being 1.  This is a case where you have to use a cast.



<html>

<body> <!-- don't want w3.org to get mad... -->

<?php

$bar = TRUE;

?>

I have <?=$bar?> bar.

<?php

$bar++;

?>

I now have <?=$bar?> bar.

<?php

$bar = (int) $bar;

$bar++;

?>

I finally have <?=$bar?> bar.

</body>

</html>



That will print



I have 1 bar.

I now have 1 bar.

I finally have 2 bar.

toma at smartsemantics dot com
10-Mar-2005 03:24


In my much of my coding I have found it necessary to type-cast between objects of different class types.



More specifically, I often want to take information from a database, convert it into the class it was before it was inserted, then have the ability to call its class functions as well.



The following code is much shorter than some of the previous examples and seems to suit my purposes.  It also makes use of some regular expression matching rather than string position, replacing, etc.  It takes an object ($obj) of any type and casts it to an new type ($class_type).  Note that the new class type must exist:



function ClassTypeCast(&$obj,$class_type){

    if(class_exists($class_type,true)){

        $obj = unserialize(preg_replace"/^O:[0-9]+:\"[^\"]+\":/i", 

          "O:".strlen($class_type).":\"".$class_type."\":", serialize($obj)));

    }

}

Raja
10-Feb-2005 12:05


Uneven division of an integer variable by another integer variable will result in a float by automatic conversion -- you do not have to cast the variables to floats in order to avoid integer truncation (as you would in C, for example):



$dividend = 2;

$divisor = 3;

$quotient = $dividend/$divisor;

print $quotient; // 0.66666666666667

tom5025_ at hotmail dot com
24-Aug-2004 10:27


function strhex($string)

{

   $hex="";

   for ($i=0;$i<strlen($string);$i++)

       $hex.=dechex(ord($string[$i]));

   return $hex;

}

function hexstr($hex)

{

   $string="";

   for ($i=0;$i<strlen($hex)-1;$i+=2)

       $string.=chr(hexdec($hex[$i].$hex[$i+1]));

   return $string;

}



to convert hex to str and vice versa

dimo dot vanchev at bianor dot com
10-Mar-2004 04:02


For some reason the code-fix posted by philip_snyder at hotmail dot com [27-Feb-2004 02:08]

didn't work for me neither with long_class_names nor with short_class_names. I'm using PHP v4.3.5 for Linux.

Anyway here's what I wrote to solve the long_named_classes problem:



<?php

function typecast($old_object, $new_classname) {

    if(class_exists($new_classname)) {

        $old_serialized_object = serialize($old_object);

        $old_object_name_length = strlen(get_class($old_object));

        $subtring_offset = $old_object_name_length + strlen($old_object_name_length) + 6;

        $new_serialized_object  = 'O:' . strlen($new_classname) . ':"' . $new_classname . '":';

        $new_serialized_object .= substr($old_serialized_object, $subtring_offset);

        return unserialize($new_serialized_object);

     } else {

         return false;

     }

}

?>

philip_snyder at hotmail dot com
27-Feb-2004 04:08


Re: the typecasting between classes post below... fantastic, but slightly flawed. Any class name longer than 9 characters becomes a problem... SO here's a simple fix:



function typecast($old_object, $new_classname) {

  if(class_exists($new_classname)) {

    // Example serialized object segment

    // O:5:"field":9:{s:5:...   <--- Class: Field

    $old_serialized_prefix  = "O:".strlen(get_class($old_object));

    $old_serialized_prefix .= ":\"".get_class($old_object)."\":";



    $old_serialized_object = serialize($old_object);

    $new_serialized_object = 'O:'.strlen($new_classname).':"'.$new_classname . '":';

    $new_serialized_object .= substr($old_serialized_object,strlen($old_serialized_prefix));

   return unserialize($new_serialized_object);

  }

  else

   return false;

}



Thanks for the previous code. Set me in the right direction to solving my typecasting problem. ;)

post_at_henribeige_dot_de
03-May-2003 06:37


If you want to do not only typecasting between basic data types but between classes, try this function. It converts any class into another. All variables that equal name in both classes will be copied.



function typecast($old_object, $new_classname) {

  if(class_exists($new_classname)) {

    $old_serialized_object = serialize($old_object);

    $new_serialized_object = 'O:' . strlen($new_classname) . ':"' . $new_classname . '":' . 

                             substr($old_serialized_object, $old_serialized_object[2] + 7);

    return unserialize($new_serialized_object);

  }

  else

    return false;

}



Example:



class A {

  var $secret;

  function A($secret) {$this->secret = $secret;}

  function output() {echo("Secret class A: " . $this->secret);}

}



class B extends A {

  var $secret;

  function output() {echo("Secret class B: " . strrev($this->secret));}

}



$a = new A("Paranoia");

$b = typecast($a, "B");



$a->output();

$b->output();

echo("Classname \$a: " . get_class($a) . "Classname \$b: " . get_class($b));



Output of the example code above:



Secret class A: Paranoia

Secret class B: aionaraP

Classname $a: a

Classname $b: b

yury at krasu dot ru
27-Nov-2002 10:24


incremental operator ("++") doesn't make type conversion from boolean to int, and if an variable is boolean and equals TRUE than after ++ operation it remains as TRUE, so:



$a = TRUE; 

echo ($a++).$a;  // prints "11"

29-Aug-2002 07:26


Printing or echoing a FALSE boolean value or a NULL value results in an empty string:

(string)TRUE //returns "1"

(string)FALSE //returns ""

echo TRUE; //prints "1"

echo FALSE; //prints nothing!

add a note

Variables

Tipos

Last updated: Fri, 22 Aug 2008