## Inteiros

Um int é um número do conjunto ℤ = {..., -2, -1, 0, 1, 2, ...}.

### Veja Também

- Números de ponto flutuante
- Precisão arbitrária / BCMath
- Número inteiro de comprimento arbitrário / GMP

### Sintaxe

Int pode ser especificado em notação decimal (base 10), hexadecimal (base 16), octal (base 8) ou binária (base 2). O sinal de menos pode ser usado para indicar um int negativo.

Para usar a notação octal, preceda o número com um `0` (zero). A partir do PHP 8.1.0, a notação octal também pode ser precedida por `0o` ou `0O`. Para utilizar a notação hexadecimal, preceda o número com `0x`. Para utilizar a notação binária, preceda o número com `0b`.

A partir do PHP 7.4.0, inteiros literais podem conter sublinhados (`_`) entre os dígitos, para melhorar a sua leitura. Estes sublinhados serão removidos pelo analisador do PHP.

Exemplo #1 Inteiros literais

    <?php
    $a = 1234; // número decimal
    $a = 0123; // número octal (equivalente a 83 em decimal)
    $a = 0o123; // número octal (a partir do PHP 8.1.0)
    $a = 0x1A; // número hexadecimal (equivalente a 26 em decimal)
    $a = 0b11111111; // número binário (equivalente a 255 em decimal)
    $a = 1_234_567; // número decimal (a partir do PHP 7.4.0)
    ?>

Formalmente, a estrutura para int literais é esta a partir do PHP 8.1.0 (anteriormente, os prefixos octal `0o` ou `0O` não eram permitidos, e antes do PHP 7.4.0 os sublinhados não eram permitidos):

    decimal     : [1-9][0-9]*(_[0-9]+)*
                | 0

    hexadecimal : 0[xX][0-9a-fA-F]+(_[0-9a-fA-F]+)*

    octal       : 0[oO]?[0-7]+(_[0-7]+)*

    binário     : 0[bB][01]+(_[01]+)*

    inteiro     : decimal
                | hexadecimal
                | octal
                | binário

O tamanho de um int depende da plataforma, embora um valor máximo de cerca de dois bilhões seja o valor usual (são 32 bits com sinal). As plataformas de 64 bits geralmente têm um valor máximo de cerca de 9E18. O PHP não suporta int sem sinal. O tamanho int pode ser determinado usando a constante `PHP_INT_SIZE`, o valor máximo usando a constante `PHP_INT_MAX` e o valor mínimo usando a constante `PHP_INT_MIN`.

### Overflow de inteiros

Se o PHP encontrar um número além dos limites do tipo int, ele será interpretado como um float. Assim, uma operação que resulte em um número além dos limites do tipo int, retornará um float.

Exemplo #2 Estouro de inteiros

    <?php
    $large_number = 50000000000000000000;
    var_dump($large_number);         // float(5.0E+19)

    var_dump(PHP_INT_MAX + 1);       // sistemas 32 bits: float(2147483648)
                                     // sistemas 64 bits: float(9.2233720368548E+18)
    ?>

### Divisão de inteiros

Não existe operador de divisão int no PHP, para isso deve ser usada a função intdiv(). `1/2` produz o float `0.5`. O valor pode ser convertido em um int para arredondar para zero ou pode ser usada a função round() para um controle mais preciso sobre o arredondamento.

Exemplo #3 Divisões

    <?php
    var_dump(25/7);         // float(3.5714285714286)
    var_dump((int) (25/7)); // int(3)
    var_dump(round(25/7));  // float(4)
    ?>

### Convertendo para inteiro

Para converter explicitamente um valor para int, use a conversão `(int)`. Entretanto, na maioria dos casos, o modificador não é necessário, já que o valor será automaticamente convertido se um operador, função ou estrutura de controle requerer um int como argumento. Um valor também pode ser convertido para int utilizando a função intval().

Se um resource for convertido para um int, resultará no número único do recurso, atribuído ao resource pelo PHP em tempo de execução.

Veja também Manipulação de Tipos.

#### Convertendo a partir de booleanos

`false` será retornado como `0` (zero), e `true` retornará `1` (um).

#### Convertendo a partir de números de ponto flutuante

Ao converter de float para int, o número será arredondado em direção ao zero. A partir do PHP 8.1.0, um aviso de descontinuação é emitido quando ocorre a conversão implícita de um float não integral para int que perca precisão.

Exemplo #4 Convertendo a partir de float

    <?php

    function foo($value): int {
      return $value;
    }

    var_dump(foo(8.1)); // Descontinuado: conversão implícita de float 8.1 para int perdendo precisão a partir do PHP 8.1.0
    var_dump(foo(8.1)); // 8 antes do PHP 8.1.0
    var_dump(foo(8.0)); // 8 em ambos os casos

    var_dump((int) 8.1); // 8 em ambos os casos
    var_dump(intval(8.1)); // 8 em ambos os casos
    ?>

Se o float estiver além dos limites de int (geralmente `+/- 2.15e+9 = 2^31` em plataformas de 32 bits e `+/- 9.22e+18 = 2^63` em plataformas de 64 bits), o resultado é indefinido, já que o float não tem precisão suficiente para fornecer um resultado int exato. Nenhum alerta, nem mesmo uma nota, será emitido quando isso acontecer!

> Nota:

> `NaN`, `Inf` e `-Inf` sempre serão zero quando convertidos para int.

Aviso

Nunca converta uma fração desconhecida para int porque isto pode, algumas vezes, levar a resultados inesperados.

    <?php
    echo (int) ( (0.1+0.7) * 10 ); // mostra 7!
    ?>

Veja também o alerta sobre a precisão de número flutuante.

#### Convertendo a partir de strings

Se a string for numérica ou inicialmente numérica, ela será convertida para o valor inteiro correspondente, caso contrário, será convertida para zero (`0`).

#### Convertendo a partir de NULL

`null` é sempre convertido para zero (`0`).

#### Convertendo a partir de outros tipos

Cuidado

O comportamento da conversão de um int é desconhecido para outros tipos. Não se deve depender de nenhum comportamento observado, pois ele pode ser alterado sem aviso.

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