문자열이 int이지만 double이 아닌지 확인하는 방법은 무엇입니까?

PHP에는 intval()문자열을 정수로 변환 하는 함수가 있습니다. 그러나 문자열이 정수인지 미리 확인하여 잘못된 경우 사용자에게 유용한 오류 메시지를 줄 수 있습니다. PHP는 is_int()있지만 문자열과 같은 경우 false를 반환합니다 "2".

PHP에는 is_numeric()함수가 있지만 숫자가 두 배이면 true를 반환합니다. 더블에 대해서는 false를 반환하지만 int에 대해서는 true를 반환하는 것을 원합니다.

예 :

my_is_int("2") == TRUE
my_is_int("2.1") == 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";
    }
}
?>

위의 예는 다음과 같이 출력됩니다.

문자열 1820.20이 모든 숫자로 구성되는 것은 아닙니다.
문자열 10002는 모든 숫자로 구성됩니다.
문자열 wsl! 12는 모든 숫자로 구성되지 않습니다.

입력이 항상 문자열 인 경우에만 작동합니다.

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

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

귀하의 의견은 유형이 될 수있는 경우 int, 다음 결합 ctype_digit으로 is_int.

음수에 관심이 있다면 앞에있는 입력을 확인해야하고, 입력 된 -경우 입력 문자열 중 ctype_digit하나 substr를 호출 해야 합니다. 이와 같은 것이 그렇게 할 것입니다 :

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

filter_var 그것을해야합니다 :

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

Dominic의 답변에 +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

int로 캐스트하십시오. 여전히 같은 값을 가지고 있다면 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);
    }
}

소스 .

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

제가 가장 좋아하는 방법은 바로 그 방법입니다. 먼저 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

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

나는 이것을 사용하고있다 :

function isInt($val){

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

}

var_dump (isInt("1"));

캐스팅이 두 배인지 아닌지 확인하는 경우 숫자를 확인할 수 있습니다.

((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)

이 시도:

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

나는 어디서도 찾을 수없는 방법을 고안 했으므로 여기에 넣습니다.

더 이상 고민하지 않으면 다음과 같습니다. 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)

아마도 가장 성능이 좋은 방법은 아닙니다. 그러나 한 줄로 작성할 수 있습니다.

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

이 경우를 제외하고 2 :

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

어때요?

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

이 함수는 (int)또는 로 int로 캐스트 할 수있는 문자열 번호에 대해서만 true를 리턴해야합니다.intval() (PHP의 정수 범위를 벗어난 소수점 또는 숫자 후 비 제로와 같은) 수학적으로 중요하지 않은 물건을받을 때 수학적 의미의 아무것도 잃지 않고 (예 : 공백, 선행 0 또는 소수점 뒤에 0)

에 '10.'대해서는 false를 반환 하지만에 대해서는 그렇지 않습니다 '10.0'. '10.'사실 이길 원한다면 정규 표현식에서 +이후를로 변경할 수 있습니다 .0*

여기에 내가 사용한 코드가 잘 작동하고 다른 코드 중 많은 문제가 없습니다.

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

순서 등을 검사하지 않으므로 음의 정수를 의미하지 않지만 위의 다른 아이디어를 사용하여 수행 할 수있는 추가 코드가 있습니다. 또한 바이너리 array('0', '1')또는 16 진수 와 함께 작동하도록 조정할 수도 있습니다 .

이것 좀 봐. $ val을 정수로 변환 한 다음 문자열로 변환 된 원래 $ val이 IDENTICAL (===)인지 확인합니다. === 예상대로 작동하지 않습니다-문자열로 변환 된 정수 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.

16 진 (0x101010), 8 진 (01) 또는 float (1.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;
}

다음 조건을 사용할 수 있습니다. ! ==를 사용해서는 안됩니다.

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

완벽하게 작동합니다! 그것이 당신에게 도움이되기를 바랍니다 =)

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

문자열이 진정한 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_digit와 같은 작업을 수행하고 길이가 적절한 지 확인하고 (ctype_digit와 같은 작업을 수행하기 전에 CPU를 낭비하지 마십시오) 음수를 처리하기가 어색합니다.

filter_var 은 문자열이 실제로 PHP 정수의 표현이라고 올바르게 주장 하지 않습니다 . 선행 + 및 주변 공백을 허용합니다.

내부적으로 PHP는 엄격한 비교를 위해 "_zend_handle_numeric_str"함수를 사용하지만,이를 어디서나 직접 노출시키지 않으므로 배열 키를 사용하는 트릭이 있습니다 (PHP 정수를 나타내는 문자열을 PHP 정수로 변환하는 데 사용됨).

PHP에서 바이너리로 안전하게 변환하려면이 방법을 사용하십시오.

모든 사람이 원하는 것은 아니며 사용자 입력을 처리하는 경우 일 수 있습니다. filter_var는 그다지 나쁘지 않으며 대부분의 경우 PHP를 처음 사용하는 사람들에게는 상당히 안전합니다.

길이 확인, ctype_digit 및 범위 내에있는 변환 된 값 확인도 사용자 입력에있어 상당히 견고합니다. 더 복잡한 체계는 트림 또는 정규식을 원할 수 있습니다.

그 점에서 많은 답변이있는 문제는 질문이 모호하지만 답변이해서는 안된다는 것입니다. 솔루션을 제안하려는 경우 솔루션이 무엇을 기대하고 기대하지 않을지를 정확하게 설명 할 수 있어야합니다. 그렇지 않으면 답변이 질문과 일치하는지 또는 안전한지 알 수 없습니다. PHP 매뉴얼은 그것이 제공하는 각 관련 방법에 대한 모든 경고를 설명하지 않기 때문에 항상 도움이되지는 않습니다. ctype_digit 및 is_int와 같은 것은 매우 안정적이며 쉽게 편집 할 수 있지만 is_numeric, filter_var 및 juggling (+ $ var) 또는 캐스팅 (intval / floatval)의 세부 사항은 제대로 문서화되지 않았습니다.

이것은 당신을위한 PHP 퍼지입니다. 불일치와 함께 문자열을 정수로 해석하기위한 수많은 스키마가 있습니다. 정수 문자열을 검증하는 가장 엄격한 방법은 사용자에게 직접 노출되지 않습니다.

mysql에서 숫자 ID를 처리하고 유효한 0이 아닌 int 또는 int문자열 형식 ( mysql은 항상 모든 문자열 형식으로 문자열을 반환하므로)이 아닌 유효성을 검사하려고하는 경우 NULL. 다음을 사용할 수 있습니다. 이것은 int/string-ints내가 찾은 것만 허용 하는 가장 오류 / 경고 / 통지 증거 방법 입니다.

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

다음은 is_numeric , floatval 및 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;
    }
}

결과 :

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를 반환 할 수 있습니다.

is_numeric ()을 사용하여 "."가 있는지 확인할 수 있습니다. 문자열에서 (특히 문화에 민감한 것은 아닙니다).

또는 is_numeric ()을 사용하여 double로 캐스트하고 $ var == floor ($ var)인지 확인하십시오 (정수인 경우 true를 리턴해야 함).