Como verificar se uma string é int, mas não dupla, etc.?

O PHP possui uma intval()função que converterá uma string em um número inteiro. No entanto, quero verificar se a string é um número inteiro de antemão, para que eu possa dar uma mensagem de erro útil ao usuário, se estiver errada. O PHP possui is_int(), mas isso retorna false para strings como "2".

O PHP tem a is_numeric()função, mas isso retornará true se o número for um dobro. Eu quero algo que retorne falso para um duplo, mas verdadeiro para um int.

por exemplo:

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

Que tal usar ctype_digit?

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

O exemplo acima apresentará:

A cadeia 1820.20 não consiste em todos os dígitos.
A sequência 10002 consiste em todos os dígitos.
A cadeia wsl! 12 não consiste em todos os dígitos.

Isso funcionará apenas se sua entrada for sempre uma string:

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

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

Se sua entrada for do tipo int, combine ctype_digitcom is_int.

Se você se importa com números negativos, precisará verificar a entrada para obter uma precedente -e, se for o caso, chamar ctype_digituma substrda sequência de entrada. Algo assim faria:

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

filter_var deve fazê-lo:

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

mas

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

Se você deseja apenas os booleanos como valores de retorno, envolva-os em uma função, por exemplo

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

+1 na resposta de Dominic (usando ctype_digit). Outra maneira de fazer isso é com coerção de tipo:

$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

Faça a conversão para int. se ainda tiver o mesmo valor, 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);
    }
}

Fonte .

Tinha uma necessidade de um robusto is_intrecentemente. Achei intval () imprevisível demais:

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

Me deparei com esse trecho nos comentários da documentação do PHP e, após testá-lo, ele cobre quase tudo o que você lança nele:

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

Mas cuidado:

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

Uma maneira realmente limpa que eu gosto de usar é essa. Você o lança duas vezes, primeiro int, segundo stringe depois faz uma comparação rigorosa ===. Veja o exemplo abaixo:

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

Agora, sobre sua função my_is_int, você pode fazer algo assim:

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

Estou usando este:

function isInt($val){

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

}

var_dump (isInt("1"));

Você pode apenas verificar se há um número, se for então verificar que o vazamento recebe um dobro ou não:

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

Apenas para números positivos:

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

Verificando:

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

Resultado:

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)

Tente o seguinte:

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

Também funciona se a sua string $ tiver casas decimais

Isso cuidará do número negativo també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';
}

Eu inventei uma maneira que não consegui encontrar em lugar nenhum, então estou colocando aqui:

Sem mais delongas, é o seguinte: ctype_digit((string) abs($input))

Exemplo:

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

Resultados: (são como esperado, suponho)

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)

Talvez não seja a maneira mais eficiente de fazer isso. Mas você pode escrever em uma linha.

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

Como esperado:

    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

Peguei vocês:

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

Alguns anos atrasado, mas com base nas respostas dadas aqui, encontrei uma solução um pouco mais precisa (em booleanos, em particular) e mais eficiente (acho) do que a maioria das outras respostas:

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

Trabalhando conforme o esperado para estes:

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

Exceto, talvez, estes 2:

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

E se:

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

Esta função só deve retornar true para qualquer número de string que possa ser convertido para int com (int)ou intval()sem perder nada de significado matemático (como zeros após ponto decimal ou números fora do intervalo inteiro do PHP) enquanto aceita coisas que não são matematicamente significativas (como espaço em branco; zeros à esquerda) ou, após o ponto decimal, zeros exclusivamente).

Retornará false para, '10.'mas não para '10.0'. Se você quisesse '10.'ser verdade, poderia mudar o+ depois do 0na expressão regular para *.

Aqui, usei algum código que parece funcionar bem e não possui nenhum dos problemas que muitos outros têm.

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

Ele não verifica a ordem, etc., portanto não se destina a números inteiros negativos, mas com algum código de adição que pode ser feito usando algumas das outras idéias acima. Também pode ser adaptado para trabalhar com binários array('0', '1')ou hexadecimais, etc.

Veja isso. Converte $ val em número inteiro e, em seguida, verifica se o $ val original convertido em string é IDENTICAL (===) - apenas == não funcionará conforme o esperado - no valor inteiro convertido em 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;
}

Se você não verificar os valores das strings, pode não funcionar como o esperado:

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

Resultado:

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.

Razão mesmo que você use hex (0x101010), octal (01) ou um número inteiro armazenado como float (1.0, 0.0), internamente todos serão armazenados como float. No entanto, se você usar a função para procurar int armazenado como uma sequência, ela funcionará.

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

Você pode usar a seguinte condição. Observe que você não deve usar! ==

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

Funciona perfeitamente! Espero que seja útil para você =)

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

Se você quiser realmente saber se uma string é uma representação válida de um verdadeiro tipo inteiro PHP ...

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

No entanto, isso é impossível de ser executado, pois o conjunto é muito grande (nesse caso, não caberá na memória, se você fizer um loop, em seguida, serão necessários muitos ciclos de CPU).

Talvez você possa fazer uma pesquisa binária com comparação de cadeias, no entanto, existem maneiras melhores.

O ser mais simples:

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

Existem outras maneiras incomuns de abordá-lo, como:

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

Você também pode fazer comparação de strings, mas ainda precisará fazer coisas como ctype_digit, verificar se o tamanho é razoável (não desperdice CPU antes de fazer coisas como ctype_digit) e ter um tratamento estranho para números negativos.

Observe que filter_var não afirma corretamente que uma string é realmente a representação de um número inteiro PHP. Permitirá um + e um espaço em branco circundante.

Internamente, o PHP usa a função "_zend_handle_numeric_str" para comparação estrita, mas não a expõe diretamente em nenhum lugar, daí o truque usando as chaves da matriz (que a utiliza para converter qualquer sequência que seja uma representação de um número inteiro do PHP em um número inteiro do PHP).

Se você deseja uma conversão binária segura de e para PHP, esta é a abordagem a ser adotada.

Nem todo mundo pode querer isso e pode ser um caso de manipulação de entrada do usuário. filter_var não é tão ruim assim e será bastante seguro na maioria dos casos para pessoas novas no PHP.

Uma verificação de comprimento, ctype_digit e, em seguida, uma verificação do valor convertido em um intervalo também é bastante sólido para a entrada do usuário. Esquemas mais complexos podem querer aparar ou regex.

O problema com muitas das respostas aqui a esse respeito é que, embora a pergunta seja vaga, as respostas não devem ser. Se você vai propor uma solução, deve ser capaz de explicar exatamente o que ela vai esperar e o que não vai esperar. Sem isso, não há como saber se uma resposta corresponde a uma pergunta ou é segura. O manual do PHP nem sempre ajuda porque não explica todas as advertências de cada um dos métodos relevantes que ele fornece. Coisas como ctype_digit e is_int são muito confiáveis ​​e fáceis de editar, mas as especificidades de is_numeric, filter_var e malabarismo (+ $ var) ou conversão (intval / floatval) são pouco documentadas.

Este é o fudge do PHP para você. Possui um número incontável de esquemas para interpretar cadeias de caracteres como números inteiros, com inconsistências. O método mais estrito de validar uma sequência inteira não é exposto diretamente ao usuário.

Se você está manipulando IDs numéricos do mysql e está tentando impor uma validação para que seja um int zero diferente de zero ou um intformato mas em formato de string ( como o mysql sempre retorna tudo em formato de string ) e não NULL. Você pode usar o seguinte. Esta é a maneira mais prova de erro / aviso / aviso para permitir apenas o int/string-intsque encontrei.

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

Aqui está uma solução simples que usa is_numeric , floatval e 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;
    }
}

Resultados:

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

Observe que valores maiores que PHP_INT_MAX podem retornar false.

Poderia usar is_numeric () e verificar a presença de "." na string (não particularmente sensível à cultura).

Como alternativa, use is_numeric () e depois converta para um dobro e veja se $ var == floor ($ var) (deve retornar true se for um número inteiro).