Bagaimana cara memeriksa bahwa string adalah int, tetapi bukan dobel, dll.?

PHP memiliki intval()fungsi yang akan mengubah string menjadi integer. Namun saya ingin memeriksa bahwa string adalah bilangan bulat sebelumnya, sehingga saya dapat memberikan pesan kesalahan yang bermanfaat kepada pengguna jika itu salah. PHP memiliki is_int(), tetapi mengembalikan false untuk string seperti "2".

PHP memiliki is_numeric()fungsi, tetapi itu akan mengembalikan true jika angkanya ganda. Saya menginginkan sesuatu yang akan mengembalikan false untuk dobel, tetapi berlaku untuk int.

misalnya:

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

Bagaimana kalau menggunakan ctype_digit?

Dari manual:

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

Contoh di atas akan menampilkan:

String 1820.20 tidak terdiri dari semua digit.
String 10002 terdiri dari semua digit.
String wsl! 12 tidak terdiri dari semua digit.

Ini hanya akan berfungsi jika input Anda selalu berupa string:

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

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

Jika input Anda mungkin bertipe int, maka gabungkan ctype_digitdengan is_int.

Jika Anda peduli dengan angka negatif, maka Anda harus memeriksa input untuk yang sebelumnya -, dan jika demikian, hubungi salah ctype_digitsatu substrdari string input. Sesuatu seperti ini akan melakukannya:

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

filter_var harus melakukannya:

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

tapi

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

Jika Anda hanya ingin Boolean sebagai nilai pengembalian, bungkus menjadi fungsi, misalnya

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

+1 untuk jawaban Dominic (menggunakan ctype_digit). Cara lain yang bisa Anda lakukan adalah dengan paksaan tipe:

$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

Keluarkan ke int. jika masih memiliki nilai yang sama intnya;

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

Sumber .

Punya kebutuhan untuk yang kuat is_intbaru-baru ini. Saya menemukan intval () terlalu tidak terduga:

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

Lihat potongan ini di komentar dokumentasi PHP, dan setelah mengujinya, ia mencakup hampir semua yang Anda berikan padanya:

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

Tapi hati-hati:

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

Salah satu cara yang benar-benar bersih yang saya suka gunakan adalah yang itu. Anda melemparkannya dua kali, pertama masuk int, kedua masuk string, lalu Anda membandingkan dengan ketat ===. Lihat contoh di bawah ini:

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

Sekarang, tentang fungsi Anda my_is_int, Anda dapat melakukan sesuatu seperti ini:

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

Saya menggunakan ini:

function isInt($val){

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

}

var_dump (isInt("1"));

Anda bisa saja memeriksa nomor, jika sudah mengecek daripada casting diberikan angka ganda atau tidak:

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

Hanya untuk angka positif:

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

Memeriksanya:

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

Keluaran:

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)

Coba ini:

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

Juga berfungsi jika $ string Anda memiliki tempat desimal

Ini akan menangani angka negatif juga

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

Saya menemukan cara yang tidak bisa saya temukan di mana pun, jadi saya taruh di sini:

Tanpa basa-basi lagi begini: ctype_digit((string) abs($input))

Contoh:

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

Hasil: (seperti yang diharapkan, saya kira)

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)

Mungkin bukan cara yang paling baik untuk melakukannya. Tetapi Anda dapat menulisnya dalam satu baris.

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

Seperti yang diharapkan:

    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

Kena kau:

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

Beberapa tahun terlambat, tetapi berdasarkan jawaban yang diberikan di sini saya datang dengan solusi yang sedikit lebih akurat (pada boolean, khususnya) dan lebih efisien (saya pikir) daripada kebanyakan jawaban lain:

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

Bekerja seperti yang diharapkan untuk ini:

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

Kecuali mungkin untuk 2 ini:

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

Bagaimana tentang:

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

Fungsi ini seharusnya hanya mengembalikan true untuk nomor string apa saja yang dapat dilemparkan ke int dengan (int)atau intval()tanpa kehilangan sesuatu yang signifikan secara matematis (seperti non-nol setelah titik desimal atau angka di luar rentang integer PHP) sambil menerima hal-hal yang tidak signifikan secara matematis (seperti spasi putih; memimpin nol; atau, setelah titik desimal, nol secara eksklusif).

Ini akan mengembalikan false untuk '10.'tetapi tidak untuk '10.0'. Jika Anda ingin '10.'menjadi benar, Anda dapat mengubah +setelah 0dalam ekspresi reguler menjadi *.

Berikut beberapa kode yang saya gunakan yang tampaknya berfungsi dengan baik dan tidak memiliki masalah yang banyak lainnya.

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

Itu tidak memeriksa pesanan dll jadi tidak dimaksudkan untuk bilangan bulat negatif tetapi dengan beberapa kode tambahan yang dapat dilakukan juga menggunakan beberapa ide lain dari atas. Ini juga dapat diadaptasi untuk bekerja dengan biner array('0', '1')atau Hexadecimal juga dll.

Lihat ini. Mengkonversi $ val ke integer dan kemudian memeriksa apakah $ val asli yang dikonversi ke string adalah IDENTICAL (===) - cukup == tidak akan berfungsi seperti yang diharapkan - ke integer val yang dikonversi ke string.

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

Jika Anda tidak memeriksa nilai string, itu mungkin tidak berfungsi seperti yang Anda harapkan:

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

Keluaran:

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.

Alasan menjadi bahkan jika Anda menggunakan hex (0x101010), oktal (01) atau bilangan bulat yang disimpan sebagai float (1.0, 0.0), secara internal semua disimpan sebagai float. Namun, jika Anda menggunakan fungsi untuk memeriksa int disimpan sebagai string, itu akan berfungsi.

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

Anda dapat menggunakan kondisi berikut. Perhatikan bahwa Anda tidak boleh menggunakan! ==

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

Itu bekerja dengan sempurna! Semoga bermanfaat bagi Anda =)

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

Jika Anda ingin benar-benar tahu apakah sebuah string adalah representasi valid dari tipe integer PHP sejati ...

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

Namun ini tidak mungkin untuk dijalankan karena set terlalu besar (tidak akan muat dalam memori dalam kasus ini, jika Anda mengulanginya akan mengambil terlalu banyak siklus CPU).

Anda mungkin dapat melakukan pencarian biner dengan perbandingan string, namun ada cara yang lebih baik.

Yang paling sederhana:

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

Ada beberapa cara lain yang tidak biasa untuk mendekatinya seperti:

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

Anda juga dapat melakukan perbandingan string tetapi Anda masih harus melakukan hal-hal seperti ctype_digit, periksa panjangnya wajar (jangan buang-buang CPU sebelum melakukan hal-hal seperti ctype_digit) dan memiliki penanganan yang canggung untuk angka negatif.

Perhatikan bahwa filter_var tidak menyatakan dengan benar bahwa string benar-benar representasi dari integer PHP. Ini akan memungkinkan spasi + terkemuka dan sekitarnya.

PHP secara internal menggunakan fungsi "_zend_handle_numeric_str" untuk perbandingan yang ketat tetapi tidak secara langsung mengekspos ini di mana saja, karenanya trik menggunakan kunci array (yang menggunakannya untuk mengubah string apa pun yang merupakan representasi dari integer PHP ke integer PHP).

Jika Anda ingin konversi biner aman ke dan dari PHP, inilah pendekatan yang harus diambil.

Tidak semua orang mungkin menginginkannya dan itu mungkin merupakan kasus penanganan input pengguna. filter_var tidak terlalu buruk untuk itu dan akan cukup aman dalam banyak kasus untuk orang yang baru mengenal PHP.

Pemeriksaan panjang, ctype_digit dan kemudian cek nilai yang dikonversi dalam rentang juga cukup solid untuk input pengguna. Skema yang lebih kompleks mungkin ingin trim atau regex.

Masalah dengan banyak jawaban di sini dalam hal itu adalah bahwa sementara pertanyaannya tidak jelas, jawabannya tidak boleh. Jika Anda akan mengusulkan solusi, Anda harus dapat menjelaskan dengan tepat apa yang akan dan tidak diharapkan. Tanpa itu tidak ada yang tahu apakah jawaban cocok dengan pertanyaan atau aman. Manual PHP tidak selalu membantu karena tidak menjelaskan semua peringatan untuk masing-masing metode yang relevan yang disediakannya. Hal-hal seperti ctype_digit dan is_int sangat dapat diandalkan dan mudah untuk diprediksi tetapi spesifik is_numeric, filter_var dan juggling (+ $ var) atau casting (intval / floatval) kurang didokumentasikan.

Ini adalah PHP fudge untuk Anda. Ini memiliki sejumlah skema untuk menafsirkan string sebagai bilangan bulat, dengan inkonsistensi. Metode paling ketat untuk memvalidasi string integer tidak secara langsung terpapar kepada pengguna.

Jika Anda menangani ID numerik dari mysql dan mencoba untuk memaksakan validasi untuk itu menjadi bukan nol int atau intdalam format string ( karena mysql selalu mengembalikan semuanya dalam format string ) dan tidak NULL. Anda dapat menggunakan yang berikut ini. Ini adalah cara bukti kesalahan / peringatan / pemberitahuan yang paling banyak untuk hanya mengizinkan int/string-intsyang saya temukan.

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

Inilah solusi sederhana yang menggunakan is_numeric , floatval , dan 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;
    }
}

Hasil:

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

Perhatikan bahwa nilai yang lebih besar dari PHP_INT_MAX dapat menghasilkan false.

Bisa menggunakan is_numeric () lalu memeriksa keberadaan "." dalam string (meskipun tidak terlalu peka terhadap budaya).

Atau gunakan is_numeric () lalu gandakan ke ganda dan lihat apakah $ var == floor ($ var) (harus mengembalikan true jika itu bilangan bulat).