# Integers

An **integer** is a number of the set ℤ = {..., -2, -1, 0, 1, 2, ...}.

See also:

## Syntax

**Integer**s can be specified in decimal (base 10), hexadecimal (base 16), octal (base 8) or binary (base 2) notation. The negation operator can be used to denote a negative **integer**.

Binary **integer** literals are available since **PHP** 5.4.0.

To use octal notation, precede the number with a 0 (zero). To use hexadecimal notation precede the number with 0x. To use binary notation precede the number with 0b.

####
Example #1 **Integer literals**

```
<?php
$a = 1234; // decimal number
$a = -123; // a negative number
$a = 0123; // octal number (equivalent to 83 decimal)
$a = 0x1A; // hexadecimal number (equivalent to 26 decimal)
$a = 0b11111111; // binary number (equivalent to 255 decimal)
?>
```

Formally, the structure for **integer** literals is:

```
decimal : [1-9][0-9]*
| 0
hexadecimal : 0[xX][0-9a-fA-F]+
octal : 0[0-7]+
binary : 0[bB][01]+
integer : decimal
| hexadecimal
| octal
| binary
```

The size of an **integer** is platform-dependent, although a maximum value of about two billion is the usual value (that's 32 bits signed). 64-bit platforms usually have a maximum value of about 9E18, except on Windows prior to **PHP** 7, where it was always 32 bit. **PHP** does not support unsigned **integer**s. **Integer** size can be determined using the constant `PHP_INT_SIZE`

, maximum value using the constant `PHP_INT_MAX`

since **PHP** 5.0.5, and minimum value using the constant `PHP_INT_MIN`

since **PHP** 7.0.0.

Warning

Prior to

PHP7, if an invalid digit was given in an octalinteger(i.e. 8 or 9), the rest of the number was ignored. SincePHP7, a parse error is emitted.

##
**Integer overflow**

If **PHP** encounters a number beyond the bounds of the **integer** type, it will be interpreted as a float instead. Also, an operation which results in a number beyond the bounds of the integer type will return a float instead.

###
Example #2 **Integer overflow** on a 32-bit system

```
<?php
$large_number = 2147483647;
var_dump($large_number); // int(2147483647)
$large_number = 2147483648;
var_dump($large_number); // float(2147483648)
$million = 1000000;
$large_number = 50000 * $million;
var_dump($large_number); // float(50000000000)
?>
```

###
Example #3 **Integer overflow** on a 64-bit system

```
<?php
$large_number = 9223372036854775807;
var_dump($large_number); // int(9223372036854775807)
$large_number = 9223372036854775808;
var_dump($large_number); // float(9.2233720368548E+18)
$million = 1000000;
$large_number = 50000000000000 * $million;
var_dump($large_number); // float(5.0E+19)
?>
```

There is no **integer** division operator in PHP. 1/2 yields the float 0.5. The value can be cast to an **integer** to round it towards zero, or the round() function provides finer control over rounding.

Note: As of

PHP7.0.0, the function intdiv() is available forintegerdivision.

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

##
**Converting to integer**

To explicitly convert a value to **integer**, use either the (int) or (**integer**) casts. However, in most cases the cast is not needed, since a value will be automatically converted if an operator, function or control structure requires an **integer** argument. A value can also be converted to **integer** with the intval() function.

If a resource is converted to an integer, then the result will be the unique resource number assigned to the resource by **PHP** at runtime.

See also Type Juggling.

### From booleans

`FALSE`

will yield 0 (zero), and `TRUE`

will yield 1 (one).

### From floating point numbers

When converting from float to **integer**, the number will be rounded towards zero.

If the **float** is beyond the boundaries of **integer** (usually +/- 2.15e+9 = 2^31 on 32-bit platforms and +/- 9.22e+18 = 2^63 on 64-bit platforms other than Windows), the result is undefined, since the float doesn't have enough precision to give an exact **integer** result. No warning, not even a notice will be issued when this happens!

Note:

As of

PHP7.0.0, instead of being undefined and platform-dependent,NaNand Infinity will always be zero when cast tointeger.

Warning

Never cast an unknown fraction to

integer, as this can sometimes lead to unexpected results.`<?php echo (int) ( (0.1+0.7) * 10 ); // echoes 7! ?>`

See also the warning about float precision.

### From strings

See String conversion to numbers

### From NULL

`NULL`

is always converted to zero (0).

###
From other **types**

Caution

The behaviour of converting to

integeris undefined for othertypes. Do not rely on any observed behaviour, as it can change without notice.