जावास्क्रिप्ट में एक चर एक पूर्णांक है तो कैसे जांचें?

405

यदि जावास्क्रिप्ट में एक चर एक पूर्णांक है, तो मैं यह कैसे जांच सकता हूं और यदि यह नहीं है तो अलर्ट फेंक दें? मैंने यह कोशिश की, लेकिन यह काम नहीं करता है:

<html>
    <head>
        <script type="text/javascript">
            var data = 22;
            alert(NaN(data));
        </script>
    </head>
</html>
javascript 
— JBA
स्रोत
2
यहां एक सकारात्मकता का उपयोग करना है parseInt।
— पॉल
2
jsben.ch/#/htLVw - इसे करने के सामान्य तरीकों के लिए एक मानदंड
— एस्केपनेटस्केप
यहाँ सभी उत्तर वास्तव में पुराने हैं। आज, मैं सलाह देता हूं Number.isIntegerकि सबसे कम हैक करने का तरीका है।
— बेंजामिन ग्रुएनबाम
@Benjamim क्या होगा यदि संख्या एक स्ट्रिंग है जिसे एक पूर्णांक में परिवर्तित किया जा सकता है? और HTML में सब कुछ एक स्ट्रिंग है .. इसलिए Number.isInteger ("69") गलत है
— joedotnot

जवाबों:

344

नीचे के रूप में === ऑपरेटर ( सख्त समानता ) का उपयोग करें ,

if (data === parseInt(data, 10))
    alert("data is integer")
else
    alert("data is not an integer")
— pranag
स्रोत
95
यह NaN को पूर्णांक के रूप में गिनता है। मेरी पद्धति के खिलाफ भी बदतर प्रदर्शन करता है। jsperf.com/numbers-and-integers
— Blake Regalia
2
यदि आप उपरोक्त कोड के माध्यम से अपना उदाहरण चलाते हैं, तो यह एक पूर्णांक के रूप में अलर्ट करता है और दूसरा एक पूर्णांक के रूप में नहीं है जो मामला है ... NaN के मामले में भी NaN का प्रकार pareInt के रिटर्न मान के प्रकार से भिन्न होता है () .....
— प्रागं
1
क्या आप थोड़ा विस्तार कर सकते हैं? "उदाहरण" केवल यह प्रदर्शित कर रहा है कि parseInt का उपयोग करने से टाइपोफ कीवर्ड और मापांक ऑपरेटर के उपयोग से बदतर प्रदर्शन होता है। लेकिन मैं देख रहा हूं कि आप अब (NaN! = NaN) के बारे में क्या कहते हैं
— ब्लेक रेगलिया
4
जावास्क्रिप्ट में @connorbode सभी नंबरों को एक ही प्रकार है (कोई नाव या डबल है), इसलिए 2.0 === 2बाद से अनावश्यक दशमलव सिर्फ एक ही नंबर का एक अलग प्रतिनिधित्व है, इस प्रकार parseInt(2.0) === 2.0के बराबर है parseInt(2) === 2जो सच है
— माइकल Theriot
1
@ ब्लेक रीगलिया: हालांकि तेजी से उनकी विधि इस उत्तर से सभी संभावित मूल्यों को पारित नहीं करती है : stackoverflow.com/a/14794066/843732
— c00000fd
506

यह निर्भर करता है, क्या आप भी संभावित पूर्णांकों के रूप में तार डालना चाहते हैं?

इससे चल जाएगा:

function isInt(value) {
  return !isNaN(value) && 
         parseInt(Number(value)) == value && 
         !isNaN(parseInt(value, 10));
}

बिटवाइज ऑपरेशन के साथ

सिंपल पार्स एंड चेक

function isInt(value) {
  var x = parseFloat(value);
  return !isNaN(value) && (x | 0) === x;
}

शॉर्ट-सर्कुलेटिंग, और पार्स ऑपरेशन को सहेजना:

function isInt(value) {
  if (isNaN(value)) {
    return false;
  }
  var x = parseFloat(value);
  return (x | 0) === x;
}

या शायद दोनों एक शॉट में:

function isInt(value) {
  return !isNaN(value) && (function(x) { return (x | 0) === x; })(parseFloat(value))
}

टेस्ट:

isInt(42)        // true
isInt("42")      // true
isInt(4e2)       // true
isInt("4e2")     // true
isInt(" 1 ")     // true
isInt("")        // false
isInt("  ")      // false
isInt(42.1)      // false
isInt("1a")      // false
isInt("4e2a")    // false
isInt(null)      // false
isInt(undefined) // false
isInt(NaN)       // false

यहाँ की बेला है: http://jsfiddle.net/opfyrqwp/28/

प्रदर्शन

परीक्षण से पता चलता है कि शॉर्ट-सर्किटिंग समाधान में सबसे अच्छा प्रदर्शन (ऑप्स / सेकंड) है।

// Short-circuiting, and saving a parse operation
function isInt(value) {
  var x;
  if (isNaN(value)) {
    return false;
  }
  x = parseFloat(value);
  return (x | 0) === x;
}

यहाँ एक बेंचमार्क है: http://jsben.ch/#/htLVw

यदि आप एक छोटे, छोटे सर्कुलेटिंग के मोटे रूप को पसंद करते हैं:

function isInt(value) {
  var x;
  return isNaN(value) ? !1 : (x = parseFloat(value), (0 | x) === x);
}

बेशक, मेरा सुझाव है कि मिनिफ़ायर को ध्यान रखना चाहिए।

— krisk
स्रोत
4
@krisk - कई समाधानों के लिए तैयार किया गया। आपके द्वारा प्रदान किए गए 4 वेरिएंट पर एक त्वरित परीक्षण भी किया: jsperf.com/tfm-is-integer - और यह निर्धारित किया कि शॉर्ट- सर्कुलेटिंग समाधान में सबसे अच्छा प्रदर्शन है।
— tfmontague
1
यह 209999999999999999 पर गलत लौट रहा है: - (
— jkucharovic
1
@jkucharovic बिटवाइज या ऑपरेटर अपराधी है। गैर-बिटवाइज़ संस्करण का उपयोग करना सही वापस आएगा।
— क्रिक
1
यह '2.' बनाता है सच का मूल्यांकन
— साइबरबोनट
1
@cyberwombat अच्छी तरह से है कि एक दशमलव संख्या 2.0 है :-)
— Kuba Beránek
120

यह मानते हुए कि आपको प्रश्न में चर के बारे में कुछ भी नहीं पता है, आपको यह तरीका अपनाना चाहिए:

if(typeof data === 'number') {
    var remainder = (data % 1);
    if(remainder === 0) {
        // yes, it is an integer
    }
    else if(isNaN(remainder)) {
        // no, data is either: NaN, Infinity, or -Infinity
    }
    else {
        // no, it is a float (still a number though)
    }
}
else {
    // no way, it is not even a number
}

अगर सरल शब्द में कहा जाए तो:

if(typeof data==='number' && (data%1)===0) {
    // data is an integer
}
— ब्लेक रेगलिया
स्रोत
8
क्या मतलब? यह जावास्क्रिप्ट में डेटा प्रकारों के लिए जाँच करता है, "1.0"एक स्ट्रिंग है, और इसलिए यह संख्या नहीं है। अन्यथा 1एक चर का मान होगा यदि आप इसे इस प्रकार सेट करते हैं var my_var=1.0;, जो इस फ़ंक्शन द्वारा पूर्णांक के रूप में सही ढंग से पहचाना जाता है।
— ब्लेक रेगलिया
4
जल्द ही, Number.isInteger()काम करेगा ... तब तक, यह करने का एक अच्छा तरीका है
— क्लेयुडू
Number.isInteger मेरे लिए काम नहीं करता है। मुझसे कुछ गलत हो रहा होगा। ब्लेक का समाधान% 1 पूरी तरह से काम करता है।
— mcmacerson
104

Number.isInteger() जाने का रास्ता मालूम पड़ता है।

MDN ने Number.isInteger()मुख्य रूप से IE के सभी संस्करणों का समर्थन नहीं करने वाले ब्राउज़रों के लिए निम्न पॉलीफ़िल प्रदान की है ।

MDN पेज से लिंक करें

Number.isInteger = Number.isInteger || function(value) {
    return typeof value === "number" && 
           isFinite(value) && 
           Math.floor(value) === value;
};
— वाल्टर रोमन
स्रोत
2
एमडीएन में 9007199254740992 हटाए
— बर्नहार्ड
2
यह सबसे सीधा और "सही" उत्तर है। मेरा मतलब है, जावास्क्रिप्ट में पहले से ही पूर्णता की जांच करने की विधि है। नया लिखने की जरूरत नहीं। isNaN () संख्यात्मकता के लिए परीक्षण, पूर्णांक नहीं।
— ग्लोबेवेल्डस्क्यू
66

आप जाँच सकते हैं कि संख्या शेष है:

var data = 22;

if(data % 1 === 0){
   // yes it's an integer.
}

ध्यान रहे, यदि आपका इनपुट टेक्स्ट भी हो सकता है और आप पहले चेक करना चाहते हैं कि यह नहीं है, तो आप पहले टाइप कर सकते हैं:

var data = 22;

if(typeof data === 'number'){
     // yes it is numeric

    if(data % 1 === 0){
       // yes it's an integer.
    }
}
— नहीं
स्रोत
3
@Erwinus: 0 % 1 === 0कंसोल में चलाएँ । यह रिटर्न के trueरूप में 0 % 1मिलता है 0।
— नोप
क्या आपने इसे IE ;-) में
— आज़माया है
1
@Erwinus: IE9, IE8 और IE7 संगतता मोड में 0 % 1लौटता 0है।
— Nope
वास्तविक पुराने IE में इसे आज़माएं। इसके अलावा यह हमेशा शून्य की जांच करने के लिए प्रोग्रामिंग का एक अच्छा तरीका है और ब्राउज़र पर भरोसा नहीं करना है कि क्या करना है।
— कोडबीट
62
@ इरविन: मुझे लगता है कि आपने अपने तथ्यों को मिला दिया है। शून्य त्रुटि द्वारा एक प्रभाग के कारण होता है जब आप को विभाजित है द्वारा शून्य नहीं है जब आप एक संख्या से शून्य विभाजित करते हैं। IE के संस्करण के साथ कुछ भी नहीं करना है।
— नोप
15

सबसे पहले, NaN एक "संख्या" है (हां मुझे पता है कि यह अजीब है, बस इसके साथ रोल करें), और "फ़ंक्शन" नहीं।

यदि चर का प्रकार एक संख्या है, और पूर्णांक के लिए मैं मापांक का उपयोग करूंगा, दोनों की जांच करने की आवश्यकता है।

alert(typeof data === 'number' && data%1 == 0);
— फिल
स्रोत
2
होना चाहिए: चेतावनी (टाइपो डेटा == 'संख्या' और& (डेटा == 0 || डेटा% 1 == 0)); शून्य से विभाजन से बचने के लिए।
— कोडबीट
19
@Erwinus 0% 1 अभी भी 1 से डिवीजन है
— फिल
@Phil, (0 == 0 || 0 % 1 == 0)का मूल्यांकन करेगा true।
— टोमेक्वी 13
ओह, वैसे 0 % 1 == 0भी मूल्यांकन करता है true! %विभाजन नहीं है!
— टॉमक्वी
13

उपयोग करते समय सावधान रहें

संख्या% 1

खाली स्ट्रिंग ('') या बूलियन (सही या गलत) पूर्णांक के रूप में वापस आ जाएगी। आप ऐसा नहीं करना चाह सकते हैं

false % 1 // true
'' % 1 //true

Number.isInteger (डेटा)

Number.isInteger(22); //true
Number.isInteger(22.2); //false
Number.isInteger('22'); //false

ब्राउज़र में फ़ंक्शन का निर्माण। Dosnt पुराने ब्राउज़र को सपोर्ट करता है

विकल्प:

Math.round(num)=== num

हालाँकि, Math.round () खाली स्ट्रिंग और बूलियन के लिए भी विफल होगा

— झंकार महबूब
स्रोत
8

यह जाँचने के लिए कि पोस्टर जैसा पूर्णांक चाहता है:

if (+data===parseInt(data)) {return true} else {return false}

सूचना + डेटा के सामने (स्ट्रिंग को संख्या में परिवर्तित करता है), और सटीक के लिए ===।

यहाँ उदाहरण हैं:

data=10
+data===parseInt(data)
true

data="10"
+data===parseInt(data)
true

data="10.2"
+data===parseInt(data)
false
— user603749
स्रोत
6
यह मेरे मामले के लिए सबसे स्मार्ट समाधान की तरह लगता है (जहां मुझे कोई फर्क नहीं पड़ता अगर यह एक स्ट्रिंग में पूर्णांक है)। हालांकि: क्यों नहीं बस जाओ return (+data===parseInt(data))?
— स्विस मिस्टर
6 
if(Number.isInteger(Number(data))){
    //-----
}
— अतिथि
स्रोत
1
नीचे के रूप में एक ही टिप्पणी: IE और सफारी द्वारा समर्थित नहीं है ।
— क्राइसक्रॉस
@ क्राइसक्रॉस अब IE को छोड़कर हर चीज का समर्थन करता है, जो केवल एक चिंता का विषय है यदि आप विरासत ऑपरेटिंग सिस्टम का समर्थन कर रहे हैं।
— faintsignal
6

सबसे सरल और साफ पूर्व-ईसीएमएस्क्रिप्ट -6 समाधान (जो कि एक स्ट्रिंग या अशक्त जैसे गैर-संख्यात्मक मान फ़ंक्शन में पारित होने पर भी वापस लौटने के लिए पर्याप्त रूप से मजबूत है) निम्नलिखित होगा:

function isInteger(x) { return (x^0) === x; }

निम्नलिखित समाधान भी काम करेगा, हालांकि ऊपर वाले की तरह सुरुचिपूर्ण नहीं:

function isInteger(x) { return Math.round(x) === x; }

ध्यान दें कि उपरोक्त कार्यान्वयन में Math.ceil () या Math.floor () का समान रूप से (Math.round () के बजाय) समान रूप से उपयोग किया जा सकता है।

या वैकल्पिक रूप से:

function isInteger(x) { return (typeof x === 'number') && (x % 1 === 0); }

एक काफी सामान्य गलत समाधान निम्नलिखित है:

function isInteger(x) { return parseInt(x, 10) === x; }

हालांकि यह parseInt- आधारित दृष्टिकोण x के कई मूल्यों के लिए अच्छी तरह से काम करेगा, एक बार x काफी बड़ा हो जाता है, यह ठीक से काम करने में विफल हो जाएगा। समस्या यह है कि पार्सइंट () अंकों को पार्स करने से पहले इसके पहले पैरामीटर को एक स्ट्रिंग में ले जाता है। इसलिए, एक बार संख्या पर्याप्त रूप से बड़ी हो जाने के बाद, इसका स्ट्रिंग प्रतिनिधित्व घातीय रूप में प्रस्तुत किया जाएगा (जैसे, 1e + 21)। तदनुसार, parseInt () तब 1e + 21 पार्स करने की कोशिश करेगा, लेकिन जब यह ई चरित्र तक पहुंच जाएगा और तब पार्सिंग बंद हो जाएगा, इसलिए 1 का मान लौटाएगा। निरीक्षण:

> String(1000000000000000000000)
'1e+21'

> parseInt(1000000000000000000000, 10)
1

> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false
— आर्सेन अलेक्ज़ानियन
स्रोत
6

किसी ने उल्लेख क्यों नहीं किया Number.isInteger()?

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger

मेरे लिए पूरी तरह से काम करता है और NaNशुरुआत में एक नंबर के साथ समस्या हल करता है ।

— रातों
स्रोत
1
ध्यान दें कि यह ES6 है, इसलिए पुराने ब्राउज़र (जैसे IE <= 11) इसका समर्थन नहीं करते हैं। ऊपर दिए गए डॉक्स एक पॉलीफिल प्रदान करते हैं।
— बिशप
किसी ने उल्लेख किया था Number.isInteger(), आपके सामने 3.5 साल: stackoverflow.com/a/27424770/5208540
— एलेक्स स्ट्रैगिज
अगर हम किसी इनपुट से किसी वैल्यू को पकड़ने जा रहे हैं तो चेक करें। Number.isInteger हमेशा गलत तरीके से वापस आएगा क्योंकि इनपुट वैल्यू स्ट्रिंग डेटाटाइप की है
— शिनीगामे
6

ES6 में 2 नए तरीके नंबर ऑब्जेक्ट के लिए जोड़े गए हैं।

यदि संख्या पूर्णांक है, तो इसमें Number.isInteger () विधि सही है।

उदाहरण उपयोग:

Number.isInteger(10);        // returns true
Number.isInteger(10.5);      // returns false
— अरुण जोशला
स्रोत
4

ECMA-262 6.0 (ES6) मानक में Number.isInteger फ़ंक्शन शामिल है।

पुराने ब्राउज़र के लिए समर्थन जोड़ने के लिए मैं अत्यधिक मजबूत और समुदाय समर्थित समाधान का उपयोग करने की सलाह देता हूं:

https://github.com/paulmillr/es6-shim

जो शुद्ध ES6 JS पॉलीफ़िल लाइब्रेरी है ।

ध्यान दें कि इस परिश्रम के लिए es5-shim की आवश्यकता है, बस README.md का पालन करें।

— gavenkoa
स्रोत
4

आप कोशिश कर सकते हैं Number.isInteger(Number(value))कि valueक्या स्ट्रिंग रूप में पूर्णांक हो सकता है जैसे var value = "23"और आप चाहते हैं कि यह मूल्यांकन करना है true। कोशिश करने से बचें Number.isInteger(parseInt(value))क्योंकि यह हमेशा सही मूल्य नहीं लौटाएगा। उदाहरण के लिए यदि var value = "23abc"आप और आप parseIntकार्यान्वयन का उपयोग करते हैं, तो यह अभी भी सच है।

लेकिन अगर आप कड़े पूर्णांक मान चाहते हैं, तो शायद Number.isInteger(value)यह करना चाहिए।

— gbozee
स्रोत
1
ध्यान दें कि यह IE द्वारा समर्थित नहीं है; जैसा कि यहां कहा गया है कि इस
— दफ़ा मुझे अपनी डिफरेंस रुकी हुई
4 
var x = 1.5;
if(!isNaN(x)){
 console.log('Number');
 if(x % 1 == 0){
   console.log('Integer');
 }
}else {
 console.log('not a number');
}
— हेमंत
स्रोत
3
29 उत्तरों के बाद, एक व्यक्ति को आपके उत्तर को बाहर करने के लिए कुछ और स्पष्टीकरण की उम्मीद होगी ...
— ब्रासोफिलो
3

जांचें कि क्या चर एक पूर्णांक के समान उसी चर के बराबर है, जैसे:

if(Math.round(data) != data) {
    alert("Variable is not an integer!");
}
— इलियट बोनेविले
स्रोत
आप बहुत आसानी से लौटने के साथ इस समारोह के मुद्दे को ठीक कर सकते हैं trueके लिए NaN, बस बदलकर !=करने के लिए !==और inverting ifब्लॉक। यह काम करता है क्योंकि NaNजावास्क्रिप्ट में एकमात्र मूल्य है जो स्वयं के बराबर नहीं है। उदाहरण के लिए, नया कोड होना चाहिएif (Math.round(x) === x) { /* x IS an integer! */ }
— mgthomas99
3

, इसके अलावा Number.isInteger()। शायद ES6- निर्दिष्ट का उपयोग करके यहांNumber.isSafeInteger() एक और विकल्प है ।

Number.isSafeInteger(..)पूर्व ES6 ब्राउज़रों में पॉलीफ़िल करने के लिए :

Number.isSafeInteger = Number.isSafeInteger || function(num) {
    return typeof num === "number" && 
           isFinite(num) && 
           Math.floor(num) === num &&
           Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
};
— zangw
स्रोत
3

Number.isInteger() यदि आपका ब्राउज़र इसका समर्थन करता है तो सबसे अच्छा तरीका है, यदि नहीं, तो मुझे लगता है कि जाने के लिए बहुत सारे तरीके हैं:

function isInt1(value){
  return (value^0) === value
}

या:

function isInt2(value){
  return (typeof value === 'number') && (value % 1 === 0); 
}

या:

function isInt3(value){
  return parseInt(value, 10) === value; 
}

या:

function isInt4(value){
  return Math.round(value) === value; 
}

अब हम परिणामों का परीक्षण कर सकते हैं:

var value = 1
isInt1(value)   // return true
isInt2(value)   // return true
isInt3(value)   // return true
isInt4(value)   // return true

var value = 1.1
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = 1000000000000000000
isInt1(value)   // return false
isInt2(value)   // return true
isInt3(value)   // return false
isInt4(value)   // return true

var value = undefined
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

var value = '1' //number as string
isInt1(value)   // return false
isInt2(value)   // return false
isInt3(value)   // return false
isInt4(value)   // return false

तो, ये सभी तरीके काम कर रहे हैं, लेकिन जब संख्या बहुत बड़ी है, तो parseInt और ^ ऑपरेटर अच्छी तरह से काम नहीं करेगा।

— चार्ल्स चू
स्रोत
3

बस यह प्रयास करें:

let number = 5;
if (Number.isInteger(number)) {
    //do something
}
— जान वेबडेव
स्रोत
IE ब्राउज़र के सभी संस्करणों में Number.isInteger () समर्थित नहीं है।
— SKR
2

आप इस फ़ंक्शन का उपयोग कर सकते हैं:

function isInteger(value) {
    return (value == parseInt(value));
}

यदि मान एक पूर्णांक मान वाला स्ट्रिंग है, तो भी यह सही लौटेगा।
तो, परिणाम होंगे:

alert(isInteger(1)); // true
alert(isInteger(1.2)); // false
alert(isInteger("1")); // true
alert(isInteger("1.2")); // false
alert(isInteger("abc")); // false
— ferhrosa
स्रोत
2

मेरा दृष्टिकोण:

a >= 1e+21परीक्षण केवल एक मूल्य के लिए पारित कर सकता है जिसमें एक संख्या और एक बहुत बड़ा होना है। यह अन्य मामलों के लिए सभी मामलों को कवर करेगा, अन्य समाधानों के विपरीत जो इस चर्चा में प्रदान किए गए हैं।

a === (a|0)यदि दिए गए फ़ंक्शन का तर्क बिल्कुल (===) बिटकॉइन-रूपांतरित मूल्य के समान है, तो इसका मतलब है कि तर्क पूर्णांक है।

a|0वापस आ जाएगी 0के किसी भी मूल्य के लिए aकि कोई अंक नहीं है , और यदि aवास्तव में एक संख्या है, यह दशमलव बिंदु के बाद कुछ भी दूर पट्टी जाएगा, ताकि 1.0001बन जाएगा1

function isInteger(a){
    return a >= 1e+21 ? true : a === (a|0)
}

/// tests ///////////////////////////
[
  1,                        // true
  1000000000000000000000,   // true
  4e2,                      // true
  Infinity,                 // true
  1.0,                      // true
  1.0000000000001,          // false
  0.1,                      // false
  "0",                      // false
  "1",                      // false
  "1.1",                    // false
  NaN,                      // false
  [],                       // false
  {},                       // false
  true,                     // false
  false,                    // false
  null,                     // false
  undefined                 // false
].forEach( a => console.log(typeof a, a, isInteger(a)) )
स्निपेट का विस्तार करें

— vsync
स्रोत
1
अच्छा विचार! मुझे यह भी पसंद है कि आपने अपने परीक्षण दिखाए लेकिन दुर्भाग्य से यह "0" के स्ट्रिंग मूल्य पर विचार नहीं करता है।
— जैमर
अरे @vsync, जानबूझकर नहीं। मैंने मूल रूप से अपडाउन किया लेकिन अपनी पिछली टिप्पणी के कारण इसे वापस लौटाने का फैसला किया। मुझे गलती से इसे या कुछ और पर डबल क्लिक करना चाहिए था।
— जैमर
1

आप इसके लिए regexp का उपयोग कर सकते हैं:

function isInteger(n) {
    return (typeof n == 'number' && /^-?\d+$/.test(n+''));
}
— macloving
स्रोत
1

से http://www.toptal.com/javascript/interview-questions :

function isInteger(x) { return (x^0) === x; }

ऐसा करने के लिए यह सबसे अच्छा तरीका है।

— अवराम ट्यूडर
स्रोत
सही क्रियान्वयन नहीं, केवल छोटे पूर्णांक के लिए काम करें, सही कार्यान्वयन के लिए developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… देखें ।
— अरु
1

|ऑपरेटर का उपयोग करें :

(5.3 | 0) === 5.3 // => false
(5.0 | 0) === 5.0 // => true

तो, एक परीक्षण समारोह इस तरह लग सकता है:

var isInteger = function (value) {
  if (typeof value !== 'number') {
    return false;
  }

  if ((value | 0) !== value) {
    return false;
  }

  return true;
};
— गोलो रोडेन
स्रोत
1

यह अंत में एक और परिदृश्य ( 121. ), एक डॉट को हल करेगा

function isInt(value) {
        var ind = value.indexOf(".");
        if (ind > -1) { return false; }

        if (isNaN(value)) {
            return false;
        }

        var x = parseFloat(value);
        return (x | 0) === x;

    }
— मुहम्मद रफीक
स्रोत
1

विभाजकों के बिना सकारात्मक पूर्णांक मानों के लिए:

return ( data !== '' && data === data.replace(/\D/, '') );

परीक्षण 1. यदि रिक्त नहीं है और 2. यदि मान इसके अंक में गैर-अंक चार के प्रतिस्थापन के परिणाम के बराबर है।

— डैनियल
स्रोत
1

ठीक है माइनस हो गया, क्योंकि मेरे उदाहरण का वर्णन नहीं किया गया था, इसलिए अधिक उदाहरण :):

मैं नियमित अभिव्यक्ति और परीक्षण विधि का उपयोग करता हूं:

var isInteger = /^[0-9]\d*$/;

isInteger.test(123); //true
isInteger.test('123'); // true
isInteger.test('sdf'); //false
isInteger.test('123sdf'); //false

// If u want to avoid string value:
typeof testVal !== 'string' && isInteger.test(testValue);
— वासिल गुटनीक
स्रोत
मिल गया शायद माइनस क्योंकि टेस्ट कोई फंक्शन नहीं है।
— imlokesh
@imlokesh आपका क्या मतलब है "एक फ़ंक्शन नहीं है"? oO मैंने लिखा है कि मैं "परीक्षण विधि" का उपयोग करता हूं।
— वासिल गुटनीक
@imlokesh कोई समस्या नहीं है, मैं सिर्फ यू कारण पूछ रहा हूं मैंने इसे उत्पादन में इस्तेमाल किया :) और मुझे लगा कि यू कुछ बग पाया गया :)
— Vasyl Gutnyk
1

आप इसे इस तरह से भी आजमा सकते हैं 

var data = 22;
if (Number.isInteger(data)) {
    console.log("integer");
 }else{
     console.log("not an integer");
 }

या

if (data === parseInt(data, 10)){
    console.log("integer");
}else{
    console.log("not an integer");
}
— अदिजो इमैनुएल आईएमएम
स्रोत
यह के लिए गलत परिणाम का उत्पादन होगा data=22.5;। इसके अलावा दोनों शाखाओं में console.log("not an integer"):: एस
— कॉलिन ब्रीम
0

मुझे यह जांचना था कि क्या एक चर (स्ट्रिंग या संख्या) एक पूर्णांक है और मैंने इस स्थिति का उपयोग किया है:

function isInt(a){
    return !isNaN(a) && parseInt(a) == parseFloat(a);
}

http://jsfiddle.net/e267369d/1/

अन्य जवाबों में से कुछ का एक समान समाधान है ( parseFloatसाथ संयुक्त पर भरोसा करें isNaN), लेकिन मेरा अधिक सीधा और आत्म स्पष्टीकरण होना चाहिए।

संपादित करें: मुझे पता चला कि मेरा तरीका कॉमा (जैसे "1,2") के तार के लिए विफल है, और मुझे यह भी एहसास हुआ कि मेरे विशेष मामले में मैं चाहता हूं कि फ़ंक्शन विफल हो सकता है यदि स्ट्रिंग एक वैध पूर्णांक नहीं है (किसी भी फ्लोट पर विफल होना चाहिए) , यहां तक ​​कि 1.0)। तो यहाँ मेरा कार्य Mk II है:

function isInt(a){
    return !isNaN(a) && parseInt(a) == parseFloat(a) && (typeof a != 'string' || (a.indexOf('.') == -1 && a.indexOf(',') == -1));
}

http://jsfiddle.net/e267369d/3/

बेशक अगर आपको वास्तव में पूर्णांक फ्लोट्स (1.0 सामान) को स्वीकार करने के लिए फ़ंक्शन की आवश्यकता होती है, तो आप हमेशा डॉट की स्थिति को हटा सकते हैं a.indexOf('.') == -1।

— jahu
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.