Comment vérifier qu'une chaîne est un int, mais pas un double, etc.?

PHP a une intval()fonction qui convertira une chaîne en entier. Cependant, je veux vérifier au préalable que la chaîne est un entier, afin de pouvoir envoyer un message d'erreur utile à l'utilisateur si ce n'est pas le cas. PHP a is_int(), mais cela renvoie false pour une chaîne comme "2".

PHP a la is_numeric()fonction, mais cela retournera vrai si le nombre est un double. Je veux quelque chose qui retournera faux pour un double, mais vrai pour un int.

par exemple:

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

Que diriez-vous d'utiliser ctype_digit?

À partir du manuel:

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

L'exemple ci-dessus affichera:

La chaîne 1820.20 ne comprend pas tous les chiffres.
La chaîne 10002 se compose de tous les chiffres.
La chaîne wsl! 12 ne comprend pas tous les chiffres.

Cela ne fonctionnera que si votre entrée est toujours une chaîne:

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

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

Si votre entrée est de type int, combinez-la ctype_digitavec is_int.

Si vous vous souciez des nombres négatifs, vous devrez vérifier l'entrée pour un précédent -, et si tel est le cas, appeler ctype_digitsur a substrde la chaîne d'entrée. Quelque chose comme ça le ferait:

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

filter_var devrait le faire:

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

mais

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 vous voulez juste des booléens comme valeurs de retour, enveloppez-les dans une fonction, par exemple

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

+1 à la réponse de Dominic (en utilisant ctype_digit). Une autre façon de procéder consiste à utiliser la coercition de type:

$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

Diffusez-le en int. s'il a toujours la même valeur, son 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);
    }
}

Source .

Avait besoin d'un robuste is_intrécemment. J'ai trouvé intval () trop imprévisible:

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

Je suis tombé sur cet extrait dans les commentaires de la documentation PHP, et après l'avoir testé, il couvre presque tout ce que vous lui lancez:

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

Mais attention:

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

Une façon vraiment propre que j'aime utiliser est celle-là. Vous le lancez deux fois, d'abord dans int, ensuite dans string, puis vous comparez strictement ===. Voir l'exemple ci-dessous:

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

Maintenant, à propos de votre fonction my_is_int, vous pouvez faire quelque chose comme ceci:

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

J'utilise celui-ci:

function isInt($val){

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

}

var_dump (isInt("1"));

Vous pouvez simplement vérifier un nombre, si c'est le cas, vérifiez que le casting reçoit un double ou non:

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

Juste pour les nombres positifs:

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

Vérification:

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

Production:

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)

Essaye ça:

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

Fonctionne également si votre chaîne $ contient des décimales

Cela prendra également en charge le nombre négatif

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

J'ai conçu un moyen que je ne trouve nulle part, alors je le mets ici:

Sans plus tarder, c'est ceci: ctype_digit((string) abs($input))

Exemple:

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

Résultats: (sont comme prévu, je suppose)

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)

Peut-être pas la façon la plus performante de le faire. Mais vous pouvez l'écrire en une seule ligne.

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

Comme prévu:

    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

Je t'ai eu:

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

Quelques années de retard, mais sur la base des réponses données ici, j'ai trouvé une solution légèrement plus précise (sur les booléens, en particulier) et plus efficace (je pense) que la plupart des autres réponses:

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

Travailler comme prévu pour ceux-ci:

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

Sauf peut-être pour ces 2:

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

Que diriez-vous:

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

Cette fonction ne doit renvoyer true que pour tout numéro de chaîne pouvant être converti en int avec (int)ou intval()sans rien perdre de signification mathématique (comme des non-zéros après la virgule décimale ou des nombres en dehors de la plage d'entiers de PHP) tout en acceptant des choses qui ne sont pas mathématiquement significatives (comme les espaces; les zéros non significatifs; ou, après la virgule décimale, les zéros exclusivement).

Il renverra false pour '10.'mais pas pour '10.0'. Si vous vouliez '10.'être vrai, vous pouvez remplacer le +suivant 0dans l'expression régulière par *.

Voici un code que j'ai utilisé qui semble bien fonctionner et qui n'a aucun des problèmes que beaucoup d'autres font.

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

Il ne vérifie pas l'ordre, etc. donc pas destiné aux entiers négatifs, mais avec du code supplémentaire qui peut également être fait en utilisant certaines des autres idées ci-dessus. Il peut également être adapté pour fonctionner avec des binaires array('0', '1')ou des hexadécimaux, etc.

Regarde ça. Convertit $ val en entier, puis vérifie si le $ val d'origine converti en chaîne est IDENTIQUE (===) - juste == ne fonctionnera pas comme prévu - en entier val converti en chaîne.

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 vous ne vérifiez pas les valeurs de chaîne, cela risque de ne pas fonctionner comme prévu:

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

Production:

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 raison étant que même si vous utilisez hex (0x101010), octal (01) ou un entier stocké comme float (1.0, 0.0), tous sont stockés en interne comme float. Cependant, si vous utilisez la fonction pour vérifier les int stockés sous forme de chaîne, cela fonctionnera.

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

Vous pouvez utiliser la condition suivante. Notez que vous ne devez pas utiliser! ==

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

Cela fonctionne parfaitement! J'espère que cela vous sera utile =)

$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 vous voulez vraiment savoir si une chaîne est une représentation valide d'un vrai type entier PHP ...

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

Cependant, cela est impossible à exécuter car l'ensemble est trop grand (ne rentrera pas en mémoire dans ce cas, si vous bouclez à la place, cela prendra trop de cycles CPU).

Vous pouvez peut-être faire une recherche binaire avec comparaison de chaînes, mais il existe de meilleures façons.

Le plus simple étant:

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

Il existe d'autres façons inhabituelles de l'aborder, telles que:

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

Vous pouvez également faire des comparaisons de chaînes, mais vous devrez toujours faire des choses telles que ctype_digit, vérifier que la longueur est raisonnable (ne gaspillez pas le processeur avant de faire des choses comme ctype_digit) et avoir une gestion délicate pour les nombres négatifs.

Notez que filter_var n'affirme pas correctement qu'une chaîne est véritablement la représentation d'un entier PHP. Cela permettra un + au début et un espace blanc environnant.

En interne, PHP utilise la fonction "_zend_handle_numeric_str" pour une comparaison stricte mais elle ne l'expose pas directement n'importe où, d'où l'astuce en utilisant les clés de tableau (qui l'utilise pour convertir toute chaîne qui est une représentation d'un entier PHP en entier PHP).

Si vous voulez une conversion binaire sûre vers et depuis PHP, c'est l'approche à adopter.

Tout le monde ne voudra peut-être pas cela et cela pourrait être un cas de gestion des entrées utilisateur. filter_var n'est pas trop mal pour cela et sera assez sûr dans la plupart des cas pour les nouveaux utilisateurs de PHP.

Une vérification de longueur, ctype_digit, puis une vérification de la valeur convertie indiquant qu'elle est dans une plage est également assez solide pour la saisie de l'utilisateur. Des schémas plus complexes peuvent souhaiter un ajustement ou une expression régulière.

Le problème avec beaucoup de réponses ici à cet égard est que, même si la question est vague, les réponses ne devraient pas l'être. Si vous proposez une solution, vous devriez être en mesure d'expliquer exactement ce à quoi elle s'attendra et ce qu'elle n'attendra pas. Sans cela, il est impossible de dire si une réponse correspond à une question ou est sûre. Le manuel PHP n'aide pas toujours car il n'explique pas toutes les mises en garde pour chacune des méthodes pertinentes qu'il fournit. Des choses comme ctype_digit et is_int sont très fiables et faciles à préditer mais les spécificités de is_numeric, filter_var et jonglage (+ $ var) ou casting (intval / floatval) sont mal documentées.

C'est du fudge PHP pour vous. Il a une myriade de schémas pour interpréter les chaînes comme des entiers, avec des incohérences. La méthode la plus stricte de validation d'une chaîne entière n'est pas directement exposée à l'utilisateur.

Si vous gérez les identifiants numériques de MySQL et essayez d'imposer une validation pour qu'il soit un non valide du zéro int ou un , intmais sous forme de chaîne ( comme MySQL retourne toujours tout format de chaîne ) et non NULL. Vous pouvez utiliser ce qui suit. C'est le moyen le plus résistant aux erreurs / avertissements / avis de n'autoriser que int/string-intsce que j'ai trouvé.

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

Voici une solution simple qui utilise is_numeric , floatval et 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;
    }
}

Résultats:

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

Notez que les valeurs supérieures à PHP_INT_MAX peuvent renvoyer false.

Pourrait utiliser is_numeric () puis vérifier la présence de "." dans la chaîne (pas particulièrement sensible à la culture).

Vous pouvez également utiliser is_numeric () puis transtyper en double et voir si $ var == floor ($ var) (devrait retourner true si c'est un entier).