is_int

I've found that both that is_int and ctype_digit don't behave quite as I'd expect, so I made a simple function called isInteger which does. I hope somebody finds it useful.<?phpfunction isInteger($input){    return(ctype_digit(strval($input)));}var_dump(is_int(23)); //bool(true)var_dump(is_int("23")); //bool(false)var_dump(is_int(23.5)); //bool(false)var_dump(is_int(NULL)); //bool(false)var_dump(is_int("")); //bool(false)var_dump(ctype_digit(23)); //bool(true)var_dump(ctype_digit("23")); //bool(false)var_dump(ctype_digit(23.5)); //bool(false)var_dump(ctype_digit(NULL)); //bool(false)var_dump(ctype_digit("")); //bool(true)var_dump(isInteger(23)); //bool(true)var_dump(isInteger("23")); //bool(true)var_dump(isInteger(23.5)); //bool(false)var_dump(isInteger(NULL)); //bool(false)var_dump(isInteger("")); //bool(false)?>

Keep in mind that is_int() operates in signed fashion, not unsigned, and is limited to the word size of the environment php is running in.In a 32-bit environment:<?phpis_int( 2147483647 );           // trueis_int( 2147483648 );           // falseis_int( 9223372036854775807 );  // falseis_int( 9223372036854775808 );  // false?>In a 64-bit environment:<?phpis_int( 2147483647 );           // trueis_int( 2147483648 );           // trueis_int( 9223372036854775807 );  // trueis_int( 9223372036854775808 );  // false?>If you find yourself deployed in a 32-bit environment where you are required to deal with numeric confirmation of integers (and integers only) potentially breaching the 32-bit span, you can combine is_int() with is_float() to guarantee a cover of the full, signed 64-bit span:<?php$small = 2147483647;         // will always be true for is_int(), but never for is_float()$big = 9223372036854775807;  // will only be true for is_int() in a 64-bit environmentif( is_int($small) || is_float($small) );  // passes in a 32-bit environmentif( is_int($big) || is_float($big) );      // passes in a 32-bit environment?>

Simon Neaves was close on explaining why his function is perfect choice for testing for an int (as possibly most people would need).  He made some errors on his ctype_digit() output though - possibly a typo, or maybe a bug in his version of PHP at the time.

The correct output for parts of his examples should be:

<?php
var_dump(ctype_digit(23)); //bool(false)
var_dump(ctype_digit("23")); //bool(true)
var_dump(ctype_digit(23.5)); //bool(false)
var_dump(ctype_digit(NULL)); //bool(false)
var_dump(ctype_digit("")); //bool(false)
?>

As you can see, the reason why using *just* ctype_digit() may not always work is because it only returns TRUE when given a string as input - given a number value and it returns FALSE (which may be unexpected).

With this function you can check if every of multiple variables are int. This is a little more comfortable than writing 'is_int' for every variable you've got.<?phpfunction are_int ( ) {    $args = func_get_args ();    foreach ( $args as $arg )        if ( ! is_int ( $arg ) )            return false;    return true;}// Example:are_int ( 4, 9 ); // trueare_int ( 22, 08, 'foo' ); // false?>

Simon Neaves's answer is incomplete: negative integers will return false.I recommend checking stackoverflow's answers:http://stackoverflow.com/questions/6416763/checking-if-a-variable-is-an-integer-in-php

I've found a faster way of determining an integer.On my env, this method takes about half the time of using is_int(). Cast the value then check if it is identical to the original. <?php if ( (int) $n !== $n ) {     echo 'not is int'; } else {     echo 'is int'; } ?>

There is a versa to the vice of this int only type check.is_int( $integer_type) will only return true, if the TYPE is int, not the valuectype_digit( $string_type) will only return true if the TYPE is string, and its value is INTtherefore: return ( is_int($value) || ctype_digit($value) );

Just a shorter way to check if your variable is an int or a string containing a int without others digit than 0 to 9 :<?php $bool = ( !is_int($value) ? (ctype_digit($value)) : true );$value = 42; //true$value = '42'; //true$value = '1e9'; //false$value = '0155'; //true$value = 0155; //true$value = 0xFF; //true while it's just the same as 255$value = '0xFF'; //false$value = 'a'; //false$value = array(); //false$value = array('5'); //false$value = array(5); false$value = ''; //false$value = NULL; //false?>Short & cool :)

If you want detect integer of float values, which presents as pure int or float, and presents as string values, use this functions:<?php function isInteger($val){    if (!is_scalar($val) || is_bool($val)) {        return false;    }    if (is_float($val + 0) && ($val + 0) > PHP_INT_MAX) {        return false;    }    return is_float($val) ? false : preg_match('~^((:?+|-)?[0-9]+)$~', $val);}function isFloat($val){    if (!is_scalar($val)) {        return false;    }    return is_float($val + 0);}foreach ([    '11111111111111111', 11111111111111111, // > PHP_INT_MAX - presents in PHP as float     1, '10', '+1', '1.1', 1.1, .2, 2., '.2', '2.',     '-2.', '-.2', null, [], true, false, 'string'] as $value) {    echo $value . ':' . gettype($value) . ' is Integer? - '  . (isInteger($value) ? 'yes' : 'no') . PHP_EOL;    echo $value . ':' . gettype($value) . ' is Float? - '  . (isFloat($value) ? 'yes' : 'no') . PHP_EOL;}?>

Although this can be inferred from the documentation, beware of numeric strings.  I ran into the problem in a MySQL app where I would either SELECT an INT PRIMARY KEY or INSERT a new record and use mysql_insert_id() to get the KEY before continuing onto the new section.  I used is_int() to make sure the subsequent queries wouldn't break when using the key variable.  Unfortunately I failed to realize that while mysql_insert_id() returns an int, mysql_result() always returns a string even if you are SELECTing from an INT field.Spent at least 30 minutes trying to figure out why existing records weren't getting linked, but new records would link fine.  I ended up using intval() on mysql_result() to make sure subsequent queries still always work.

I was looking for the fastest way to check for an unsigned integer which supported large numbers like 4318943448871348 or 0xFFFFFFFF.Fastest I came up with is this:<?phpfunction is_unsigned_int($val) {    return ctype_digit((string) $value));}?>Will return true on 1515, 0xFFFFFFFF, '3515' and '1365158185855141'.Will return false on 0.1515, '415.4134' and '-616'.Be aware though, before PHP 5.1.0 this will return true on an empty string.According to my benchmarks this is about 30% faster than the regex ^\d+$.