Làm thế nào để kiểm tra xem một chuỗi có phải là int không, nhưng không phải là một chuỗi, v.v.?

PHP có một intval()hàm sẽ chuyển đổi một chuỗi thành một số nguyên. Tuy nhiên tôi muốn kiểm tra xem chuỗi có phải là số nguyên trước không, để tôi có thể đưa ra thông báo lỗi hữu ích cho người dùng nếu nó sai. PHP có is_int(), nhưng trả về false cho chuỗi như "2".

PHP có is_numeric()chức năng, nhưng điều đó sẽ trả về true nếu số đó là gấp đôi. Tôi muốn một cái gì đó sẽ trả về false cho một đôi, nhưng đúng cho một int.

ví dụ:

my_is_int("2") == TRUE
my_is_int("2.1") == FALSE

Làm thế nào về việc sử dụng ctype_digit?

Từ hướng dẫn:

<?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";
    }
}
?>

Ví dụ trên sẽ xuất ra:

Chuỗi 1820.20 không bao gồm tất cả các chữ số.
Chuỗi 10002 bao gồm tất cả các chữ số.
Chuỗi wsl! 12 không bao gồm tất cả các chữ số.

Điều này sẽ chỉ hoạt động nếu đầu vào của bạn luôn là một chuỗi:

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

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

Nếu đầu vào của bạn có thể là loại int, sau đó kết hợp ctype_digitvới is_int.

Nếu bạn quan tâm đến các số âm, thì bạn sẽ cần kiểm tra đầu vào cho trước -và nếu vậy, hãy gọi ctype_digitmột substrchuỗi đầu vào. Một cái gì đó như thế này sẽ làm điều đó:

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

filter_var Hãy làm nó:

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

nhưng

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

Nếu bạn chỉ muốn Booleans làm giá trị trả về, hãy bọc nó vào một hàm, vd

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

+1 cho câu trả lời của Dominic (sử dụng ctype_digit). Một cách khác bạn có thể làm là với kiểu ép buộc:

$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

Truyền nó tới int. nếu nó vẫn có cùng giá trị int của nó;

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

/**
 * 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);
    }
}

Nguồn .

Có một nhu cầu cho một mạnh mẽ is_intgần đây. Tôi thấy intval () quá khó đoán:

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

Đã xem qua đoạn trích này trong các nhận xét tài liệu PHP và sau khi thử nghiệm nó, nó bao gồm hầu hết mọi thứ bạn ném vào nó:

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

Nhưng cẩn thận:

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

Một cách thực sự sạch mà tôi muốn sử dụng là cách đó. Bạn đúc nó hai lần, lần đầu tiên int, lần thứ hai string, sau đó bạn so sánh chặt chẽ ===. Xem ví dụ dưới đây:

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

Bây giờ, về chức năng của bạn my_is_int, bạn có thể làm một cái gì đó như thế này:

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

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

Tôi sử dụng cái này:

function isInt($val){

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

}

var_dump (isInt("1"));

Bạn chỉ có thể kiểm tra một số, nếu đó là kiểm tra thì việc truyền có được nhân đôi hay không:

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

Chỉ cho số dương:

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

Kiểm tra nó:

$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));
}

Đầu ra:

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)

Thử cái này:

$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!

Cũng hoạt động nếu chuỗi $ của bạn có vị trí thập phân

Điều này cũng sẽ chăm sóc số âm

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';
}

Tôi đã nghĩ ra một cách mà tôi không thể tìm thấy ở bất cứ đâu, vì vậy tôi sẽ đặt nó ở đây:

Không cần phải quảng cáo thêm, đây là: ctype_digit((string) abs($input))

Thí dụ:

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;
}

Kết quả: (như mong đợi, tôi cho là)

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)

Có lẽ không phải là cách hiệu quả nhất để làm điều đó. Nhưng bạn có thể viết nó trong một dòng.

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

Như mong đợi:

    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

Gotcha:

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

Một vài năm muộn, nhưng dựa trên các câu trả lời được đưa ra ở đây, tôi đã đưa ra một giải pháp chính xác hơn một chút (đặc biệt là về booleans) và hiệu quả hơn (tôi nghĩ) so với hầu hết các câu trả lời khác:

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

Làm việc như mong đợi cho những điều này:

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

Ngoại trừ có thể cho 2:

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

Làm thế nào về:

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;
}

Hàm này chỉ nên trả về true cho bất kỳ số chuỗi nào có thể được chuyển thành int có (int)hoặc intval()không mất bất kỳ thứ gì có ý nghĩa toán học (chẳng hạn như số không sau dấu thập phân hoặc số nằm ngoài phạm vi số nguyên của PHP) trong khi chấp nhận những thứ không có ý nghĩa về mặt toán học (chẳng hạn như khoảng trắng; số 0 đứng đầu; hoặc, sau dấu thập phân, số không dành riêng).

Nó sẽ trả về false cho '10.'nhưng không cho '10.0'. Nếu bạn muốn '10.'là đúng, bạn có thể thay đổi +sau 0biểu thức chính quy thành *.

Ở đây một số mã tôi đã sử dụng dường như hoạt động tốt và không có bất kỳ vấn đề nào mà nhiều người khác làm.

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

Nó không kiểm tra thứ tự, v.v. không có nghĩa là số nguyên âm mà với một số mã bổ sung có thể được thực hiện bằng cách sử dụng một số ý tưởng khác ở trên. Nó cũng có thể được điều chỉnh để hoạt động với nhị phân array('0', '1')hoặc Hexadecimals, v.v.

Xem cái này Chuyển đổi $ val thành số nguyên và sau đó kiểm tra xem $ val ban đầu được chuyển đổi thành chuỗi có phải là IDENTICS (===) - just == sẽ không hoạt động như mong đợi - thành số nguyên được chuyển đổi thành chuỗi.

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;
}

Nếu bạn không kiểm tra giá trị chuỗi, nó có thể không hoạt động như bạn mong đợi:

$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";
}

Đầu ra:

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.

Lý do là ngay cả khi bạn sử dụng hex (0x101010), bát phân (01) hoặc số nguyên được lưu dưới dạng float (1.0, 0.0), bên trong tất cả được lưu trữ dưới dạng float. Tuy nhiên, nếu bạn sử dụng hàm để kiểm tra int được lưu dưới dạng chuỗi, nó sẽ hoạt động.

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;
}

Bạn có thể sử dụng điều kiện sau đây. Lưu ý rằng bạn không nên sử dụng! ==

$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";
}

Nó hoạt động hoàn hảo! Hy vọng nó sẽ hữu ích cho bạn =)

$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);
}

Nếu bạn thực sự muốn biết liệu một chuỗi có phải là đại diện hợp lệ của loại số nguyên PHP thực sự không ...

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

Tuy nhiên, điều này là không thể chạy vì bộ quá lớn (sẽ không vừa với bộ nhớ trong trường hợp này, nếu bạn lặp thay vào đó sẽ mất quá nhiều chu kỳ CPU).

Bạn có thể có thể thực hiện tìm kiếm nhị phân với so sánh chuỗi, tuy nhiên có nhiều cách tốt hơn.

Đơn giản nhất:

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

Có một số cách khác thường để tiếp cận nó như:

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

Bạn cũng có thể thực hiện so sánh chuỗi nhưng bạn vẫn cần thực hiện những việc như ctype_digit, kiểm tra độ dài có hợp lý không (không lãng phí CPU trước khi thực hiện những việc như ctype_digit) và xử lý một cách khó xử đối với các số âm.

Lưu ý rằng filter_var không xác nhận chính xác rằng một chuỗi thực sự là biểu diễn của một số nguyên PHP. Nó sẽ cho phép một khoảng trắng hàng đầu và xung quanh.

PHP bên trong sử dụng hàm "_zend_handle_numeric_str" để so sánh nghiêm ngặt nhưng nó không trực tiếp phơi bày điều này ở bất cứ đâu, do đó, mẹo sử dụng các khóa mảng (sử dụng nó để chuyển đổi bất kỳ chuỗi nào biểu thị số nguyên PHP thành số nguyên PHP).

Nếu bạn muốn chuyển đổi an toàn nhị phân sang và từ PHP thì đây là cách tiếp cận cần thực hiện.

Không phải ai cũng muốn điều đó và đó có thể là một trường hợp xử lý đầu vào của người dùng. filter_var không quá tệ cho điều đó và sẽ khá an toàn trong hầu hết các trường hợp cho những người mới sử dụng PHP.

Kiểm tra độ dài, ctype_digit và sau đó kiểm tra giá trị được chuyển đổi trong phạm vi cũng khá chắc chắn cho đầu vào của người dùng. Đề án phức tạp hơn có thể muốn cắt hoặc regex.

Vấn đề với rất nhiều câu trả lời ở đây về khía cạnh đó là trong khi câu hỏi còn mơ hồ, thì câu trả lời không nên có. Nếu bạn định đề xuất một giải pháp, bạn sẽ có thể giải thích chính xác những gì nó sẽ và không mong đợi. Không có điều đó, không có câu trả lời nào phù hợp với câu hỏi hoặc an toàn. Hướng dẫn PHP không phải lúc nào cũng giúp vì nó không giải thích tất cả các cảnh báo cho từng phương thức có liên quan mà nó cung cấp. Những thứ như ctype_digit và is_int rất đáng tin cậy và dễ predit nhưng các chi tiết cụ thể của is_numeric, filter_var và tung hứng (+ $ var) hoặc truyền (intval / floatval) được ghi lại kém.

Đây là fudge PHP cho bạn. Nó có vô số lược đồ để diễn giải các chuỗi dưới dạng số nguyên, với sự không nhất quán. Phương pháp nghiêm ngặt nhất để xác nhận chuỗi số nguyên không được tiếp xúc trực tiếp với người dùng.

Nếu bạn đang xử lý ID số từ mysql và đang cố áp đặt xác thực cho nó thành một số không hợp lệ int hoặc một intđịnh dạng chuỗi ( vì mysql luôn trả về mọi thứ ở định dạng chuỗi ) và không NULL. Bạn có thể sử dụng như sau. Đây là cách chứng minh lỗi / cảnh báo / thông báo nhiều nhất để chỉ cho phép int/string-intstôi tìm thấy.

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

Đây là một giải pháp đơn giản sử dụng is_numeric , floatval và intval :

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;
    }
}

Các kết quả:

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

Lưu ý rằng các giá trị lớn hơn PHP_INT_MAX có thể trả về false.

Có thể sử dụng is_numeric () sau đó kiểm tra sự hiện diện của "." trong chuỗi (mặc dù không đặc biệt nhạy cảm về văn hóa).

Hoặc sử dụng is_numeric () sau đó chuyển thành gấp đôi và xem $ var == floor ($ var) (sẽ trả về true nếu đó là số nguyên).