O PHP não requer a tipagem explícita em declarações de variáveis. Nesse caso, o tipo de uma variável é determinado pelo valor armazenado. Ou seja, se uma string é armazenada numa variável $var, então $var terá o tipo string. Se após isso um valor int value é armazenado em $var, ele será do tipo int.
O PHP pode tentar converter o tipo de um valor em outro, automaticamente, em alguns contextos. Esses contextos são:
Nota: Quando um valor precisa ser interpretado como um tipo diferente, o valor em si não se altera, apenas uma "cópia" é convertido.
Para forçar uma variável ser avaliada como um certo tipo, veja a seção Conversão de tipo. Se desejar mudar o tipo de uma variável, veja a função settype().
Esse é contexto quando da utilização de operadores aritméticos.
Esse contexto ocorre se um dos operandos é um float (e não interpretável como int), se ambos os operandos são interpretados como float, ou se o resultado é um float. Se não, se os operandos são interpretados como int, ou o resultado é um int. A partir do 8.0.0, se um dos operandos não pode ser reinterpretado, um erro do tipo TypeError é lançado.
Esse contexto ocorre ao se utilizar echo, print, interpolação de strings, o operador de concatenação.
Nesse contexto, o valor será interpretado como string.
Se o valor não puder ser interpretado, então TypeError é lançado.
Anteriormente ao 7.4.0, um alerta E_RECOVERABLE_ERROR era emitido.
Este contexto ocorre em instruções condicionais, no uso do operador ternário, ou em uma operação lógica.
Nesse contexto, o valor será interpretado como bool.
Este contexto ocorre quando utilizando operadores bitwise.
Este contexto ocorre se todos os operandos são do tipo string, ou o valor retornado é string. Se não, os operados são interpretados como int, ou o resultado é um int. A partir do PHP 8.0.0, se um dos operandos não puder ser reinterpretado, então TypeError é lançado.
Este contexto ocorre quando utilizando operadores de comparação.
As conversões de tipo que ocorrem nesse contexto são explicados na tabela de sobre comparação entre vários tipos, explicadas aqui.
Este contexto ocorre quando um valor é um parâmetro tipado, ou quando uma propriedade ou valor retornado de uma função declara um tipo.
Nesse contexto, o valor precisa do tipo informado. Duas alternativas existem. A primeira: se o valor é do tipo int e o tipo declarado é float, então o inteiro é convertido num número de ponto flutuante. A segunda alternativa: se o tipo declarado é um escalar, e o valor é conversível no tipo escalar, juntamente com o modo de conversão coercivo no estado ativo (o padrão), o valor pode ser convertido no valor escalar. Veja abaixo uma descrição detalhada desse comportamento.
Funções internas
convertem automaticamente null para tipos escalares, mas
mas esse comportamento foi DESCONTINUADO desde o PHP 8.1.0.
Quando strict_types está desativado, declarações de tipos escalares
estão sujeitas a conversões implícitas e limitadas.
Se o tipo exato do valor não é parte da união, então o tipo final da conversão
é escolhido na seguinte ordem de preferência:
Existe uma exceção, no caso do valor ser uma string, e ambos int e float serem partes
da união, o tipo preferido será determinado pela semântica de
strings numéricas.
Por exemplo, para "42" o tipo int é escolhido,
enquanto que para "42.0" o tipo escolhido é float.
Nota:
Tipos que não são parte da lista acima não são elegíveis para destinos da conversão implícita. Em particular, não existem conversões implícitas para os tipos null, false e true.
Exemplo #1 Exemplo de tipos que podem ser convertidos em tipos union
<?php
// int|string
42 --> 42 // tipo exato
"42" --> "42" // tipo exato
new ObjectWithToString --> "Resultado de __toString()"
// e objero não compatível com int, padrão para string
42.0 --> 42 // float compatível com int
42.1 --> 42 // float compatível com int
1e100 --> "1.0E+100" // float muito grande para int, padrão para string
INF --> "INF" // float muito grande para int, padrão para string
true --> 1 // bool compatível com int
[] --> TypeError // array não é compatível com int ou string
// int|float|bool
"45" --> 45 // string numérica int
"45.0" --> 45.0 // string numérica float
"45X" --> true // string não numérica, padrão para bool
"" --> false // string não numérica, padrão para bool
"X" --> true // string não numérica, padrão para bool
[] --> TypeError // array não é compatível com int, float ou bool
?>Converte o valor do tipo para o tipo escolhido através da escrita do tipo entre parênteses, antes do valor a ser convertido.
<?php
$foo = 10; // $foo é int
$bar = (bool) $foo; // $bar é bool
?>As conversões previstas são:
(int) - converte para int(bool) - converte para bool(float) - converte para float(string) - converte para string(array) - converte para array(object) - converte para object(unset) - converte para NULLNota:
(integer)converte igual a(int).(boolean)converte igual a(bool).(binary)converte igual a(string).(double)e(real)converte igual a(float). Esses casts alternativas não são recomendados, ainda que existentes.
O cast (real) foi descontinuado desde o PHP 8.0.0.
O cast (unset) foi descontinuado desde o PHP 7.2.0.
Note que o cast (unset) tem o mesmo efeito que
informar o valor NULL para a variável ou chamada de função.
O cast (unset) foi removido no PHP 8.0.0.
O cast (binary) e prefixo b ainda existem
para compatibilidade. Atualmente (binary) e
(string) são idênticos, no entanto isso pode mudar
e não deve ser considera estável
Nota:
Espaços são ignorados dentro dos parênteses de um cast. Portanto, as linhas seguintes são equivalentes:
<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>
Convertendo string e variáveis para strings binárias:
<?php
$binary = (binary) $string;
$binary = b"binary string";
?>Nota: Em vez de converter uma variável para string, é possível empacotar a variável dentro de aspas.
<?php
$foo = 10; // $foo é int
$str = "$foo"; // $str é string
$fst = (string) $foo; // $fst também é string
// Isto imprive "são iguais"
if ($fst === $str) {
echo "são iguais";
}
?>
Não é tão óbvio o que acontece quando convertendo entre certos tipos. Para mais informações, veja as seções:
Nota: O PHP suporta a indexação de string utilizando a mesma sintaxe de arrays, de forma que o exemplo seguinte é válido em todas as versões do PHP:
Veja a seção sobre Acesso a caracteres da string para mais informações.<?php
$a = 'car'; // $a é uma string
$a[0] = 'b'; // $a ainda é uma string
echo $a; // bar
?>
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.66666666666667Cast operators have a very high precedence, for example (int)$a/$b is evaluated as ((int)$a)/$b, not as (int)($a/$b) [which would be like intdiv($a,$b) if both $a and $b are integers].
The only exceptions (as of PHP 8.0) are the exponentiation operator ** [i.e. (int)$a**$b is evaluated as (int)($a**$b) rather than ((int)$a)**$b] and the special access/invocation operators ->, ::, [] and () [i.e. in each of (int)$a->$b, (int)$a::$b, (int)$a[$b] and (int)$a($b), the cast is performed last on the result of the variable expression].Casting objects to arrays is a pain. Example:
<?php
class MyClass {
private $priv = 'priv_value';
protected $prot = 'prot_value';
public $pub = 'pub_value';
public $MyClasspriv = 'second_pub_value';
}
$test = new MyClass();
echo '<pre>';
print_r((array) $test);
/*
Array
(
[MyClasspriv] => priv_value
[*prot] => prot_value
[pub] => pub_value
[MyClasspriv] => second_pub_value
)
*/
?>
Yes, that looks like an array with two keys with the same name and it looks like the protected field was prepended with an asterisk. But that's not true:
<?php
foreach ((array) $test as $key => $value) {
$len = strlen($key);
echo "{$key} ({$len}) => {$value}<br />";
for ($i = 0; $i < $len; ++$i) {
echo ord($key[$i]) . ' ';
}
echo '<hr />';
}
/*
MyClasspriv (13) => priv_value
0 77 121 67 108 97 115 115 0 112 114 105 118
*prot (7) => prot_value
0 42 0 112 114 111 116
pub (3) => pub_value
112 117 98
MyClasspriv (11) => second_pub_value
77 121 67 108 97 115 115 112 114 105 118
*/
?>
The char codes show that the protected keys are prepended with '\0*\0' and private keys are prepended with '\0'.__CLASS__.'\0' so be careful when playing around with this.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)The object casting methods presented here do not take into account the class hierarchy of the class you're trying to cast your object into.
/**
* Convert an object to a specific class.
* @param object $object
* @param string $class_name The class to cast the object to
* @return object
*/
public static function cast($object, $class_name) {
if($object === false) return false;
if(class_exists($class_name)) {
$ser_object = serialize($object);
$obj_name_len = strlen(get_class($object));
$start = $obj_name_len + strlen($obj_name_len) + 6;
$new_object = 'O:' . strlen($class_name) . ':"' . $class_name . '":';
$new_object .= substr($ser_object, $start);
$new_object = unserialize($new_object);
/**
* The new object is of the correct type but
* is not fully initialized throughout its graph.
* To get the full object graph (including parent
* class data, we need to create a new instance of
* the specified class and then assign the new
* properties to it.
*/
$graph = new $class_name;
foreach($new_object as $prop => $val) {
$graph->$prop = $val;
}
return $graph;
} else {
throw new CoreException(false, "could not find class $class_name for casting in DB::cast");
return false;
}
}There are some shorter and faster (at least on my machine) ways to perform a type cast.
<?php
$string='12345.678';
$float=+$string;
$integer=0|$string;
$boolean=!!$string;
?>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!Type casting in expressions is executed first.
The casting is assigned to the value, not to the expression result.
Examples:
<?php
$string = "777";
var_dump( $string === 777 ); // FALSE
var_dump( (int) $string === 777 ); // TRUE
var_dump( ( (int) $string ) === 777 ); // TRUE
var_dump( (int) ( $string === 777 ) ); // 0
?>