कैसे जांचें कि एक स्ट्रिंग एक इंट है, लेकिन एक डबल नहीं, आदि?

Question

PHP में एक intval()फ़ंक्शन होता है जो स्ट्रिंग को पूर्णांक में बदल देगा। हालाँकि मैं यह जाँचना चाहता हूँ कि स्ट्रिंग पहले से ही एक पूर्णांक है, ताकि मैं गलत होने पर उपयोगकर्ता को एक उपयोगी त्रुटि संदेश दे सकूँ। PHP के पास है is_int(), लेकिन यह स्ट्रिंग की तरह गलत है "2"।

PHP के पास is_numeric()फंक्शन है, लेकिन संख्या दोगुनी होने पर यह सच हो जाएगी। मैं ऐसा कुछ चाहता हूं जो एक दोहरे के लिए गलत हो, लेकिन एक इंट के लिए सच है।

उदाहरण के लिए:

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

Comments

"2.0" का इलाज कैसे किया जाना चाहिए?

— निक

Answer 1

कैसे उपयोग करने के बारे में 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);
}

Comments

नकारात्मक संख्या?

— अनुराग

@ अनुराग, में संपादित (हालांकि यदि आप वास्तव में इस सामान की परवाह करते हैं, तो एक रेगीक्स शायद सरल है)।

— डोमिनिक रॉगर

यदि आप ऋणात्मक पूर्णांकों की जांच करना चाहते हैं, तो एब्स () का उपयोग करें जैसे कि ctype_digit(abs($str))इसके बजाय ctype_digit।

— ENCHANCE

@enchance abs('definitelynotanint') === 0। इसके अलावा, ctype_digitकेवल स्ट्रिंग्स लेता है

— केलसुन

यह सही नहीं है। PHP में एक बड़ा पूर्णांक एक डबल है!

— jgmjgm

Answer 2

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

Comments

मुझे अधिकांश उत्तर पसंद हैं, लेकिन मुझे लगता है कि यह सबसे सुरुचिपूर्ण है।

— इयान डुन

@grenoult 3v4l.org/qVRRS स्ट्रिंग्स और पूर्णांक के लिए int 0 देता है, इसलिए सुनिश्चित नहीं है कि आपको क्यों लगता है कि यह काम नहीं करता है। क्या आप परिणाम की तुलना ==शायद कर रहे हैं?

— गॉर्डन

@ मेरी गलती से, मैं वास्तव में केवल if 3v4l.org/IAvCF के

— Guillaume

यह कुछ अजीब चीजें करेगा जैसे कि "+123" के लिए सही है। यह माना जाता है कि यह वास्तविक इंट को वापस करने के लिए है, लेकिन यह अभी भी नहीं हो सकता है कि लोग क्या चाहते हैं जो एक सख्त इंट चेक है।

— jgmjgm

@ MohammedRédaOUASSINI ओपी ने तारों को मान्य करने के लिए कहा , न कि तैरने के लिए। यह होगा यदि आप '-1.0' में (एक स्ट्रिंग) पास काम यह होगा नहीं करता है, तो आप में -1.0 (एक नाव) पास काम करते हैं, लेकिन यह एक आवश्यकता के साथ शुरू करने के लिए नहीं था। 3v4l.org/bOX6X

— गॉर्डन

Answer 3

डोमिनिक के जवाब के लिए +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

Comments

+1 आपको भी (हालांकि मुझे आश्चर्य है कि अगर उस विशेष मामले को इनपुट स्ट्रिंग को ट्रिम करके अधिक स्पष्ट रूप से नियंत्रित किया जाएगा)।

— डोमिनिक रॉगर

यह विधि गैर-संख्यात्मक स्ट्रिंग्स के लिए काम नहीं करती है: is_int ("abc" +0) सच है

— काई पोमेरेंके

सच है, यह नॉन-न्यूमेरिक स्ट्रिंग्स के लिए काम नहीं करता है ... किस बारे में is_int($inty + 0) && is_numeric($inty)(मुझे पता है कि यह एक आलसी समाधान है, लेकिन अधिकांश इरादों और उद्देश्यों के लिए काम करता है ...

— एलेक्स मैनटूट

टाइप जॉगिंग का उपयोग करने से काफी ढीली जाँच होगी जहाँ सभी प्रकार के स्ट्रिंग तरीकों से इन्ट्स का प्रतिनिधित्व किया जा सकता है, यह स्ट्रिंग चेक नहीं है। आपको भी +0 की जरूरत नहीं है। आप बस + $ var कर सकते हैं।

— jgmjgm

Answer 4

इसे इंट कास्ट करें। अगर यह अभी भी अपने int के समान मूल्य है;

function my_is_int($var) {
  $tmp = (int) $var;
  if($tmp == $var)
       return true;
  else
       return false;
}

Comments

या इससे भी कम:return $var == (int) $var;

— Al.G.

@ AI.G। यदि कलाकार विफल हो जाता है तो क्या होता है

— डॉ।

यह बहुत करीब है, अगर जरूरत नहीं है, तो बाजीगरी से बचना चाहिए। यह काम करेगा अगर $ var "123xxxx" हो।

— jgmjgm

Answer 5

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

स्रोत ।

Comments

थोड़ा उपयोगिता कार्यों के साथ अपने कोड को बिखेरने के बजाय, मुझे कुछ ऐसा चाहिए जो php में बनाया गया हो।

— रॉरी

मुझे ये हैक पसंद नहीं है। लेकिन डोमिनिक द्वारा इस दृष्टिकोण या ctype सुझाव का उपयोग करते हुए, आप किसी भी तरीके से सभी कार्यान्वयन को इनकैप्सुलेट करने जा रहे हैं। Php का उपयोग करते समय, मेरे पास इन समस्याओं को दूर करने के लिए हमेशा एक "Util" क्लास होता है।

— GmonC

elseifसिर्फ ifइसलिए हो सकता है क्योंकि आप पहले ही इसके ऊपर दिए गए बयान में लौट आए हैं।

— रयॉब ११

इसके अलावा अंत में झूठे लौटने की कोई जरूरत नहीं है।

— rybo111

यदि $dataकोई वस्तु है, तो यह वापस आ जाएगी null। return false;अंत में बेहतर है ।

— थियोडोर आर। स्मिथ

Answer 6

is_intहाल ही में एक मजबूत की जरूरत थी । मैंने पाया कि बहुत ही अप्रत्याशित है:

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

Answer 7

एक सच में साफ तरीका है कि मैं का उपयोग करना पसंद है कि एक है। आप इसे दो बार, पहले में 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

Answer 8

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

Comments

मैंने इसके एक भिन्नता का उपयोग किया, जिससे संख्या संकेत की अनुमति दी गई:'/^[-+]?[0-9]+$/'

— डेनिलसन सा मैया

यह ctype_digit के समान है, यह एक अनुगामी न्यूलाइन की भी अनुमति देता है।

— jgmjgm

Answer 9

मैं इस एक का उपयोग कर रहा हूँ:

function isInt($val){

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

}

var_dump (isInt("1"));

Answer 10

आप बस एक नंबर के लिए जाँच कर सकते हैं, अगर यह है तो जाँच की तुलना में कास्टिंग एक डबल दिया जाता है या नहीं:

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

Comments

is_numeric () वही था जिसकी मुझे तलाश थी।

— ccjjmartin

यह सुनिश्चित करने के लिए कि आप क्या चाहते हैं, आपको PHP स्रोत को पढ़ना होगा क्योंकि यह अच्छी तरह से प्रलेखित नहीं है। उदाहरण के लिए, is_numeric अग्रणी व्हाट्सएप स्वीकार करता है, जो कुछ ऐसा नहीं है जो PHP मैनुअल में प्रलेखित है। आपको यह भी ध्यान में रखना चाहिए कि स्ट्रिंग पूर्णांक जो एक देशी इंट के साथ प्रतिनिधित्व करने के लिए बहुत बड़े हैं, फ्लोट में कनवर्ट किए जाते हैं।

— jgmjgm 19

Answer 11

इसे इस्तेमाल करे:

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

यह भी काम करता है अगर आपके $ स्ट्रिंग में दशमलव स्थान हैं

Comments

यह 123xxxx को एक वैध इंट स्ट्रिंग के रूप में मानेगा।

— jgmjgm

Answer 12

इससे नकारात्मक संख्या का भी ध्यान रखा जाएगा

function myIsInt()
{
   return (is_numeric($var) AND (is_int($var) OR ctype_digit(trim($var, '-'))))
}
//'234-' => false
//'-234' => true
//'--234' => false
//'234' => true

Comments

मुझे समझ में नहीं आता कि यह 234- या - 234 के लिए गलत क्यों होगा, क्या आपने इसका परीक्षण किया था? यह ----- 1234 ----

— jgmjgm

Answer 13

function my_is_int($var){
    return is_numeric($var) && gettype($var+0)=='integer';
}

Answer 14

मैंने एक तरह से तैयार किया, जो मुझे कहीं भी नहीं मिला, इसलिए मैं इसे यहां डाल रहा हूं:

आगे की हलचल के बिना यह है: 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)

Comments

abs स्ट्रिंग से लेकर न्यूमेरिक तक इनपुट कर रहा है। यह is_int (+ $ var) के समान है।

— jgmjgm

Answer 15

शायद ऐसा करने का सबसे अच्छा तरीका नहीं है। लेकिन आप इसे एक पंक्ति में लिख सकते हैं।

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

Comments

यह एक सही है, जब तक आप यह सुनिश्चित करते हैं कि $ इनपुट टाइप स्ट्रिंग का है।

— jgmjgm 18

Answer 16

कुछ साल देर से, लेकिन यहाँ दिए गए जवाबों के आधार पर मैं एक ऐसा समाधान लेकर आया हूँ, जो अन्य सभी उत्तरों की तुलना में थोड़ा अधिक सटीक है (बुलियन पर, विशेष रूप से) और अधिक कुशल (मुझे लगता है):

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

Comments

बहुत अच्छा। यदि आप नकारात्मक संकेत के साथ संख्यात्मक स्ट्रिंग को संभालना चाहते हैं, तो आप ctype_digits (preg_replace ('/ ^ - /', '', 's') को बदल सकते हैं, हालांकि यह थोड़ा लंबा होना शुरू हो जाता है। इसके अलावा, 0x101010 एक इंट है, इसलिए यह कोई त्रुटि नहीं है, बल्कि "0x101010" को गलत माना जा सकता है, और मुझे यकीन है कि बाइनरी शाब्दिक बाइनरी शाब्दिक संकेतन ("0b11111") से मेल खाता है और साथ ही विफल हो जाएगा

— fasas

Answer 17

कैसा रहेगा:

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)या intval()बिना int के लिए डाला जा सकता है (जैसे कि दशमलव बिंदु के बाद गैर-शून्य या PHP के पूर्णांक सीमा के बाहर की संख्या), उन चीजों को स्वीकार करते हुए जो गणितीय रूप से महत्वपूर्ण नहीं हैं (जैसे व्हॉट्सएप; अग्रणी शून्य; या, दशमलव बिंदु के बाद, विशेष रूप से शून्य)।

यह असत्य के लिए लौटेगा, '10.'लेकिन इसके लिए नहीं '10.0'। यदि आप '10.'सही होना चाहते हैं तो आप नियमित अभिव्यक्ति के +बाद में बदल सकते हैं ।0*

Answer 18

यहाँ मैंने कुछ कोड का उपयोग किया है जो अच्छी तरह से काम करता है और उनमें से कोई भी ऐसा मुद्दा नहीं है जो कई अन्य करते हैं।

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

यह ऑर्डर आदि की जांच नहीं करता है, इसलिए यह नकारात्मक पूर्णांक के लिए नहीं है, लेकिन कुछ अतिरिक्त कोड के साथ जो ऊपर से कुछ अन्य विचारों का उपयोग करके किया जा सकता है। इसे बाइनरी array('0', '1')या हेक्साडेसिमल के साथ भी काम करने के लिए अनुकूलित किया जा सकता है आदि।

Comments

यह सिर्फ एक बहुत महंगा ctype_digit है।

— jgmjgm

Answer 19

यह देखो। $ वैल को पूर्णांक में रूपांतरित करता है और फिर जाँचता है कि स्ट्रिंग में परिवर्तित मूल $ वैल IDENTICAL (===) है - बस == अपेक्षा के अनुरूप काम नहीं करेगा - पूर्णांक स्ट्रिंग में परिवर्तित वैल।

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.

यदि आप हेक्स (0x101010), ऑक्टल (01) या फ़्लोट के रूप में संग्रहीत पूर्णांक (1.0, 0.0) का उपयोग करते हैं, तो भी आंतरिक रूप से सभी को फ़्लोट के रूप में संग्रहीत किया जाता है। हालांकि, यदि आप एक स्ट्रिंग के रूप में संग्रहित इंट के लिए जांच करने के लिए फ़ंक्शन का उपयोग करते हैं, तो यह काम करेगा।

Answer 20

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

Comments

यह एक जाँच याद आ रही है कि स्ट्रिंग! == ''। यदि आप इसमें बहुत लंबा पूर्णांक लगाते हैं, तो यह कुछ के लिए भी सही लौटेगा, जिसे PHP फ्लोट के लिए डालेगा!

— jgmjgm

Answer 21

आप निम्न स्थिति का उपयोग कर सकते हैं। ध्यान दें कि आपको उपयोग नहीं करना चाहिए! ==

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

Answer 22

यह पूरी तरह से काम करता है! आशा है कि यह आपके लिए उपयोगी होगा =)

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

Comments

एक पुराने प्रश्न का उत्तर देते समय, आपका उत्तर अन्य StackOverflow उपयोगकर्ताओं के लिए अधिक उपयोगी होगा यदि आपने यह समझाने के लिए कुछ संदर्भ शामिल किए कि आपका उत्तर कैसे मदद करता है, विशेष रूप से उस प्रश्न के लिए जो पहले से ही स्वीकृत उत्तर है। देखें: कैसे मैं एक अच्छा जवाब लिख सकता हूं ।

— डेविड बक

Answer 23

यदि आप वास्तव में जानना चाहते हैं कि क्या एक स्ट्रिंग एक सच्चे PHP पूर्णांक प्रकार का एक वैध प्रतिनिधित्व है ...

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

हालांकि यह चलाना असंभव है क्योंकि सेट बहुत बड़ा है (इस मामले में मेमोरी में फिट नहीं होगा, यदि आप इसके बजाय लूप करते हैं तो यह बहुत अधिक सीपीयू चक्र लेगा)।

आप शायद स्ट्रिंग तुलना के साथ एक द्विआधारी खोज कर सकते हैं, हालांकि बेहतर तरीके हैं।

सबसे सरल:

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 जैसी चीजों को करने से पहले सीपीयू को बर्बाद न करें) और नकारात्मक संख्याओं के लिए कुछ अजीब हैंडलिंग करें।

ध्यान दें कि filter_var सही ढंग से यह दावा नहीं करता है कि एक स्ट्रिंग वास्तव में एक PHP पूर्णांक का प्रतिनिधित्व है। यह एक प्रमुख + और आसपास के व्हाट्सएप की अनुमति देगा।

आंतरिक रूप से PHP सख्त तुलना के लिए फ़ंक्शन "_zend_handle_numeric_str" का उपयोग करता है, लेकिन यह सीधे कहीं भी उजागर नहीं करता है, इसलिए सरणी कुंजियों का उपयोग करने वाली चाल (जो किसी भी स्ट्रिंग को परिवर्तित करने के लिए इसका उपयोग करता है जो PHP पूर्णांक के लिए PHP पूर्णांक का प्रतिनिधित्व करता है)।

यदि आप PHP से बाइनरी सुरक्षित रूपांतरण चाहते हैं और इसे लेने के लिए दृष्टिकोण है।

हर कोई ऐसा नहीं चाहता है और यह उपयोगकर्ता इनपुट को संभालने का मामला हो सकता है। फ़िल्टर_वर उसके लिए बहुत बुरा नहीं है और PHP के लिए नए लोगों के लिए ज्यादातर मामलों में काफी सुरक्षित होगा।

एक लंबाई की जाँच, ctype_digit और फिर परिवर्तित मान का एक चेक जो कि एक सीमा में है, उपयोगकर्ता इनपुट के लिए भी काफी ठोस है। अधिक जटिल योजनाएँ ट्रिम या रेगेक्स चाहती हैं।

उस संबंध में यहां बहुत सारे जवाबों के साथ समस्या यह है कि जब सवाल अस्पष्ट है, तो उत्तर नहीं होने चाहिए। यदि आप एक समाधान का प्रस्ताव करने जा रहे हैं, तो आपको यह स्पष्ट रूप से समझाने में सक्षम होना चाहिए कि यह क्या होगा और क्या उम्मीद नहीं करेगा। इसके बिना अगर कोई उत्तर किसी प्रश्न से मेल खाता है या सुरक्षित है तो कोई बता नहीं सकता। PHP मैनुअल हमेशा मदद नहीं करता है क्योंकि यह उन सभी प्रासंगिक तरीकों की व्याख्या नहीं करता है जो इसकी आपूर्ति करता है। Ctype_digit और is_int जैसी चीजें बहुत ही विश्वसनीय और भविष्यवाणी करने में आसान हैं, लेकिन is_numeric, filter_var और बाजीगरी (+ $ var) या कास्टिंग (intval / floatval) की बारीकियों को खराब दस्तावेज़ हैं।

यह आप के लिए PHP ठगना है। इसमें विसंगतियों के साथ पूर्णांक के रूप में तारों की व्याख्या करने के लिए स्कीमाओं की असंख्य संख्या है। पूर्णांक स्ट्रिंग को मान्य करने का सबसे सख्त तरीका सीधे उपयोगकर्ता के सामने नहीं आता है।

Answer 24

यदि आप mysql से सांख्यिक आईडी को संभाल रहे हैं और इसके लिए एक वैध गैर शून्य इंट या एक intलेकिन स्ट्रिंग प्रारूप में mysql ( जैसा कि mysql हमेशा स्ट्रिंग प्रारूप में सब कुछ लौटाता है ) होने के लिए एक सत्यापन लगाने की कोशिश कर रहा है और नहीं NULL। आप निम्नलिखित का उपयोग कर सकते हैं। यह केवल int/string-intsमुझे अनुमति देने के लिए सबसे अधिक त्रुटि / चेतावनी / नोटिस प्रूफ तरीका है ।

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

Answer 25

यहाँ एक सरल समाधान है जो 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 से अधिक मूल्य गलत हो सकते हैं।

Answer 26

या तो is_numeric () का उपयोग कर सकते हैं "की उपस्थिति के लिए जाँच करें।" स्ट्रिंग में (हालांकि विशेष रूप से संस्कृति के प्रति संवेदनशील नहीं)।

वैकल्पिक रूप से is_numeric () का उपयोग करें और फिर एक डबल पर जाएं और देखें कि $ var == फ्लोर ($ var) (यह पूर्णांक होने पर वापस लौटना चाहिए)।

Comments

यह एकमात्र उत्तर है जो स्थानीय परिवर्तनों को पहचानता है, यह भी बदलता है कि PHP कैसे व्याख्या करता है और संख्याओं को आउटपुट करता है। सेटलोकाले और समाधान के साथ बहुत सावधान रहें जो विभाजक के बारे में धारणा बनाते हैं।

— jgmjgm