PHP: intval - Manual

downloads | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | conferences | my php.net

search for in the

is_array import_request_variables

Last updated: Sat, 27 Jan 2007

view this page in

# intval

(PHP 3, PHP 4, PHP 5)

intval -- Get the integer value of a variable

## Описание

int intval ( mixed var [, int base] )

Returns the integer value of `var`, using the specified `base` for the conversion (the default is base 10).

## Список параметров

`var`

  The scalar value being converted to an integer

`base`

  The base for the conversion (default is base 10)

## Возвращаемые значения

The integer value of `var` on success, or 0 on failure. Empty arrays and objects return 0, non-empty arrays and objects return 1.

The maximum value depends on the system. 32 bit systems have a maximum signed integer range of -2147483648 to 2147483647. So for example on such a system, `intval('1000000000000')` will return 2147483647. The maximum signed integer value for 64 bit systems is 9223372036854775807.

Strings will most likely return 0 although this depends on the leftmost characters of the string. The common rules of integer casting apply.

## Примеры

Пример 1. intval() examples

The following examples are based on a 32 bit system.

`<?php
echo intval(42); // 42
echo intval(4.2); // 4
echo intval('42'); // 42
echo intval('+42'); // 42
echo intval('-42'); // -42
echo intval(042); // 34
echo intval('042'); // 42
echo intval(1e10); // 1410065408
echo intval('1e10'); // 1
echo intval(0x1A); // 26
echo intval(42000000); // 42000000
echo intval(420000000000000000000); // 0
echo intval('420000000000000000000'); // 2147483647
echo intval(42, 8); // 42
echo intval('42', 8); // 34
?>`

## Примечания

> Замечание: The `base` parameter has no effect unless the `var` parameter is a string.

## Смотрите также

floatval()
strval()
settype()
is_numeric()
Type juggling
BCMath Arbitrary Precision Mathematics Functions

add a note User Contributed Notes
intval
27-Apr-2006 10:36
`Operating on integers gives puzzling results--which don't seem to have to do with the number of bits...
<?php
echo intval(1e10); // -1 on my system; 1410065408 in the example
echo intval(1e5); // 100000 (my own example: lower number--works all right)
echo intval(4e9); // -294967296 ! (my own example: somewhere in the middle)
echo intval(42000000); // 42000000 (as in the manual; reasonable)
echo intval(420000000000000000000); // -1 on my system at least. 0 in the example
// ...and yet still odder...
echo intval(4200000000); // -94967296! (my own example: somewhere in between)
?>`
david at davidmosesNO dot SPAMca
25-Mar-2006 08:16
`Re: Ben Laurienti, Disturbing issue with intval()
This may make things a little more clear for you:
<?php
$amount = 19.99 * 100;
printf("%.13f", $amount); // Outputs : 1998.99999999999981998
?>
Remember that casting floats to ints rounds towards zero, so these are all functionally the same producing 1998:
echo (int)$amount;
echo intVal($amount);
echo (int) 1998.99999999999981998;
Computers cannot store many floating point values to exact precision. For this reason it is generally recommended to never work with currencies in floating point types, and use integers (work in cents), or use some other method. Using floats will have all kinds of rounding and comparison issues. 19.99 will not be the only number to surprise you!`
mkamerma at science dot uva dot nl
06-Mar-2006 11:48
`As addendum, the "if ($int > 0)" check in the encode function is redundant. It doesn't do anything bad to keep it in since it will always be true when reaching that point, but it's a meaningless conditional this way. It's a remnant from when I tried to write the function in terms of bitshifts, which could lead to negative ints when shifting if the 32nd bit was set (instead of always padding with 0's when using >> it pads with 1's leading to negative ints).`
mkamerma at science dot uva dot nl
05-Mar-2006 02:04
`When you need to work with integer values that exceed maxint, the following functions may be of use to you - they form a codec pair for integers of variable length rather than fixed length, encoded in a byte as a 7 bit numberal with a 1 bit has-more flag, indicating that the next byte encodes a higher order part of the same number still.
<?php
/* encode integer as 7bit with has-more bit numeral,
ordered lowest byte first. */
function encode_7bhm($int) {
if ($int==0) return chr(0); // shortcut
$ret = "";
while($int != 0) {
$high = floor($int / 128); // overflow for this round
$low = $int - ($high * 128); // 7 bit numeral
if ($int > 0) {
if ($high > 0) { $low = $low + 128; } // has-more flag
$ret .= chr($low); } //encode
$int = $high; // set overflow as next round's number
}
return $ret;
}
/* decode a 7bit with has-more bit numeral,
ordered lowest byte first. */
function decode_7bhm($hmb) {
$ret = 0;
$pos = 0;
$high = 1;
while($high == 1) {
$byte = ord(substr($hmb, $pos, 1));
$high = floor($byte/128); // gets has-more flag
$low = $byte - ($high*128);
$ret += $low * pow(128, $pos++); // decode
}
return $ret;
}
?>
This codec pair is also quite useful when needing to write ints to files, as this is a low-numeral biased encoding: most of the time this will only require 8 or 16 bit rather than the 32 bits an int will use in fixed-length encoding.
The encoding range:
1 byte - 0 through 128 (2^7)
2 bytes - 129 through 16,384 (2^14)
3 bytes - 16,385 through 2,097,152 (2^21)
4 bytes - 2,097,153 through 268,435,456 (2^28)
while indeed a 32 bit encoded variable length integer will be lower than maxint, rather than needing a new 32 bit block to represent higher range only 8 more bits are required to represent this higher number (for completeness the range of representation by bytes 5-8 are listed):
5 bytes - 268,435,457 through 34,359,738,368 (2^35)
6 bytes - 343,59,738,369 through 4,398,046,511,104 (2^42)
7 bytes - 4,398,046,511,105 through 562,949,953,421,312 (2^49)
8 bytes - 562,949,953,421,313 through 720,57,594,037,927,936 (2^56)
Also for completeness, the function to read a 7 bit with has-more bit from a filepointer:
<?php
// read a 7bhm numeral from file
function read_7bhm($fp) {
$bytestring = "";
$high = 1;
while($high==1) {
$byte = fread($fp, 1);
$high = floor(ord($byte)/128); // check for has-more bit
$bytestring .= $byte;
}
return decode_7bhm($bytestring); }
?>`
simon at npkk dot cz
30-Jan-2006 08:03
`Still have on mind, that if you convert big numbers by adding zero, PHP makes automatic "to a float" conversion, so it is same as floatVal(). So if the number is realy big (over 13 digits), you can lose preciosity. Do not use it for such long numbers, if all bits do matter (IPv6 addresses and similar).`
simon at npkk dot cz
30-Jan-2006 06:48
`intval() returns maxint on number_in_string, if the result would be bigger than it. But for float returns the signed 32 bit integer with the "same" value:
<?
$num=-1000;
print($num."\n");
$i_str=sprintf("%u",$num);
print($i_str."\n");
$i1=intval($i_str);
print($i1."\n");
$i2=intval(floatval($i_str));
print($i2."\n");
?>
prints:
-1000
4294966296
2147483647
-1000`
anonymous at place dot com
17-Jan-2006 09:37
`re: Disturbing issue with intval()
It's probably just good practice to round decimals anyways. i.e...
$amount = round(19.99 * 100);
$test2 = intVal($amount);
$test3 = intVal("$amount");
echo $test2 . "<br />\n";
echo $test3 . "<br />\n";`
Ben Laurienti
16-Jan-2006 01:21
`You guys are going to love this. I found something that I found quite disturbing.
$test1 = intVal(1999);
$amount = 19.99 * 100;
$test2 = intVal($amount);
$test3 = intVal("$amount");
echo $test1 . "<br />\n";
echo $test2 . "<br />\n";
echo $test3 . "<br />\n";
expected output:
1999
1999
1999
actual output
1999
1998
1999
Appears to be a floating point issue, but the number 1999 is the only number that I was able to get to do this. 19.99 is the price of many things, and for our purpose we must pass it as 1999 instead of 19.99.`
adspeed.com
29-Jul-2005 08:32
`Say you have a string $s="3763328634" to be used as a key into the database, intval() this string will result in a different,smaller number (depends on the machine/OS). To keep the number intact but as an int/long type, do $s +=0; instead.`
23-May-2004 08:38
`When trying to read 32bit values (32 bit limitation depends on the word size of your machine) from a string that is represented in hex with the high bit set,
eg. F9833234
intval returns -1. The reason is the sign bit being set. This number is larger than can be saved in a signed int.
The way around this is to read the value in using two calls to intval.
eg.
$val = intval(substr($str,0,4), 16); // read high 16 bit word
$val <<= 16; // shift hi word correct position
$val |= intval(substr($str, 4, 4), 16); // read low 16 bit word`
tuxedobob at mac dot com
07-Feb-2004 04:56
`Sometimes intval just won't cut it. For example if you want to use an unsigned 32-bit int and need all 32 bits. Recently, I wrote a little script that took and integer and converted it to an IP address. After realizing I couldn't just mod the whole thing, since the sign bit throws it off (and compensating for that), we ran into a problem where if it was entered into a form, the value somehow wasn't converted to an integer properly, at least not implicitly. The solution for this, and the way I recommend converting a string to an integer, is:
$num = $num + 0;
and PHP will leave your number alone; it'll just know it's a number. Such is the fun of a loosely-typed language. :)`
Robin Y. Millette http://rym.waglo.com
15-May-2003 01:29
`Rob_Kohr at no_need_to_email dot me dot com
11-Nov-2002 12:24
[snip]
$var=intval("122.5");
//$var==122
This is nice if you want to turn a double into an int automatically rounding down
Hum, I had a bug earlier today, involving ===. Coming from a c++ background, I can't help testing for types. I was using floor() to get an integer from a division by 2, and comparing that to a known integer from a for loop. Well, first I changed the === to == because the test would always be false otherwise. Next, I looked up this function, and converted most of my floor() calls to intval() calls, because I really meant to get an int, and not a float with no decimal part. So I have to disagree with the editor note here. Oh, and I'm comfortably back to using ===.`
cleong at letstalk dot com
01-Oct-2001 05:21
`intval() handles overflow differently depending on the type of the argument.
intval('10000000000') = 2147483647
intval(1e10) = 1410065408
intval(float) yields essentially non-defined result when the argument is beyond the range of int.`
spectator at nanum dot net
11-May-2001 08:30
`For hexadecimal value...
(Ex, RGB color value => each R,G,B integer value)
---------------------------------------
<?
$rgb = '#E7A3EF';
$r = intval(substr($rgb,1,2),16);
$g = intval(substr($rgb,3,2),16);
$b = intval(substr($rgb,5,2),16);
?>
RGB : <?= $rgb ?><br>
R : <?= $r ?><br>
G : <?= $g ?><br>
B : <?= $b ?><br>
---------------------------------------
=> RGB : #E7A3EF
R : 231
G : 163
B : 239`
zak at php dot net
12-Aug-2000 01:38
`intval converts doubles to integers by truncating the fractional component of the number.
When dealing with some values, this can give odd results. Consider the following:
print intval ((0.1 + 0.7) * 10);
This will most likely print out 7, instead of the expected value of 8.
For more information, see the section on floating point numbers in the PHP manual (http://www.php.net/manual/language.types.double.php)
Also note that if you try to convert a string to an integer, the result is often 0.
However, if the leftmost character of a string looks like a valid numeric value, then PHP will keep reading the string until a character that is not valid in a number is encountered.
For example:
"101 Dalmations" will convert to 101
"$1,000,000" will convert to 0 (the 1st character is not a valid start for a number
"80,000 leagues ..." will convert to 80
"1.4e98 microLenats were generated when..." will convert to 1.4e98
Also note that only decimal base numbers are recognized in strings.
"099" will convert to 99, while "0x99" will convert to 0.
One additional note on the behavior of intval. If you specify the base argument, the var argument should be a string - otherwise the base will not be applied.
For Example:
print intval (77, 8); // Prints 77
print intval ('77', 8); // Prints 63`
add a note
is_array import_request_variables

Last updated: Sat, 27 Jan 2007
show source | credits | stats | sitemap | contact | advertising | mirror sites
Copyright © 2001-2007 The PHP Group
All rights reserved.
This mirror generously provided by: Yahoo! Inc.
Last updated: Sat Mar 10 10:36:09 2007 PST