Bir dizenin int, çift değil vs. olup olmadığını nasıl kontrol edebilirim?

PHP, bir intval()dizeyi tamsayıya dönüştürecek bir işleve sahiptir . Ancak ben yanlışsa kullanıcıya yararlı bir hata mesajı verebilir böylece dize önceden bir tamsayı olup olmadığını kontrol etmek istiyorum. PHP var is_int(), ancak bu dize için false döndürür "2".

PHP is_numeric()işlevi vardır, ancak sayı bir çift ise bu doğru dönecektir. Bir çift için yanlış, ama bir int için doğru bir şey döndürecek bir şey istiyorum.

Örneğin:

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

Kullanmaya ne dersiniz ctype_digit?

Kılavuzdan:

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

Yukarıdaki örnek çıktı verecektir:

1820.20 dizesi tüm rakamlardan oluşmuyor.
10002 dizesi tüm rakamlardan oluşur.
Wsl! 12 dizesi tüm rakamlardan oluşmaz.

Bu yalnızca girdiniz her zaman bir dize olduğunda çalışır:

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

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

Girişiniz türden olabilirse int, ctype_digitile birleştirin is_int.

Eğer negatif sayılar önem veriyorsan o zaman bir önceki için girdi kontrol etmek gerekir -, ve eğer öyleyse, çağrı ctype_digitbir üzerinde substrgiriş dizesi. Böyle bir şey yapardı:

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

filter_var yapmalı:

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

fakat

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

Booleans'in yalnızca dönüş değerleri olmasını istiyorsanız, bir işleve sarın, örn.

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

Dominic'in cevabına +1 (kullanma ctype_digit). Bunu yapmanın bir başka yolu da tip zorlamasıdır:

$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

İnt. hala aynı değere sahipse int;

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

Kaynak .

is_intSon zamanlarda sağlam bir ihtiyaç vardı . İntval () çok tahmin edilemez buldum:

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 dokümantasyon yorumlarında bu snippet'e rastladım ve test ettikten sonra, attığınız hemen hemen her şeyi kapsar :

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

Ancak dikkatli olun:

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

Kullanmayı sevdiğim gerçekten temiz bir yol bu. İki kez atıyorsunuz, önce intiçeri, ikinci olarak string, sonra sıkı bir karşılaştırma yapıyorsunuz ===. Aşağıdaki örneğe bakın:

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

Şimdi, fonksiyonum hakkında my_is_int, böyle bir şey yapabilirsiniz:

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

Bunu kullanıyorum:

function isInt($val){

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

}

var_dump (isInt("1"));

Sadece bir sayı olup olmadığını kontrol edebilirsiniz, eğer o zaman döküm bir çift verilir ya da verilmez daha kontrol edin:

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

Sadece pozitif sayılar için:

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

Kontrol ediliyor:

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

Çıktı:

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)

Bunu dene:

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

$ Dizenizde ondalık basamak varsa da çalışır

Bu, negatif sayıyla da ilgilenecektir

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

Hiçbir yerde bulamadığım bir yol buldum, bu yüzden buraya koyuyorum:

Daha fazla uzatmadan bu: ctype_digit((string) abs($input))

Misal:

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

Sonuçlar: (beklendiği gibi, sanırım)

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)

Belki de bunu yapmanın en etkili yolu değil. Ama bir satırda yazabilirsiniz.

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

Beklenildiği gibi:

    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

Anladım:

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

Birkaç yıl geç, ama burada verilen cevaplara dayanarak diğer cevaplardan biraz daha doğru (özellikle booleanlarda) ve daha verimli (bence) bir çözüm buldum:

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

Bunlar için beklendiği gibi çalışmak:

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

Belki bu 2 hariç:

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

Nasıl olur:

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

Bu işlev , matematiksel olarak anlamlı olmayan şeyleri kabul ederken, yalnızca matematiksel öneme sahip herhangi bir şeyle (ondalık noktadan sonra sıfır olmayan veya PHP'nin tamsayı aralığının dışındaki sayılar gibi) kaybedilen (int)veya intval()kaybedilmeden kullanılabilecek herhangi bir dize numarası için true değerini döndürmelidir. (boşluk gibi; baştaki sıfırlar; veya ondalık noktadan sonra yalnızca sıfırlar).

İçin yanlış döndürür '10.'ama için döndürmez '10.0'. Eğer '10.'doğru olmak istiyorsanız , normal ifadede olandan +sonrasını olarak değiştirebilirsiniz .0*

Burada kullandığım bazı kodlar iyi çalışıyor gibi görünüyor ve diğerlerinin çoğunun yaptığı sorunlardan hiçbiri yok.

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

Negatif tamsayılar için değil, aynı zamanda yukarıdan diğer fikirlerin bir kısmı kullanılarak da yapılabilen bazı ek kodlarla sipariş vb. İkili array('0', '1')veya Onaltılıklarla da çalışacak şekilde uyarlanabilir .

Bunu gör. $ Val değerini integer değerine dönüştürür ve sonra dizeye dönüştürülen orijinal $ val değerinin IDENTICAL (===) - sadece == beklendiği gibi çalışmaz - dizeye dönüştürülen tamsayı val olup olmadığını kontrol eder.

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

Dize değerlerini kontrol etmezseniz, beklediğiniz gibi çalışmayabilir:

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

Çıktı:

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.

Bunun nedeni, onaltılık (0x101010), sekizli (01) veya kayan nokta (1.0, 0.0) olarak saklanan bir tam sayı kullansanız bile, dahili olarak kayan nokta olarak saklanır. Ancak, dize olarak saklanan int'i denetlemek için işlevi kullanırsanız, çalışır.

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

Aşağıdaki koşulu kullanabilirsiniz. Kullanmamanız gerektiğine dikkat edin! ==

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

Mükemmel çalışıyor! Size yardımcı olacağını umuyoruz =)

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

Bir dizenin gerçek bir PHP tamsayı türünün geçerli bir temsili olup olmadığını gerçekten bilmek istiyorsanız ...

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

Bununla birlikte, set çok büyük olduğundan çalıştırmak mümkün değildir (bu durumda belleğe sığmaz, bunun yerine döngü yaparsanız çok fazla CPU döngüsü sürecektir).

Belki dize karşılaştırması ile ikili bir arama yapabilirsiniz, ancak daha iyi yollar vardır.

En basit varlık:

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

Buna yaklaşmanın bazı alışılmadık yolları vardır:

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

Ayrıca dize karşılaştırması yapabilirsiniz, ancak yine de ctype_digit gibi şeyleri yapmanız, uzunluğun makul olduğunu kontrol etmeniz (ctype_digit gibi şeyler yapmadan önce CPU'yu boşa harcamayın) ve negatif sayılar için garip bir işlem yapmanız gerekir.

O filter_var Not değil bir dize gerçekten bir PHP tamsayı temsil olduğunu assert doğru. Bir lider + ve çevresindeki beyaz alana izin verecektir.

Dahili olarak PHP, katı karşılaştırma için "_zend_handle_numeric_str" işlevini kullanır, ancak bunu doğrudan hiçbir yerde göstermez, bu nedenle dizi anahtarlarını kullanarak hile yapar (bu, bir PHP tamsayısının temsili olan herhangi bir dizeyi bir PHP tamsayısına dönüştürmek için kullanır).

PHP ve ikili ikili dönüşüm istiyorsanız bu yaklaşım almaktır.

Herkes bunu istemeyebilir ve kullanıcı girdilerinin işlenmesi söz konusu olabilir. filter_var bunun için çok kötü değildir ve çoğu durumda PHP'ye yeni başlayanlar için oldukça güvenli olacaktır.

Bir uzunluk kontrolü, ctype_digit ve daha sonra bir aralıktaki dönüştürülmüş değer kontrolü de kullanıcı girişi için oldukça sağlamdır. Daha karmaşık şemalar kırpma veya normal ifade isteyebilir.

Burada bu konuda birçok cevap veren sorun, soru belirsiz olsa da cevapların olmaması gerektiğidir. Bir çözüm önerecekseniz, tam olarak ne olacağını ve ne beklemeyeceğinizi açıklayabilmelisiniz. Bu olmadan, bir yanıtın bir soru ile eşleşip eşleşmediğini veya güvenli olup olmadığını söylemek mümkün değildir. PHP kılavuzu her zaman yardımcı olmaz çünkü sağladığı ilgili yöntemlerin her biri için tüm uyarıları açıklamaz. Ctype_digit ve is_int gibi şeylerin güvenilirliği ve güvenilirliği kolaydır ancak is_numeric, filter_var ve hokkabazlık (+ $ var) veya döküm (intval / floatval) özellikleri yeterince belgelenmemiştir.

Bu sizin için PHP fudge. Dizeleri tamsayı olarak, tutarsızlıklar olarak yorumlamak için sayısız şemaya sahiptir. Bir tam sayı dizesini doğrulamanın en katı yöntemi doğrudan kullanıcıya maruz kalmaz.

Eğer mysql sayısal kimlikleri kullanımı vardır ve geçerli bir sigara sıfır olabilmesi için bir doğrulama empoze etmeye çalışıyorsanız int veya intancak dize biçiminde (içinde MySQL daima dize biçiminde şeyi döndürür olarak ) değil NULL. Aşağıdakileri kullanabilirsiniz. Bu sadece int/string-intsbulduğum izin vermek için en hata / uyarı / uyarı geçirmez yoludur .

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

İşte is_numeric , floatval ve intval kullanan basit bir çözüm :

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

Sonuçlar:

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 değerinden büyük değerlerin false döndürülebileceğini unutmayın.

Her ikisi de is_numeric () öğesini kullanabilir, sonra "." (özellikle kültüre duyarlı değil).

Alternatif olarak, is_numeric () kullanın ve sonra bir çifte yayınlayın ve $ var == floor ($ var) 'a bakın (eğer bir tamsayı ise true değerini döndürmelidir).