¿Cómo verificar que una cadena es un int, pero no un doble, etc.?

PHP tiene una intval()función que convertirá una cadena en un número entero. Sin embargo, quiero comprobar que la cadena es un número entero de antemano, para poder dar un mensaje de error útil al usuario si está equivocado. PHP tiene is_int(), pero eso devuelve falso para una cadena como "2".

PHP tiene la is_numeric()función, pero eso devolverá verdadero si el número es un doble. Quiero algo que devuelva falso para un doble, pero cierto para un int.

p.ej:

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

¿Qué tal el uso ctype_digit?

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

El ejemplo anterior generará:

La cadena 1820.20 no consta de todos los dígitos.
La cadena 10002 consta de todos los dígitos.
La cadena wsl! 12 no consta de todos los dígitos.

Esto solo funcionará si su entrada es siempre una cadena:

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

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

Si su entrada puede ser de tipo int, combínela ctype_digitcon is_int.

Si le importan los números negativos, deberá verificar la entrada de un precedente -y, de ser así, invocar ctype_digituna substrde las cadenas de entrada. Algo como esto lo haría:

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

filter_var Deberías hacerlo:

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

pero

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

Si solo desea booleanos como valores de retorno, ajústelo en una función, por ejemplo

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

+1 a la respuesta de Dominic (usando ctype_digit). Otra forma de hacerlo es con la coerción 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

Envíalo a int. si todavía tiene el mismo 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);
    }
}

Fuente .

Tenía la necesidad de un robusto is_intrecientemente. Encontré intval () demasiado impredecible:

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

Encontré este fragmento en los comentarios de la documentación de PHP, y después de probarlo, cubre casi todo lo que le arrojas:

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

Pero cuidado:

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

Una forma realmente limpia que me gusta usar es esa. Lo lanzas dos veces, primero adentro int, segundo adentro string, luego comparas estrictamente ===. Vea el siguiente ejemplo:

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

Ahora, sobre su función my_is_int, puede hacer algo como esto:

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

Estoy usando este:

function isInt($val){

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

}

var_dump (isInt("1"));

Puede verificar si hay un número, si es así, verifique que al casting se le dé un doble o no:

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

Solo para números positivos:

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

Comprobándolo:

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

Salida:

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)

Prueba esto:

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

También funciona si su cadena de $ tiene decimales

Esto también se encargará del número negativo

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

Ideé una forma que no pude encontrar en ningún lado, así que lo estoy poniendo aquí:

Sin más preámbulos es esto: ctype_digit((string) abs($input))

Ejemplo:

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: (son como se esperaba, supongo)

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)

Quizás no sea la forma más eficaz de hacerlo. Pero puedes escribirlo en una línea.

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

Como se esperaba:

    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

Algunos años tarde, pero en base a las respuestas dadas aquí, se me ocurrió una solución que es un poco más precisa (en booleanos, en particular) y más eficiente (creo) que la mayoría de las otras respuestas:

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

Trabajando como se esperaba para estos:

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

Excepto tal vez por estos 2:

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

Qué tal si:

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 función solo debe devolver verdadero para cualquier número de cadena que se pueda convertir a int con (int)ointval() sin perder nada de importancia matemática (como no ceros después del punto decimal o números fuera del rango entero de PHP) mientras se aceptan cosas que no son matemáticamente significativas (como el espacio en blanco; ceros a la izquierda; o, después del punto decimal, ceros exclusivamente).

Volverá falso para '10.'pero no para '10.0'. Si desea '10.'ser sincero, puede cambiar el +después 0de la expresión regular a *.

Aquí hay un código que he usado que parece funcionar bien y no tiene ninguno de los problemas que tienen muchos de los otros.

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

No verifica el orden, etc., por lo que no está destinado a enteros negativos, sino con algún código de adición que también se puede hacer usando algunas de las otras ideas anteriores. También se puede adaptar para trabajar con binarios array('0', '1')o hexadecimales, etc.

Mira esto. Convierte $ val en entero y luego comprueba si el $ val original convertido en cadena es IDÉNTICO (===), solo == no funcionará como se esperaba, en el entero val convertido en cadena.

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

Si no verifica los valores de cadena, puede que no funcione como lo espera:

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

Salida:

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.

La razón es que incluso si usa hexadecimal (0x101010), octal (01) o un número entero almacenado como flotante (1.0, 0.0), internamente todos se almacenan como flotante. Sin embargo, si usa la función para verificar int almacenado como una cadena, 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;
}

Puede usar la siguiente condición. ¡Tenga en cuenta que no debe 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 perfectamente! Espero que te sea útil =)

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

Si desea saber realmente si una cadena es una representación válida de un verdadero tipo entero de PHP ...

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

Sin embargo, esto es imposible de ejecutar ya que el conjunto es demasiado grande (no cabe en la memoria en este caso, si realiza un bucle en su lugar, tomará demasiados ciclos de CPU).

Quizás pueda hacer una búsqueda binaria con comparación de cadenas, sin embargo, hay mejores formas.

El ser más simple:

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

Hay otras formas inusuales de abordarlo, como:

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

También puede hacer una comparación de cadenas, pero aún tendrá que hacer cosas como ctype_digit, verificar que la longitud sea razonable (no desperdicie la CPU antes de hacer cosas como ctype_digit) y tener un manejo incómodo para los números negativos.

Tenga en cuenta que filter_var no afirma correctamente que una cadena es realmente la representación de un entero PHP. Permitirá un espacio en blanco inicial + y circundante.

Internamente, PHP usa la función "_zend_handle_numeric_str" para una comparación estricta, pero no expone directamente esto en ningún lado, de ahí el truco que usa las teclas de matriz (que lo usa para convertir cualquier cadena que sea una representación de un entero PHP en un entero PHP).

Si desea una conversión segura binaria hacia y desde PHP, este es el enfoque a seguir.

No todos pueden querer eso y podría ser un caso de manejo de la entrada del usuario. filter_var no es tan malo para eso y será bastante seguro en la mayoría de los casos para las personas nuevas en PHP.

Una verificación de longitud, ctype_digit y luego una verificación del valor convertido de que está en un rango también es bastante sólida para la entrada del usuario. Los esquemas más complejos pueden querer recortar o regex.

El problema con muchas de las respuestas aquí a ese respecto es que, si bien la pregunta es vaga, las respuestas no deberían serlo. Si va a proponer una solución, debería poder explicar exactamente qué es lo que esperará y qué no. Sin eso, no se sabe si una respuesta coincide con una pregunta o si es segura. El manual de PHP no siempre ayuda porque no explica todas las advertencias para cada uno de los métodos relevantes que proporciona. Cosas como ctype_digit e is_int son muy confiables y fáciles de predecir, pero los detalles de is_numeric, filter_var y malabares (+ $ var) o casting (intval / floatval) están poco documentados.

Este es PHP fudge para ti. Tiene una gran cantidad de esquemas para interpretar cadenas como enteros, con inconsistencias. El método más estricto para validar una cadena entera no está expuesto directamente al usuario.

Si está manejando ID numéricos de mysql y está tratando de imponer una validación para que sea un int no cero válido o un intpero en formato de cadena ( ya que mysql siempre devuelve todo en formato de cadena ) y no NULL. Puedes usar lo siguiente. Esta es la forma más a prueba de error / advertencia / aviso para permitir solo int/string-intslo que encontré.

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

Aquí hay una solución simple 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

Tenga en cuenta que los valores mayores que PHP_INT_MAX pueden devolver falso.

Podría usar is_numeric () y luego verificar la presencia de "." en la cadena (aunque no particularmente sensible a la cultura).

Alternativamente, use is_numeric (), luego convierta a un doble y vea si $ var == floor ($ var) (debería devolver verdadero si es un entero).