Javascript debugger
Website design

↑

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

See also: Arbitrary length integer / GMP, Floating point numbers, and Arbitrary precision / BCMath

Integers can be specified in decimal (10-based), hexadecimal (16-based) or octal (8-based) notation, optionally preceded by a sign (- or +).

If you use the octal notation, you must precede the number with a
`0`

(zero), to use hexadecimal notation precede
the number with `0x`

.

`<?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)

?>

Formally the possible structure for integer literals is:

`decimal : [1-9][0-9]*`

| 0

hexadecimal : 0[xX][0-9a-fA-F]+

octal : 0[0-7]+

integer : [+-]?decimal

| [+-]?hexadecimal

| [+-]?octal

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). PHP does not support unsigned
integers.
Integer size can be determined from `PHP_INT_SIZE`

,
maximum value from `PHP_INT_MAX`

since PHP 4.4.0 and
PHP 5.0.5.

If an invalid digit is passed to octal integer (i.e. 8 or 9), the rest of the number is ignored.

If you specify a number beyond the bounds of the integer type, it will be interpreted as a float instead. Also, if you perform an operation that results in a number beyond the bounds of the integer type, a float will be returned instead.

`<?php`

$large_number = 2147483647;

var_dump($large_number);

// output: int(2147483647)

$large_number = 2147483648;

var_dump($large_number);

// output: float(2147483648)

// it's true also for hexadecimal specified integers between 2^31 and 2^32-1:

var_dump( 0xffffffff );

// output: float(4294967295)

// this doesn't go for hexadecimal specified integers above 2^32-1:

var_dump( 0x100000000 );

// output: int(2147483647)

$million = 1000000;

$large_number = 50000 * $million;

var_dump($large_number);

// output: float(50000000000)

?>

Unfortunately, there was a bug in PHP so that this
does not always work correctly when there are negative numbers
involved. For example: when you do ```
-50000 *
$million
```

, the result will be
`-429496728`

. However, when both operands are
positive there is no problem.

This is solved in PHP 4.1.0.

There is no integer division operator in PHP.
`1/2`

yields the float
`0.5`

. You can cast the value to
an integer to always round it downwards, or you can
use the **round()** function.

`<?php`

var_dump(25/7); // float(3.5714285714286)

var_dump((int) (25/7)); // int(3)

var_dump(round(25/7)); // float(4)

?>

To explicitly convert a value to integer, use either
the `(int)`

or the `(integer)`

cast.
However, in most cases you do not need to use the cast, since a value
will be automatically converted if an operator, function or
control structure requires an integer argument.
You can also convert a value to integer with the function
**intval()**.

See also type-juggling.

`FALSE`

will yield
`0`

(zero), and `TRUE`

will yield `1`

(one).

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`

),
the result is undefined, since the float hasn't
got enough precision to give an exact integer result.
No warning, not even a notice will be issued in this
case!

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 for more information the warning about float-precision.

Behaviour of converting to integer is undefined for other
types. Currently, the behaviour is the same as if the value
was first converted to boolean. However, do
*not* rely on this behaviour, as it can
change without notice.

↓