## Conversão automática de tipos

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 for 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:

- Numérico
- String
- Lógico
- Inteiro e string
- Comparação
- Funçã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().

### Contexto numérico

Esse contexto é utilizando em 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.

### Contextos string

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.

### Contextos lógicos

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.

### Contextos inteiros e string

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.

### Contextos de comparação

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.

### Contextos de função

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.

Aviso

Funções internas convertem automaticamente `null` para tipos escalares, mas esse comportamento foi DESCONTINUADO desde o PHP 8.1.0.

#### Coerção de tipos com tipos declarados

- Declaração bool: o valor é convertido para bool.
- Declaração int: o valor é convertido para int quando a conversão for bem definida. Por exemplo, quando uma string é numérica.
- Declaração float: o valor é convertido para float quando a conversão for bem definida. Por exemplo, quando uma string é numérica.
- Declaração string: o valor é convertido para string.

#### Conversão de tipos em tipos union

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:

1. int
2. float
3. string
4. bool

Se o tipo existe na união e o valor puder ser convertido pela mesma semântica do PHP, então esse tipo é escolhido. Senão, um tipo seguinte é tentado.
Cuidado

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 fazem 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
    ?>

### Conversão explícita

Converte o valor do tipo para o tipo escolhido através da escrita do tipo entre parênteses, antes do valor a ser convertido.

Exemplo #2 Conversão de tipo

    <?php
    $foo = 10;           // $foo é um inteiro
    $bar = (bool) $foo;  // $bar é um booleano

    var_dump($bar);
    ?>

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 NULL

A conversão `(void)` também está disponível a partir do PHP 8.5.0, mas não é uma conversão de valor. Ela é usada como uma instrução para descartar explicitamente o resultado de uma expressão.

Aviso

`(integer)` é um sinônimo de `(int)`. `(boolean)` é um sinônimo de `(bool)`. `(binary)` é um sinônimo de `(string)`. `(double)` e `(real)` são sinônimos de `(float)`. Essas conversões alternativas não usam o nome canônico de tipo e foram descontinuadas a partir do PHP 8.5.0.

Aviso

A conversão `(real)` foi descontinuada a partir do PHP 7.4.0 e removida a partir do PHP 8.0.0.

Aviso

A conversão `(unset)` foi descontinuada a partir do PHP 7.2.0. Observe que a conversão `(unset)` tem o mesmo efeito que informar o valor NULL para a variável ou chamada de função. A conversão `(unset)` foi removida no PHP 8.0.0.

Cuidado

A conversão `(binary)` e o prefixo `b` ainda existem para compatibilidade. Atualmente `(binary)` e `(string)` são idênticos, no entanto isso pode mudar e não deve ser considerado estável.

> Nota:

> Espaços são ignorados dentro dos parênteses de uma conversão. 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";
    ?>

Em vez de converter uma variável para string, é possível delimitar a variável entre aspas.

Exemplo #3 Diferentes mecanismos de conversão

    <?php
    $foo = 10;            // $foo é int
    $str = "$foo";        // $str é string
    $fst = (string) $foo; // $fst também é string

    // Isto exibe "são iguais"
    if ($fst === $str) {
        echo "são iguais", PHP_EOL;
    }
    ?>

Não é tão óbvio o que acontece ao converter entre certos tipos. Para mais informações, veja as seções:

- Convertendo para boolean
- Convertendo para integer
- Convertendo para float
- Convertendo para string
- Convertendo para array
- Convertendo para object
- Convertendo para resource
- Convertendo para NULL
- Descartando um valor com `(void)`
- Tabela de conversão de tipos

> 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:

> Exemplo #4 Usando índice de array com uma string

>     <?php
>     $a    = 'car'; // $a é uma string
>     $a[0] = 'b';   // $a ainda é uma string
>     echo $a;       // bar
>     ?>

> Veja a seção sobre Acesso a caracteres da string para mais informações.

`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open