如何检查一个字符串是整型的，而不是双精度的，等等？

可以使用 is _ numeric ()然后检查字符串中是否存在“ .”(尽管不是特别区分区域性)。

或者使用 is _ numeric () ，然后强制转换为 double，查看 $var = = floor ($var)(如果是整数，应该返回 true)。

/**
* Check if a number is a counting number by checking if it
* is an integer primitive type, or if the string represents
* an integer as a string
*/
function is_int_val($data) {
if (is_int($data) === true) return true;
if (is_string($data) === true && is_numeric($data) === true) {
return (strpos($data, '.') === false);
}
}

来源 。

用 ctype_digit怎么样？

手册上说:

<?php
$strings = array('1820.20', '10002', 'wsl!12');
foreach ($strings as $testcase) {
if (ctype_digit($testcase)) {
echo "The string $testcase consists of all digits.\n";
} else {
echo "The string $testcase does not consist of all digits.\n";
}
}
?>

上面的例子将输出:

The string 1820.20 does not consist of all digits.
The string 10002 consists of all digits.
The string wsl!12 does not consist of all digits.

只有当你的输入始终是一个字符串时，这才会起作用:

$numeric_string = '42';
$integer        = 42;


ctype_digit($numeric_string);  // true
ctype_digit($integer);         // false

如果您的输入可能是 int类型，那么将 ctype_digit与 is_int组合起来。

如果您关心负数，那么您需要检查前面的 -的输入，如果是的话，在输入字符串的 substr上调用 ctype_digit。像这样的东西就可以做到:

function my_is_int($input) {
if ($input[0] == '-') {
return ctype_digit(substr($input, 1));
}
return ctype_digit($input);
}

对多米尼克的回答 + 1(使用 ctype_digit)。另一种方法是使用类型强制:

$inty = "2";
$inty2 = " 2";
$floaty = "2.1";
$floaty2 = "2.0";


is_int($inty + 0); // true
is_int($floaty + 0); // false
is_int($floaty2 + 0); // false


// here's difference between this and the ctype functions.
is_int($inty2 + 0);  // true
ctype_digit($inty2); // false

应该这样做:

var_dump(filter_var('2', FILTER_VALIDATE_INT));   // 2
var_dump(filter_var('2.0', FILTER_VALIDATE_INT)); // false
var_dump(filter_var('2.1', FILTER_VALIDATE_INT)); // false

var_dump(filter_var(2, FILTER_VALIDATE_INT));     // 2
var_dump(filter_var(2.0, FILTER_VALIDATE_INT));   // 2
var_dump(filter_var(2.1, FILTER_VALIDATE_INT));   // false

function validatesAsInt($number)
{
$number = filter_var($number, FILTER_VALIDATE_INT);
return ($number !== FALSE);
}

将其强制转换为 int。 如果它的 int 值仍然相同;

function my_is_int($var) {
$tmp = (int) $var;
if($tmp == $var)
return true;
else
return false;
}

function my_is_int($var) {
return preg_match('/^\d+$/', $var);
}

最近需要一个强健的 is_int，我发现 intval ()太不可预测了:

intval(array('foo', 'bar')) //returns 1 ?!?
intval("2dog") //returns 2 even though the value is definitely not an integer
intval("dog2") //also returns 2

在 PHP 文档注释中偶然发现了这个片段，在测试之后，它涵盖了 差不多的所有内容:

function my_is_int($s) {
return (is_numeric($s) ? intval($s) == $s : false);
}

my_is_int(2); //true
my_is_int("2"); //true
my_is_int(2.1); //false
my_is_int("2.1"); //false
my_is_int("dog"); //false
my_is_int("2dog"); //false
my_is_int("dog2"); //false
my_is_int(array('foo', 'bar')); //false
my_is_int(array(1)); //false

但要小心:

my_is_int(2.0); //true
my_is_int("2.0"); //true

我用这个:

function isInt($val){


return (filter_var($val, FILTER_VALIDATE_INT) !== false && strpos($val, '-') === false);


}


var_dump (isInt("1"));

这个怎么样:

function isIntStr($str) {
return preg_match('/^(-?\d+)(?:\.0+)?$/', trim($str), $ms)
&& bcComp($ms[1], PHP_INT_MAX) <= 0
&& bcComp($ms[1], -PHP_INT_MAX - 1) >= 0;
}

这个函数应该只对任何字符串数字返回 true，这些字符串数字可以用 (int)或 intval()转换为 int，而不会丢失任何具有数学意义的东西(比如小数点后的非零或 PHP 整数范围之外的数字) ，同时接受不具有数学意义的东西(比如空格; 前导零; 或者小数点后的零)。

对于 '10.'返回 false，但对于 '10.0'返回 false。如果希望 '10.'为 true，可以将正则表达式中 0之后的 +更改为 *。

在这里，我使用的一些代码似乎工作得很好，没有其他代码存在的任何问题。

if (0 != strlen(str_replace(range(0, 9), '', $TestInt))) { print 'Not an integer!';}

它不检查顺序等，所以不是为了负整数，但一些加法代码，可以做以及使用其他一些想法从上面。它也可以适用于工作与二进制 array('0', '1')或十六进制以及等。

看这个。将 $val 转换为整数，然后检查转换为字符串的原始 $val 是否为 IDENTICS (= = =)-just = = 不能按预期工作-转换为转换为字符串的整数 val。

function validInt($val, $min=null, $max=null) {
$ival = intval($val);
//echo "'$ival' '$val'<br>\n"; // Uncomment to see the comparisons done in below if block
if(''.$ival !== ''.$val) {
return false;
}
if($min !== null && $ival < $min)
return false;
if($max !== null && $ival > $max)
return false;
return true;
}

如果您不检查字符串值，它可能不会像您期望的那样工作:

$nums = array(
'1',
'+1',
'-1',
'01',
'1.0',
'.0',
'1.123',
'a123',
'0x101010',
1,
-1,
01,
1.0,
.0,
1.123,
0x101010,
);
foreach($nums as $num) {
if(validInt2($num))
echo $num." - Valid integer.<br>\n";
else
echo $num." - Not a valid integer.<br>\n";
}

产出:

1 - Valid integer.
+1 - Not a valid integer.
-1 - Valid integer.
01 - Not a valid integer.
1.0 - Not a valid integer.
.0 - Not a valid integer.
1.123 - Not a valid integer.
a123 - Not a valid integer.
0x101010 - Not a valid integer.
1 - Valid integer.
-1 - Valid integer.
1 - Valid integer.
1 - Valid integer.
0 - Valid integer.
1.123 - Not a valid integer.
1052688 - Valid integer.

原因是即使使用十六进制(0x101010)、八进制(01)或存储为 float (1.0.0.0.0)的整数，内部也都存储为 float。但是，如果您使用该函数检查作为字符串存储的 int，那么它将工作。

public static function isNumeric($value, $negativ = false) {
return is_int($value) || is_string($value) && (
ctype_digit($value) || (
$negativ && $value{0} == '-' && ctype_digit(substr($value, 1))
)
);


//alternativ:
//return $value == (int) $value;
}

试试这个:

$string='12abc';
if ((int)$string==$string) var_dump((int)$string); else echo 'Invalid!';
// Outputs: Invalid!


$string='789';
if ((int)$string==$string) var_dump((int)$string); else echo 'Invalid!';
// Outputs: int 789


$string='345.00';
if ((int)$string==$string) var_dump((int)$string); else echo 'Invalid!';
// Outputs: 345


$string='123.01';
if ((int)$string==$string) var_dump((int)$string); else echo 'Invalid!';
// Outputs: Invalid!

如果 $string 有小数位，也可以工作

这也会处理负数

function myIsInt()
{
return (is_numeric($var) AND (is_int($var) OR ctype_digit(trim($var, '-'))))
}
//'234-' => false
//'-234' => true
//'--234' => false
//'234' => true

function my_is_int($var){
return is_numeric($var) && gettype($var+0)=='integer';
}

您可以使用以下条件。请注意，您不应该使用! = =

$value = 12; // true
$value = '12'; // true
$value = 'abc'; // false
$value = 12.1; // false
$value = '12.1'; // false


if (!is_numeric($value) || (int) $value != (float) $value) {
echo "false";
} else {
echo "true";
}

我发明了一种在任何地方都找不到的方法，所以我把它放在这里:

废话不多说，就是这个: ctype_digit((string) abs($input))

例如:

function means_int($input) {
return ctype_digit((string) abs($input));
}


$list = array(
0,
'0',
1,
'1',
1.1,
'1.1',
2.0,
'2.0',
2.6,
'2.6',
-4,
'-4',
-3.2,
'-3.2',
-30.02,
'-30.02',
100.00,
'100.00',
);


foreach ($list as $x) {
var_dump($x);
var_dump(means_int($x));
echo PHP_EOL;
}

结果: (如我所料)

int(0)
bool(true)


string(1) "0"
bool(true)


int(1)
bool(true)


string(1) "1"
bool(true)


float(1.1)
bool(false)


string(3) "1.1"
bool(false)


float(2)
bool(true)


string(3) "2.0"
bool(true)


float(2.6)
bool(false)


string(3) "2.6"
bool(false)


int(-4)
bool(true)


string(2) "-4"
bool(true)


float(-3.2)
bool(false)


string(4) "-3.2"
bool(false)


float(-30.02)
bool(false)


string(6) "-30.02"
bool(false)


float(100)
bool(true)


string(6) "100.00"
bool(true)

你可以只检查一个数字，如果它是然后检查比铸造是否给了一个双:

((is_numeric($var) && !is_double(1*$var)));

只是为了积极的数字:

(is_numeric($var) && !is_double(1*$var)) && ($var >= 0)

检查一下:

$numbersToCheck = array("a", "-1", "1", "1.0", "1.2");


foreach ($numbersToCheck as $var) {
echo $var . " is integer? ";var_dump((is_numeric($var) && !is_double(1*$var)));


echo $var . " is a positive integer? ";var_dump((is_numeric($var) && !is_double(1*$var)) && ($var >= 0));
}

产出:

a is integer? bool(false)
a is a positive integer? bool(false)
-1 is integer? bool(true)
-1 is a positive integer? bool(false)
1 is integer? bool(true)
1 is a positive integer? bool(true)
1.0 is integer? bool(false)
1.0 is a positive integer? bool(false)
1.2 is integer? bool(false)
1.2 is a positive integer? bool(false)

也许不是最有效的方法，但是你可以写成一行。

function my_is_int($input) {
return intval($input).'' === $input.'';
}

不出所料:

    my_is_int(1);     // TRUE
my_is_int(-1);    // TRUE
my_is_int(1.2);   // FALSE
my_is_int("1");   // TRUE
my_is_int("-1");  // TRUE
my_is_int("1.2"); // FALSE
my_is_int(0);     // TRUE
my_is_int(null);  // FALSE

抓到你了:

    my_is_int(1.0);   // TRUE
my_is_int("1.0"); // FALSE

虽然晚了几年，但基于这里给出的答案，我想出了一个比其他大多数答案稍微更准确(尤其是布尔型)和更有效(我认为)的解决方案:

function my_is_int($s) {
return ctype_digit($s) || is_int($s);
}

正如预期的那样:

my_is_int(2);                   // true
my_is_int("2");                 // true
my_is_int(-2);                  // true
my_is_int(2.0);                 // false
my_is_int("2.0");               // false
my_is_int(2.1);                 // false
my_is_int("2.1");               // false
my_is_int("dog");               // false
my_is_int("2dog");              // false
my_is_int("dog2");              // false
my_is_int(array('foo', 'bar')); // false
my_is_int(array(1));            // false
my_is_int(true);                // false
my_is_int(false);               // false
my_is_int("true");              // false
my_is_int("false");             // false
my_is_int("0x101010");          // false

除了这两个:

my_is_int(0x101010);            // true
my_is_int("-2");                // false

如果你真的想知道一个字符串是否是一个真正的 PHP 整数类型的有效表示..。

in_array($string, array_map('strval', range(PHP_INT_MIN, PHP_INT_MAX)), true)

然而，这是不可能的运行，因为集太大(在这种情况下不适合在内存中，如果您循环，而是将采取太多的 CPU 周期)。

您也许可以使用字符串比较进行二进制搜索，但是有更好的方法。

最简单的就是:

strlen($string) <= max(strlen((string)PHP_INT_MIN), strlen((string)PHP_INT_MAX)) && $string === (string)(int)$string

还有其他一些不同寻常的方法来解决这个问题，例如:

is_int(array_keys([$string => null])[0])

你也可以做字符串比较，但是你仍然需要做一些事情，比如 ctype _ digital，检查长度是否合理(在做 ctype _ digital 之前不要浪费 CPU) ，并且对负数有一些笨拙的处理。

请注意，filter _ var 没有正确地断言字符串确实是 PHP 整数的表示。它将允许前导 + 和周围的空格。

在内部，PHP 使用函数“ _ zend _ handle _ numeric _ str”进行严格的比较，但是它并不直接在任何地方公开这个函数，因此使用数组键(它确实使用数组键将任何表示 PHP 整数的字符串转换为 PHP 整数)。

如果您希望在 PHP 和 PHP 之间进行二进制安全转换，可以采用这种方法。

并不是每个人都希望这样，这可能是处理用户输入的一种情况。Filter _ var 在这方面还不错，对于 PHP 新手来说，在大多数情况下是相当安全的。

对于用户输入，长度检查、 ctype _ data 和转换后的值检查(它在一个范围内)也是相当可靠的。更复杂的方案可能需要修剪或正则表达式。

这方面很多答案的问题在于，尽管问题很模糊，但答案不应该是模糊的。如果你打算提出一个解决方案，你应该能够准确地解释它将会和不会期望什么。没有这个，就不知道答案是否与问题相匹配或者是否安全。PHP 手册并不总是有帮助，因为它没有解释它提供的每个相关方法的所有警告。诸如 ctype _ digital 和 is _ int 之类的东西是非常可靠的，并且很容易预测，但是关于 is _ numeric、 filter _ var 和 jugging (+ $var)或 cast (intval/floatval)的细节文档很少。

这是给你的 PHP 软糖。它有无数的模式用于将字符串解释为整数，并且不一致。验证整数字符串的最严格的方法不会直接向用户公开。

我喜欢用的一种非常干净的方法就是那个。你施放了两次，第一次在 int，第二次在 string，然后你严格比较 ===。请看下面的例子:

$value === (string)(int)$value;

现在，关于你的函数 my _ is _ int，你可以这样做:

function my_is_int($value){ return $value === (string)(int)$value; }
my_is_int('2');  // true
my_is_int('2.1') // false

如果您正在处理 mysql 中的数字 ID，并试图强制验证它是有效的非零 Int或 int，但是是字符串格式(因为 mysql 总是以字符串格式返回所有内容)而不是 NULL。您可以使用以下内容。这是最错误/警告/通知证明的方式，只允许 int/string-ints，我发现。

...
if(empty($id) || !is_scalar($id) || !ctype_digit($id)){
throw("Invalid ID");
}
...

下面是一个使用 是 _ numeric、 Floatval和 Inval的简单解决方案:

function is_string_an_int($string)
{
if (is_string($string) === false)
{
//throw some kind of error, if needed
}


if (is_numeric($string) === false || floatval(intval($string)) !== floatval($string))
{
return false;
}


else
{
return true;
}
}

结果:

is_string_an_int('-1'); //true
is_string_an_int('-1.0'); //true
is_string_an_int('-1.1'); //false
is_string_an_int('0'); //true
is_string_an_int('0.0'); //true
is_string_an_int('0.1'); //false
is_string_an_int('1'); //true
is_string_an_int('1.0'); //true
is_string_an_int('1.1'); //false
is_string_an_int('' . PHP_INT_MAX); //true
is_string_an_int('foobar'); //false
is_string_an_int('NaN'); //false
is_string_an_int('null'); //false
is_string_an_int('undefined'); //false

注意，大于 PHP _ INT _ MAX 的值可能返回 false。

它工作得很好! 希望对你有帮助

$value = 1; // true
$value = '1'; // true
$value = '1.0'; // true
$value = ' 1'; // true
$value = '01'; // true


$value = -1; // true
$value = '-1'; // true
$value = '-1.0'; // true
$value = ' -1'; // true
$value = '-01'; // true


$value = PHP_INT_MIN; // true
$value = PHP_INT_MAX; // true
$value = 0x000001; // true


$value = 'a'; // false
$value = '1a'; // false
$value = 'a1'; // false
$value = 1.1; // false
$value = '1.1'; // false
$value = '--1'; // false
$value = []; // false
$value = [1,2]; // false
$value = true; // false
$value = false; // false
$value = null; // false
$value = 'NaN'; // false
$value = 'undefined'; // false


function isInt($value) {
return is_numeric($value) && floatval(intval($value)) === floatval($value);
}

下面是一个有效的1行示例:

<?php
// combination of is_int and type coercion
// FALSE: 0, '0', null, ' 234.6',  234.6
// TRUE: 34185, ' 34185', '234', 2345
$mediaID =  34185;
if( is_int( $mediaID + 0) && ( $mediaID + 0 ) > 0 ){
echo 'isint'.$mediaID;
}else{
echo 'isNOTValidIDint';
}
?>

一个简单的方法是将数字强制转换为整数和浮点数，并检查它们是否相同

if ((int) $val == (float) $val) {
echo 'AN INTEGER';
} else {
echo 'NOT AN INTEGER';
}

$int_check=(int)(trim($val));   // returning 0 for non int value
if($int_check<=0){
// do for non int
}
else
{
`enter code here`//integer
}