Wie kann man überprüfen, ob eine Zeichenfolge ein int, aber kein double usw. ist?

PHP hat eine intval()Funktion, die einen String in eine Ganzzahl konvertiert. Ich möchte jedoch vorher überprüfen, ob die Zeichenfolge eine Ganzzahl ist, damit ich dem Benutzer eine hilfreiche Fehlermeldung geben kann, wenn sie falsch ist. PHP hatis_int() , aber das gibt false für string like zurück "2".

PHP hat die is_numeric() Funktion, aber das gibt true zurück, wenn die Zahl doppelt ist. Ich möchte etwas, das für ein Double false zurückgibt, für ein int jedoch true.

z.B:

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

Wie wäre es mit ctype_digit?

Aus dem Handbuch:

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

Das obige Beispiel gibt Folgendes aus:

Die Zeichenfolge 1820.20 besteht nicht aus allen Ziffern.
Die Zeichenfolge 10002 besteht aus allen Ziffern.
Die Zeichenfolge wsl! 12 besteht nicht aus allen Ziffern.

Dies funktioniert nur, wenn Ihre Eingabe immer eine Zeichenfolge ist:

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

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

Wenn Ihre Eingabe vom Typ sein könnte int, kombinieren Sie sie ctype_digitmit is_int.

Wenn Sie negative Zahlen kümmern, dann müssen Sie die Eingabe für einen vorhergehenden zu überprüfen -, und wenn ja, Anruf ctype_digitauf eine substrder Eingabezeichenfolge. So etwas würde es tun:

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

filter_var Sollte es tun:

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

aber

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

Wenn Sie nur Boolesche Werte als Rückgabewerte möchten, schließen Sie diese in eine Funktion ein, z

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

+1 auf Dominics Antwort (mit ctype_digit). Eine andere Möglichkeit besteht darin, den Typ zu erzwingen:

$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

Wirf es auf int. wenn es immer noch den gleichen Wert hat, ist es 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);
    }
}

Quelle .

Hatte in is_intletzter Zeit ein Bedürfnis nach einem robusten . Ich fand intval () zu unvorhersehbar:

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

Kam in den Kommentaren der PHP-Dokumentation auf dieses Snippet und deckt nach dem Testen fast alles ab, was Sie darauf werfen:

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

Aber Vorsicht:

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

Eine wirklich saubere Art, die ich gerne benutze, ist diese. Sie haben es zweimal gewirkt, erstens int, zweitens string, dann streng verglichen ===. Siehe das folgende Beispiel:

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

Über Ihre Funktion my_is_int können Sie nun Folgendes tun:

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

Ich benutze dieses:

function isInt($val){

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

}

var_dump (isInt("1"));

Sie können einfach nach einer Zahl suchen, wenn dies der Fall ist, wird dem Casting ein Doppel gegeben oder nicht:

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

Nur für positive Zahlen:

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

Überprüfen Sie es:

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

Ausgabe:

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)

Versuche dies:

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

Funktioniert auch, wenn Ihr $ string Dezimalstellen hat

Dies wird auch für negative Zahlen sorgen

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

Ich habe einen Weg gefunden, den ich nirgendwo finden konnte, also setze ich ihn hier ein:

Ohne weiteres ist es das: ctype_digit((string) abs($input))

Beispiel:

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

Ergebnisse: (sind wie erwartet, nehme ich an)

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)

Vielleicht nicht die performanteste Art, es zu tun. Aber Sie können es in einer Zeile schreiben.

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

Wie erwartet:

    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

Erwischt:

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

Ein paar Jahre zu spät, aber basierend auf den hier gegebenen Antworten habe ich eine Lösung gefunden, die etwas genauer (insbesondere bei Booleschen Werten) und effizienter (glaube ich) ist als die meisten anderen Antworten:

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

Arbeiten wie erwartet für diese:

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

Außer vielleicht für diese 2:

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

Wie wäre es mit:

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

Diese Funktion sollte nur true für eine Zeichenfolgenummer zurückgeben, die mit (int)oder in int umgewandelt werden kannintval() ohne Verlust von mathematischer Bedeutung (z. B. Nicht-Nullen nach dem Dezimalpunkt oder Zahlen außerhalb des Ganzzahlbereichs von PHP) während Dinge akzeptiert werden, die mathematisch nicht signifikant sind (z. B. Leerzeichen, führende Nullen oder nach dem Dezimalpunkt ausschließlich Nullen).

Es wird false für, '10.'aber nicht für zurückgegeben '10.0'. Wenn Sie '10.'wahr sein möchten, können Sie das +nach dem 0im regulären Ausdruck ändern *.

Hier ist ein Code, den ich verwendet habe, der gut zu funktionieren scheint und keiner der Probleme hat, die viele der anderen haben.

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

Die Reihenfolge usw. wird nicht überprüft, ist also nicht für negative Ganzzahlen gedacht, sondern mit einem zusätzlichen Code, der auch mit einigen der anderen Ideen von oben ausgeführt werden kann. Es kann auch angepasst werden, um mit Binär- array('0', '1')oder Hexadezimalzahlen usw. zu arbeiten.

Sieh dir das an. Konvertiert $ val in eine Ganzzahl und prüft dann, ob der ursprüngliche $ val, der in eine Zeichenfolge konvertiert wurde, IDENTISCH ist (===) - nur == funktioniert nicht wie erwartet - in die Ganzzahl, die in eine Zeichenfolge konvertiert wurde.

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

Wenn Sie die Zeichenfolgenwerte nicht überprüfen, funktioniert dies möglicherweise nicht wie erwartet:

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

Ausgabe:

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.

Selbst wenn Sie hex (0x101010), octal (01) oder eine als float (1.0, 0.0) gespeicherte Ganzzahl verwenden, werden intern alle als float gespeichert. Wenn Sie die Funktion jedoch verwenden, um nach int zu suchen, das als Zeichenfolge gespeichert ist, funktioniert dies.

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

Sie können die folgende Bedingung verwenden. Beachten Sie, dass Sie nicht verwenden sollten! ==

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

Es funktioniert perfekt! Hoffe es wird dir hilfreich sein =)

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

Wenn Sie wirklich wissen möchten, ob eine Zeichenfolge eine gültige Darstellung eines echten PHP-Integer-Typs ist ...

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

Dies kann jedoch nicht ausgeführt werden, da der Satz zu groß ist (passt in diesem Fall nicht in den Speicher, wenn Sie stattdessen eine Schleife ausführen, dauert es zu viele CPU-Zyklen).

Sie können möglicherweise eine binäre Suche mit Zeichenfolgenvergleich durchführen, es gibt jedoch bessere Möglichkeiten.

Das einfachste Wesen:

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

Es gibt einige andere ungewöhnliche Herangehensweisen, wie zum Beispiel:

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

Sie können auch einen Zeichenfolgenvergleich durchführen, müssen jedoch noch Dinge wie ctype_digit ausführen, überprüfen, ob die Länge angemessen ist (verschwenden Sie keine CPU, bevor Sie Dinge wie ctype_digit ausführen) und mit negativen Zahlen umständlich umgehen.

Beachten Sie, dass filter_var nicht korrekt behauptet, dass eine Zeichenfolge wirklich die Darstellung einer PHP-Ganzzahl ist. Dies ermöglicht ein führendes + und ein umgebendes Leerzeichen.

Intern verwendet PHP die Funktion "_zend_handle_numeric_str" für einen strengen Vergleich, macht dies jedoch nirgendwo direkt verfügbar, daher der Trick mit den Array-Schlüsseln (mit dem eine Zeichenfolge konvertiert wird, die eine PHP-Ganzzahl in eine PHP-Ganzzahl darstellt).

Wenn Sie eine binäre sichere Konvertierung von und nach PHP wünschen, ist dies der richtige Ansatz.

Möglicherweise möchte das nicht jeder, und es kann sich um die Verarbeitung von Benutzereingaben handeln. filter_var ist dafür nicht schlecht und wird in den meisten Fällen für PHP-Neulinge ziemlich sicher sein.

Eine Längenprüfung, ctype_digit und dann eine Prüfung des konvertierten Werts, der sich in einem Bereich befindet, ist auch für Benutzereingaben ziemlich solide. Komplexere Schemata möchten möglicherweise Trimmen oder Regex.

Das Problem bei vielen Antworten hier in dieser Hinsicht ist, dass die Frage zwar vage ist, die Antworten aber nicht sein sollten. Wenn Sie eine Lösung vorschlagen, sollten Sie in der Lage sein, genau zu erklären, was erwartet wird und was nicht. Ohne das ist nicht abzusehen, ob eine Antwort mit einer Frage übereinstimmt oder sicher ist. Das PHP-Handbuch hilft nicht immer, da es nicht alle Einschränkungen für jede der relevanten Methoden erklärt, die es bereitstellt. Dinge wie ctype_digit und is_int sind sehr zuverlässig und leicht zu bearbeiten, aber die Besonderheiten von is_numeric, filter_var und Jonglieren (+ $ var) oder Casting (intval / floatval) sind schlecht dokumentiert.

Dies ist PHP Fudge für Sie. Es gibt eine Vielzahl von Schemata zum Interpretieren von Zeichenfolgen als Ganzzahlen mit Inkonsistenzen. Die strengste Methode zum Überprüfen einer Ganzzahlzeichenfolge ist für den Benutzer nicht direkt verfügbar.

Wenn Sie numerische IDs von MySQL verarbeiten und versuchen, eine Validierung für eine gültige Nicht-Null- Int oder ein intAber im Zeichenfolgenformat ( da MySQL immer alles im Zeichenfolgenformat zurückgibt ) und nicht zu erzwingenNULL . Sie können Folgendes verwenden. Dies ist der fehler-, warnungs- und hinweisungssicherste Weg, nur das zuzulassen, int/string-intswas ich gefunden habe.

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

Hier ist eine einfache Lösung, die is_numeric , floatval und intval verwendet :

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

Ergebnisse:

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

Beachten Sie, dass Werte größer als PHP_INT_MAX möglicherweise false zurückgeben.

Könnte entweder is_numeric () verwenden und dann prüfen, ob "." in der Saite (allerdings nicht besonders kulturempfindlich).

Alternativ können Sie is_numeric () verwenden und dann in ein Double umwandeln und prüfen, ob $ var == floor ($ var) (sollte true zurückgeben, wenn es sich um eine Ganzzahl handelt).