मैं कैसे जांचूं कि कोई नंबर फ्लोट या पूर्णांक है?

Question

कैसे पता करें कि एक संख्या है floatया integer?

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float

Comments

मैं समझता हूं कि आप यहां क्या पूछ रहे हैं, लेकिन बस स्पष्ट होना चाहिए: <nit-pick>जावास्क्रिप्ट में अलग-अलग पूर्णांक और फ्लोट न्यूमेरिक प्रकार नहीं हैं। जावास्क्रिप्ट में हर संख्या सिर्फ एक है Number। </nit-pick>

— मैट बॉल

है Infinityएक पूर्णांक या एक गैर पूर्णांक मान के रूप में दूर के रूप में आप चिंतित हैं? इस स्कोर पर यहाँ उत्तर बहुत समान रूप से वितरित किए गए हैं।

— माइक शमूएल

@MikeSamuel गणितीय रूप से सटीक होना: चूंकि अनंत एक वास्तविक संख्या नहीं है और सभी पूर्णांक वास्तविक संख्या हैं, इसलिए Infinityपूर्णांक नहीं माना जा सकता है।

— rvighne

@rvighne, सवाल "फ्लोट" के बारे में पूछता है, "वास्तविक" नहीं। किसी भी तरह से, वास्तविक अप्रासंगिक हैं क्योंकि कंप्यूटर केवल कम्प्यूटेबल संख्याओं का प्रतिनिधित्व कर सकते हैं ।

— माइक सेमुअल

@rvighne, मुझे लगता है कि हम सहमत हैं कि तथ्य यह है कि शिशुओं और NaN वास्तविक संख्या नहीं हैं इसका मतलब है कि IEEE-754 फ़्लोट वास्तविक संख्याओं का सबसेट नहीं हैं। IEEE-754 पर आधारित सभी संख्यात्मक विश्लेषण को इस तथ्य से निपटना होगा। मुझे समझ में नहीं आता है कि आप कैसे सोचते हैं कि यह तथ्य निर्धारित करता है कि is_integral को wrt cardinalities का व्यवहार कैसे करना चाहिए। व्यक्तिगत रूप से, मुझे लगता है ((x% 1) == 0) एक अच्छा प्रॉक्सी है और IEEE-754 द्वारा पूरी तरह से निर्दिष्ट है, इसलिए विभिन्न संख्या लाइनों के बीच पत्राचार के बारे में बहस करने की कोई आवश्यकता नहीं है।

— माइक सैमुअल

Answer 1

1 से भाग देने पर शेषफल की जाँच करें:

function isInt(n) {
   return n % 1 === 0;
}

यदि आप नहीं जानते कि तर्क एक संख्या है जिसे आपको दो परीक्षणों की आवश्यकता है:

function isInt(n){
    return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
    return Number(n) === n && n % 1 !== 0;
}

अपडेट 2019 5 साल बाद यह उत्तर लिखा गया था, ईसीएमए स्क्रिप्ट 2015 में एक समाधान मानकीकृत किया गया था। यह समाधान इस उत्तर में शामिल है ।

Comments

सावधान रहें, इस भी सच कोई रिक्त स्ट्रिंग के लिए, वापस आ जाएगी एक स्ट्रिंग एक अभिन्न संख्या का प्रतिनिधित्व करने true, false, null, एक खाली सरणी, एक सरणी एक भी अभिन्न संख्या, एक सरणी एक स्ट्रिंग एक अभिन्न संख्या का प्रतिनिधित्व करने वाले, और शायद अधिक हैं।

— डग नबबिट

अच्छी चाल लेकिन सही उत्तर नहीं है क्योंकि यह खाली स्ट्रिंग ""और 1.0 isInt("");&& isInt(1.0);दोनों की जांच करने में विफल रहता है, trueइस डेमो को देखें jsbin.com/elohuq/1/edit

— Champ

इना में, === का उपयोग सामान्य रूप से == को प्रोत्साहित किया जाता है, क्योंकि यह अधिक प्रकार की सुरक्षा और अधिक अनुमानित, समान व्यवहार की ओर जाता है। जैसा कि पिछले उत्तरदाताओं ने कहा है, यह उत्तर बिल्कुल गलत है, 100% गलत है। मान शून्य, खाली स्ट्रिंग, 1.0 और कई अन्य सभी पूर्णांक के रूप में गलत तरीके से पंजीकृत होंगे (यहां तक ​​कि === चेक के साथ)।

— whoblitz

प्रश्न यह था कि यदि कोई संख्या पूर्णांक है तो जांच कैसे की जाए, न कि किसी मान की जाँच कैसे की जाए।

— kennebec

यह कैसे स्ट्रिंग को मान्य नहीं करता है, इसके बारे में बहुत सारे शत्रुतापूर्ण टिप्पणी। यह ओपी के सवाल का हिस्सा नहीं है। यदि मैं किसी सरणी के अंतिम तत्व को पुनः प्राप्त करने के बारे में एक सवाल पूछने के लिए SO पर जाता हूं और कोई व्यक्ति उत्तर देता है function last (array) { return array[array.length - 1]; }, तो क्या यह "गलत है" या "SO पर सबसे खराब उत्तर" क्योंकि यह जांच नहीं करता है कि क्या तर्क पहले एक सरणी है? हां, तर्कों की जांच करने के लिए अच्छा अभ्यास, लेकिन यह डेवलपर जिम्मेदारी है। एसओ के उत्तर संक्षिप्त होने चाहिए और सीधे प्रश्न का उत्तर यथासंभव स्पष्ट रूप से देना चाहिए।

— एम मिलर

Answer 2

यह जाँचने के लिए इन कार्यों को आज़माएँ कि क्या कोई मान एक ऐसा आदिम मान है जिसका कोई भिन्नात्मक भाग नहीं है और जो सटीक पूर्णांक के रूप में दर्शाया जा सकता है, उसके आकार सीमा के भीतर है।

function isFloat(n) {
    return n === +n && n !== (n|0);
}

function isInteger(n) {
    return n === +n && n === (n|0);
}

Comments

हे, अरे शोषण, यह बहुत ज्यादा मेरा है ( n===+nसंख्यात्मक के लिए जांच करने के लिए, n|0गोल करने के लिए), लेकिन अंतर्निहित ऑपरेटरों के साथ। अजीब

— Claudiu

@ जॉन हार्टसॉक एक स्ट्रिंग कभी भी संख्यात्मक मान नहीं होने वाला है। यह एक तार है। इस फ़ंक्शन का बिंदु यह परीक्षण करना है कि क्या एक जावास्क्रिप्ट संख्यात्मक मान है जिसका कोई अंश नहीं है और एक सटीक पूर्णांक के रूप में प्रतिनिधित्व किया जा सकता है। यदि आप यह देखने के लिए एक स्ट्रिंग की जाँच करना चाहते हैं कि इसमें वर्णों का क्रम है जो किसी संख्या का प्रतिनिधित्व करता है, तो आप parseFloat()पहले कॉल करेंगे ।

— नुकीले

@ जॉन हार्टसॉक: यह तब तक सही नहीं होगा जब तक कि एक नंबर आदिम पारित नहीं किया गया था। मुझे लगता है कि यह समझ में आता है कि कार्यों के नाम दिए गए हैं। ऐसे कार्यों को लिखा जा रहा है, तो कुछ भी isString, isBoolean, आदि के लिए एक उम्मीदवार होना चाहिए।

— डग नबबिट

@ संकेत: डबल सटीक फ़्लोट्स पूर्णांक मानों का प्रतिनिधित्व कर सकते हैं, 2 ^ 53 तक। तो यह निर्भर करता है कि ओपी मैथ्स सेंस (पूर्ण संख्या) या 32-बिट डेटा सेंस में पूर्णांक के बारे में पूछ रहा था या नहीं। यदि यह बाद की बात है, तो आपका समाधान एकदम सही है।

— djd

जावास्क्रिप्ट में, बिटवाइन ऑपरेटर जैसे |(OR) केवल हस्ताक्षरित 32-बिट पूर्णांक पर काम करते हैं। ओपी यह नहीं बताता है कि क्या लक्ष्य पर हस्ताक्षर किए गए इंट 32 मूल्यों की जांच करना है। तो यह सीमा संख्या से बाहर काम नहीं करेगा। isInteger(5000000000)वापस आ जाएगा falseजो गलत है!

— ओनूर येल्ड्रिअम

Answer 3

ऐसा कुछ क्यों नहीं है:

var isInt = function(n) { return parseInt(n) === n };

Comments

यह वास्तव में मेरे लिए एक अच्छे समाधान का मूल है। मुझे सकारात्मक पूर्णांक और फ्लोट, स्ट्रिंग्स और नकारात्मक पूर्णांक को हटाने की अनुमति देने की आवश्यकता थी।

— इमरान-यूके

यह इस धागे में दूसरों की तुलना में काफी बेहतर समाधान की तरह लगता है। क्या समुदाय कुछ आलोचना कर सकता है, शायद?

— sbichenko 18

var y = 1.00; y === parseInt (y, 10); // यह मेरे लिए सच है, जो वास्तव में हम क्या चाहते हैं नहीं है।

— whoughton

केवल "नकारात्मक पक्ष" मैं देख रहा हूं कि दी गई संख्या nएक स्ट्रिंग से बदल जाती है parseInt। MDN देखें । लेकिन मैं इस समाधान का उपयोग करूंगा। :)

— राइनोवेवेल

@ekussberg: वह झूठ क्यों लौटना चाहिए? 1 एक इंट है। और 02, दूसरा तर्क, नजरअंदाज कर दिया गया है।

— २zy

Answer 4

एक विधि है जिसे Number.isInteger()वर्तमान में हर चीज में लागू किया जाता है लेकिन IE। MDN अन्य ब्राउज़रों के लिए एक पॉलीफ़िल भी प्रदान करता है:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

हालाँकि, अधिकांश उपयोग के मामलों के लिए, आप बेहतर उपयोग कर रहे हैं Number.isSafeInteger जो यह भी जांचता है कि क्या मूल्य इतना अधिक / कम है कि किसी भी दशमलव स्थानों को वैसे भी खो दिया गया होगा। MDN इस के लिए एक polyfil भी है। (आपको isIntegerऊपर पोलीफिल की भी आवश्यकता है।)

if (!Number.MAX_SAFE_INTEGER) {
    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};

Comments

यह अब मेरे क्रोम में भी काम करता है और शायद भविष्य में जाने का रास्ता

— ड्यूकिटकोडिंग

मेरी राय में सबसे अच्छा समाधान।

— ऑटोमैटिक

पॉलीफिल के साथ यह सबसे विश्वसनीय और सरल समाधान है।

— फ्रांसेस्को पासा

@SergeyPanfilov 12.0 ∈ ℤ।

— Константин Ван

यदि इस उत्तर को प्रदान किए जाने के बाद से कल्पना बदल गई है, तो मैं अनजान हूं, लेकिन ध्यान दें कि उपरोक्त फ़ंक्शन सही पॉलीफ़िल नहीं है Number.isInteger। हालांकि, यह एक सही पॉलीफिल है Number.isSafeInteger। Number.isIntegerयह जांचना चाहिए कि संख्या "सुरक्षित पूर्णांक" है या नहीं। MDN पर देखें: isteteger और isSafeInteger ।

— nunocastromartins

Answer 5

आप एक साधारण नियमित अभिव्यक्ति का उपयोग कर सकते हैं:

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

या आप अपनी आवश्यकताओं के अनुसार, नीचे के कार्यों का भी उपयोग कर सकते हैं। वे PHPJS प्रोजेक्ट द्वारा विकसित किए गए हैं ।

is_int() => जाँचें कि क्या चर प्रकार पूर्णांक है और यदि इसकी सामग्री पूर्णांक है

is_float() => जांचें कि क्या चर प्रकार फ्लोट है और यदि इसकी सामग्री फ्लोट है

ctype_digit() => जांचें कि क्या चर प्रकार स्ट्रिंग है और यदि इसकी सामग्री में केवल दशमलव अंक हैं

अपडेट १

अब यह नकारात्मक संख्याओं की भी जाँच करता है, @ChrisBartley टिप्पणी के लिए धन्यवाद !

Comments

सरल अहस्ताक्षरित पूर्णांक का परीक्षण करने के लिए बिल्कुल सही।

— टोटामारियो

वन लाइनर:/^[0-9]+$/.test(String(value))

— टोटेमेरियो

छोटा और थोड़ा कम पठनीय वन-लाइनर:/^[0-9]+$/.test(''+value)

— skeggse

नकारात्मक पूर्णांक नहीं संभालता है। परीक्षण के बाद से आपको टर्नरी ऑपरेटर की आवश्यकता नहीं है () एक बूलियन देता है। यह इसे करना चाहिए:return /^-?\d+$/.test(String(value));

— क्रिस बार्टले

@ क्रिसब्रेटली, धन्यवाद! मैंने आपके क्रेडिट सहित एक अपडेट किया। कृपया जांचें कि क्या सब कुछ ठीक है।

— मार्सियो मेज़ुकाटो

Answer 6

यहां कुशल कार्य हैं जो यह जांचते हैं कि मान एक संख्या है या सुरक्षित रूप से एक संख्या में परिवर्तित किया जा सकता है :

function isNumber(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    if (typeof value == 'number') {
        return true;
    }
    return !isNaN(value - 0);
}

और पूर्णांकों के लिए (यदि मान फ़्लोट है तो गलत लौटेगा):

function isInteger(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    return value % 1 == 0;
}

यहाँ दक्षता यह है कि जब मूल्य पहले से ही एक संख्या है तो parseInt (या parseNumber) से बचा जाता है। दोनों पार्सिंग फ़ंक्शन हमेशा स्ट्रिंग में परिवर्तित होते हैं और फिर उस स्ट्रिंग को पार्स करने का प्रयास करते हैं, जो कि बेकार होगा यदि मूल्य पहले से ही एक संख्या है।

अनुकूलन के लिए और विचार प्रदान करने के लिए यहां अन्य पदों के लिए धन्यवाद!

Comments

यह फ़ंक्शन रिक्त स्ट्रिंग पर विफल रहता है: isNumber ('') सत्य है।

— जेसन ग्राउट

Answer 7

function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }

// give it a spin

isInteger(1.0);        // true
isFloat(1.0);          // false
isFloat(1.2);          // true
isInteger(1.2);        // false
isFloat(1);            // false
isInteger(1);          // true    
isFloat(2e+2);         // false
isInteger(2e+2);       // true
isFloat('1');          // false
isInteger('1');        // false
isFloat(NaN);          // false
isInteger(NaN);        // false
isFloat(null);         // false
isInteger(null);       // false
isFloat(undefined);    // false
isInteger(undefined);  // false

Comments

जाहिर है, कि .0 के साथ समाप्त होने वाली नाव स्वचालित रूप से Int में जावास्क्रिप्ट में डाली जाती है।

के साथ विफल रहा 1.2। हमेशा 0.1 0.2 0.3 के साथ संख्यात्मक कार्यों का परीक्षण करें

— लुकास एलिस

@LukasLiesis मेरे लिए नहीं।

— डबलऑर्ट

यहां किसी भी सख्त समानता ऑपरेटरों की आवश्यकता नहीं है।

— डबलऑर्ट

isFloat (1563457121531) झूठा लौटाता है

— Aalex Gabi

Answer 8

function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

सभी मामलों के लिए काम करता है।

Comments

+1 यह अच्छा है। उम्मीद के isInt('1')मुताबिक रिटर्न true(कम से कम मेरे लिए)। हालांकि, पर्याप्त है, हालांकि यह भी लौटता trueहै isInt([5])। मेरे लिए कोई बात नहीं थी, लेकिन आपके लिए हो सकता है, इसलिए, ध्यान रखें।

— एकड्यूजनिओर

isFloat (12.0) गलत है

— django

Answer 9

जैसा कि दूसरों ने उल्लेख किया है, आपके पास जेएस में केवल युगल हैं। तो आप किसी संख्या को पूर्णांक कैसे परिभाषित करते हैं? बस जांचें कि क्या गोल संख्या स्वयं के बराबर है:

function isInteger(f) {
    return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }

Comments

यह जाँचना चाहते हैं कि मान संख्यात्मक है ... isFloat('abc')रिटर्नtrue

— डग नबबिट

isFloat(NaN) // true

— शिम

@ शिम: अच्छा कैच। NaN तकनीकी रूप से एक फ्लोटिंग पॉइंट नंबर है, हालांकि ... यह निर्भर करता है कि मैं क्या उपयोग कर रहा हूं।

— क्लाउडिया

Answer 10

इसके बारे में क्या खयाल है?

isFloat(num) {
    return typeof num === "number" && !Number.isInteger(num);
}

Comments

प्रयास करें console.log(isFloat(1.0));परिणाम झूठे।

— फेबियन पॉनिकॉन

Answer 11

यहाँ मैं पूर्णांक के लिए क्या उपयोग कर रहा हूँ:

Math.ceil(parseFloat(val)) === val

लघु, अच्छा :) हर समय काम करता है। डेविड फ्लानगन ने सुझाव दिया है कि अगर मैं गलत नहीं हूं।

Comments

मुझे यह पसंद है क्योंकि यह एक छोटा, सरल उत्तर है जो क्रिप्टिक बिटवाइज़ ऑपरेशंस पर निर्भर नहीं करता है।

— जिम

क्यों parseFloat?

— डबलऑर्ट

Answer 12

यह वास्तव में इस बात पर निर्भर करता है कि आप क्या हासिल करना चाहते हैं। यदि आप दृढ़ता से टाइप की गई भाषाओं का "अनुकरण" करना चाहते हैं तो मेरा सुझाव है कि आप कोशिश न करें। जैसा कि अन्य ने उल्लेख किया है कि सभी संख्याओं में समान प्रतिनिधित्व (समान प्रकार) है।

क्लाउडीयू जैसी किसी चीज़ का उपयोग करना :

isInteger( 1.0 ) -> सच है

जो सामान्य ज्ञान के लिए ठीक है, लेकिन सी जैसी किसी चीज़ में आपको मिलेगा false

Answer 13

शून्य दशमलव भाग (जैसे 1.0, 12.00, 0.0) के साथ कोई भी फ्लोट नंबर को पूरी तरह से इंटेगर में डाला जाता है, इसलिए यह जांचना संभव नहीं है कि वे फ्लोट हैं या नहीं।

Answer 14

!!(24%1) // false
!!(24.2%1) // true

Comments

!!(24.0%1)असत्य है

— रोहमर

Answer 15

यह वास्तव में इतना जटिल होना जरूरी नहीं है। पूर्णांक के parseFloat () और parseInt () समकक्षों का संख्यात्मक मान समान होगा। इस प्रकार आप ऐसा कर सकते हैं:

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

फिर

if (isInt(x)) // do work

यह स्ट्रिंग जांच के लिए भी अनुमति देगा और इस प्रकार सख्त नहीं है। यदि एक मजबूत प्रकार का समाधान चाहते हैं (उर्फ, तार के साथ काम नहीं):

function is_int(value){ return !isNaN(parseInt(value * 1) }

Comments

isteger (12.0) सच है

— django

Answer 16

var isInt = function (n) { return n === (n | 0); };

ऐसा मामला नहीं था जहां यह काम नहीं किया।

Comments

हे क्षमा करें कि यह गलत क्यों है? console.log (isInt (7932938942839482938));

— itsme

क्योंकि यह मैक्सिन्ट से अधिक है।

— अकर

लेकिन आप एक अधिकतम अधिकतम लंबाई सेट कर सकते हैं? क्या होगा अगर मुझे इंट की लंबाई वापस आ गई है?

— me

@ekussberg हाँ क्योंकि 2पूर्णांक है और 23इसे फ़ंक्शन का दूसरा तर्क माना जाता है। जावास्क्रिप्ट में दशमलव को विभाजक के रूप में उपयोग करके लिखा जाता है - इसलिए यह होना चाहिए 2.23।

— अकर

या यह बिटवाइज़ ऑपरेशंस के बारे में जानने का बढ़िया मौका है। आगे बढ़ने से आपको बहुत लाभ होगा।

— एकर

Answer 17

यह चैक बॉथ इंट और फ़्लोट के लिए अंतिम कोड है

function isInt(n) { 
   if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
       return true;
   } else {
       return false;
   }
} 

या

function isInt(n) {   
   return typeof n == 'number' && Math.Round(n) % 1 == 0;   
}   

Comments

यह केवल फ्लोट के लिए परीक्षण करता है यदि n एक संख्या होती है

— हैकलिक्क्रैक

Answer 18

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

function isFloat(n) {
   return ((typeof n==='number')&&(n%1!==0));
}

function isNumber(n) {
   return (typeof n==='number');
}

Comments

पूर्णांक एक फ्लोट नहीं है? मुझे खबर है।

— मार्टन बोडेवेस

Answer 19

यह सरल है:

if( n === parseInt(n) ) ...

कंसोल में यह प्रयास करें:

x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously

// BUT!

x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!

यह बहुत से लोगों को भ्रमित करता है। जब भी कुछ होता है, तो यह अब फ्लोट नहीं है। यह एक पूर्णांक है। या आप इसे केवल "एक संख्यात्मक बात" कह सकते हैं, क्योंकि सी। गुड पुराने समय में वापस जैसा कोई सख्त अंतर नहीं है।

तो मूल रूप से, आप जो कुछ भी कर सकते हैं वह पूर्णांक को इस तथ्य को स्वीकार करने के लिए जांचना है कि 1.000 पूर्णांक है।

रोचक पक्ष नोट

बड़ी संख्या के बारे में एक टिप्पणी थी। विशाल संख्या का मतलब इस दृष्टिकोण के लिए कोई समस्या नहीं है; जब भी parseInt संख्या को संभालने में असमर्थ होता है (क्योंकि यह बहुत बड़ा है) यह वास्तविक मूल्य की तुलना में कुछ और लौटाएगा ताकि परीक्षण FALSE वापस आ जाए। यह एक अच्छी बात है क्योंकि यदि आप किसी "संख्या" पर विचार करते हैं, तो आप सामान्य रूप से उम्मीद करते हैं कि जेएस इसके साथ गणना करने में सक्षम होगा - इसलिए हां, संख्या सीमित हैं और पार्सइंट इसे इस तरह से ध्यान में रखेगा ।

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

<script>

var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";
alert(aIsInteger+"; "+bIsInteger);

</script>

मेरे ब्राउज़र (IE8) में यह "एक ठीक है; बी विफल" है जो कि वास्तव में बी में बड़ी संख्या के कारण है। सीमा भिन्न हो सकती है लेकिन मुझे लगता है कि 20 अंक "किसी के लिए पर्याप्त होना चाहिए", एक शास्त्रीय उद्धरण के लिए :)

Comments

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

— डग नबबिट

म्म्म्म्म्म्म… आपको ऐसा क्यों लगता है? मेरा मतलब है, अगर parseInt कुछ देता है और यह चर के बराबर लगता है, तो आप सुनिश्चित कर सकते हैं कि आपका एन वास्तव में पूर्णांक के रूप में काम करता है। मैंने पाया कि 9999999999999999999 (यानी, 20 गुना "9") एक संख्या है जबकि एक और "9" को जोड़ने से पार्सइंट विफल हो जाता है (1 लौट जाता है)। यह ब्राउज़र-निर्भर हो सकता है; हालाँकि, हाँ, एक सीमा और NO है, जो कुछ भी उस सीमा से दूर है वह ऊपर दिए गए चेक के लिए सही नहीं होगा।

— डकेलर

मेरे कहने का मतलब यह है कि बिटवाइज़ ऑपरेटर्स (जो 32 बिट्स के रूप में संख्याओं का इलाज करते हैं) उन संख्याओं पर अपेक्षित परिणाम नहीं देंगे, जिन्हें 32 बिट इनट्स के रूप में प्रस्तुत नहीं किया जा सकता है, इसलिए उन संख्याओं को इनट्स के रूप में पहचाना नहीं जाना चाहिए। यह प्रस्तावित Number.isIntegerकार्यों के अनुरूप है ।

— डग नबबिट

कुछ एक विशिष्ट तरीके से संग्रहीत किए बिना एक वास्तविक पूर्णांक हो सकता है। मैं आपकी बात देखता हूं लेकिन पूर्णांक पूर्णांक होते हैं क्योंकि उनके पास एक अंश नहीं होता है और इसे फ्लोट जैसे परिणाम प्राप्त किए बिना मनमाने ढंग से जोड़ा / घटाया जा सकता है। यदि आप संख्याओं को बिटफ़िल्ड के रूप में मानते हैं, तो आप कुछ इस बारे में सोच रहे हैं कि वे कैसे संग्रहित हैं - जो मेरी राय में है - व्यावहारिक रूप से काम करने वाला लेकिन 100% विश्वसनीय तरीके से नहीं। यदि आप "एक पूर्णांक एक निश्चित तरीके से संग्रहीत" की तलाश कर रहे हैं, तो, मुझे यकीन नहीं है कि एक एकल-पंक्ति परीक्षण है जिसे आप सभी प्लेटफार्मों पर सुरक्षित रूप से उपयोग कर सकते हैं।

— डेक्लेनर

संख्याएँ जो 32-बिट इनट्स के रूप में व्यक्त की जा सकती हैं, बिटवाइज़ ऑपरेटरों के साथ 100% मज़बूती से काम करती हैं। आप "वे कैसे संग्रहीत किए जाते हैं, इसके बारे में कुछ भी नहीं बोल रहे हैं;" संख्याएँ हस्ताक्षरित 32-बिट बिग-एंडियन दो के पूरक पूर्णांक, प्रति विनिर्देश में परिवर्तित हो जाती हैं। इस प्रारूप में जिन संख्याओं का प्रतिनिधित्व नहीं किया जा सकता है, उन्हें पूर्णांक नहीं माना जाना चाहिए। फिर, यह कैसे Number.isIntegerकाम करता है के अनुरूप है । एक एकल पंक्ति परीक्षण n === (n | 0)एक और उत्तर में दिखाया गया है।

— डग नबबिट

Answer 20

इस समाधान ने मेरे लिए काम किया।

<html>
<body>
  <form method="post" action="#">
    <input type="text" id="number_id"/>
    <input type="submit" value="send"/>
  </form>
  <p id="message"></p>
  <script>
    var flt=document.getElementById("number_id").value;
    if(isNaN(flt)==false && Number.isInteger(flt)==false)
    {
     document.getElementById("message").innerHTML="the number_id is a float ";
    }
   else 
   {
     document.getElementById("message").innerHTML="the number_id is a Integer";
   }
  </script>
</body>
</html>

Answer 21

पूर्णांकों के लिए मैं इसका उपयोग करता हूं

function integer_or_null(value) {
    if ((undefined === value) || (null === value)) {
        return null;
    }
    if(value % 1 != 0) {
        return null;
    }
    return value;
}

Answer 22

जावा स्क्रिप्ट में सभी संख्याएँ internally 64 bit floating pointसमान हैं , जो जावा में दोगुनी हैं। जावास्क्रिप्ट में कोई भिन्न प्रकार नहीं हैं, सभी प्रकार द्वारा दर्शाए गए हैं number। इसलिए आप wil l instanceofचेक नहीं कर पाएंगे । हालाँकि, यह पता लगाने के लिए कि क्या यह एक भिन्नात्मक संख्या है, उपर्युक्त समाधानों का उपयोग कर सकते हैं। जावा स्क्रिप्ट के डिजाइनरों ने एक ही प्रकार के साथ महसूस किया कि वे कई प्रकार की कास्ट त्रुटियों से बच सकते हैं।

Answer 23

कुछ बार नंबर ऑब्जेक्ट आपको डायरेक्ट ऑपरेटर (%) का उपयोग करने की अनुमति नहीं देते हैं, यदि आप उस मामले का सामना कर रहे हैं तो आप इस समाधान का उपयोग कर सकते हैं।

if(object instanceof Number ){
   if( ((Number) object).doubleValue() % 1 == 0 ){
      //your object is an integer
   }
   else{
      //your object is a double
   }
}

Answer 24

यहाँ कुछ उत्तरों की कोशिश करके मैंने इस समाधान को लिखना समाप्त कर दिया। यह एक स्ट्रिंग के अंदर संख्याओं के साथ भी काम करता है।

function isInt(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}

    var tests = {
        'integer' : 1,
        'float' : 1.1,
        'integerInString' : '5',
        'floatInString' : '5.5',
        'negativeInt' : -345,
        'negativeFloat' : -34.98,
        'negativeIntString' : '-45',
        'negativeFloatString' : '-23.09',
        'notValidFalse' : false,
        'notValidTrue' : true,
        'notValidString' : '45lorem',
        'notValidStringFloat' : '4.5lorem',
        'notValidNan' : NaN,
        'notValidObj' : {},
        'notValidArr' : [1,2],
    };

    function isInt(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return !(number - parseInt(number));
    }
    
    function isFloat(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return number - parseInt(number) ? true : false;
    }

    function testFunctions(obj) {
        var keys = Object.keys(obj);
        var values = Object.values(obj);

        values.forEach(function(element, index){
            console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
            console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
        });
    }

    testFunctions(tests);

Answer 25

यह शायद% उत्तर के रूप में प्रदर्शन करने वाला नहीं है, जो आपको पहले एक स्ट्रिंग में बदलने से रोकता है, लेकिन मैंने अभी तक किसी को भी पोस्ट नहीं किया है, इसलिए यहां एक और विकल्प है जो ठीक काम करना चाहिए:

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}

Comments

अच्छा दृष्टिकोण आईएमएचओ

— सर्गेई पैनफिलोव

मैं जोड़ना चाहूंगा कि ES6 विधि में यह शामिल है () इस उत्तर को और भी सरल बनाता है

— Axle

Answer 26

उन उत्सुक लोगों के लिए, बेंचमार्क.जेएस का उपयोग करते हुए मैंने इस पोस्ट पर सबसे अधिक मतदान वाले उत्तर (और आज पोस्ट किए गए) का परीक्षण किया, यहां मेरे परिणाम हैं:

var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
    // kennebec
    .add('0', function() {
        return n % 1 == 0;
    })
    // kennebec
    .add('1', function() {
        return typeof n === 'number' && n % 1 == 0;
    })
    // kennebec
    .add('2', function() {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    })

    // Axle
    .add('3', function() {
        return n.toString().indexOf('.') === -1;
    })

    // Dagg Nabbit
    .add('4', function() {
        return n === +n && n === (n|0);
    })

    // warfares
    .add('5', function() {
        return parseInt(n) === n;
    })

    // Marcio Simao
    .add('6', function() {
        return /^-?[0-9]+$/.test(n.toString());
    })

    // Tal Liron
    .add('7', function() {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    });

// Define logs and Run
suite.on('cycle', function(event) {
    console.log(String(event.target));
}).on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });

---

0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)

Fastest is 7 Tal Liron

Answer 27

यहाँ मेरा कोड है। यह सुनिश्चित करने के लिए जांच करता है कि यह एक खाली स्ट्रिंग नहीं है (जो अन्यथा पास हो जाएगी) और फिर इसे संख्यात्मक प्रारूप में परिवर्तित कर देता है। अब, इस पर निर्भर करते हुए कि आप '1.1' को 1.1 के बराबर चाहते हैं, यह वही हो सकता है जो आप खोज रहे हैं या नहीं।

var isFloat = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseFloat(n));
};
var isInteger = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseInt(n));
};

var isNumeric = function(n){

   if(isInteger(n) || isFloat(n)){
        return true;
   }
   return false;

};

Answer 28

मुझे यह छोटा कार्य पसंद है, जो सकारात्मक और नकारात्मक पूर्णांक दोनों के लिए सच होगा:

function isInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}

यह काम करता है क्योंकि 1 या "1" "1.0" हो जाता है, जो कि NNN () गलत है (जो हम तब नकारात्मक करते हैं और वापस लौटते हैं), लेकिन 1.0 या "1.0" "1.0.0" बन जाता है, जबकि "स्ट्रिंग" "स्ट्रिंग" बन जाता है। 0 ", जिनमें से कोई भी संख्या नहीं है, इसलिए NNN () गलत है (और, फिर से, नकारात्मक हो जाता है) देता है।

यदि आप केवल सकारात्मक पूर्णांक चाहते हैं, तो यह संस्करण है:

function isPositiveInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

या, नकारात्मक पूर्णांक के लिए:

function isNegativeInt(val) {
    return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}

isPositiveInt () परीक्षण किए जाने वाले मान से आगे समवर्ती संख्यात्मक स्ट्रिंग को स्थानांतरित करके काम करता है। उदाहरण के लिए, isPositiveInt (1) परिणाम isNaN () "01" का मूल्यांकन करता है, जो गलत का मूल्यांकन करता है। इस बीच, isPositiveInt (-1) परिणाम isNaN () "0-1" का मूल्यांकन करता है, जो सही मूल्यांकन करता है। हम रिटर्न वैल्यू को नकारते हैं और इससे हमें वह मिलता है जो हम चाहते हैं। isNegativeInt () समान रूप से काम करता है, लेकिन isNaN () के रिटर्न मान की उपेक्षा किए बिना।

संपादित करें:

मेरा मूल कार्यान्वयन सरणियों और खाली तारों पर भी सही लौटेगा। इस कार्यान्वयन डो में वह दोष नहीं है। यदि घाटी एक स्ट्रिंग या संख्या नहीं है, या यदि यह एक खाली स्ट्रिंग है, तो इन मामलों में तेजी से वापस लौटने पर इसका लाभ भी है। आप पहले दो खंडों को बदलकर इसे और संशोधित कर सकते हैं

typeof(val) != "number"

यदि आप केवल शाब्दिक संख्याओं से मेल खाना चाहते हैं (और तार नहीं)

संपादित करें:

मैं अभी तक टिप्पणी पोस्ट नहीं कर सकता, इसलिए मैं इसे अपने उत्तर में जोड़ रहा हूं। @Asok द्वारा पोस्ट किया गया बेंचमार्क बहुत जानकारीपूर्ण है; हालाँकि, सबसे तेज़ फ़ंक्शन आवश्यकताओं के अनुकूल नहीं है, क्योंकि यह फ़्लोट, सरणियों, बूलियन और खाली तारों के लिए TRUE भी लौटाता है।

मैंने प्रत्येक फ़ंक्शन का परीक्षण करने के लिए निम्नलिखित परीक्षण सूट बनाया, सूची में अपना उत्तर जोड़कर, (फ़ंक्शन 8, जो तार तार करता है, और फ़ंक्शन 9, जो नहीं करता है):

funcs = [
    function(n) {
        return n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    },
    function(n) {
        return n.toString().indexOf('.') === -1;
    },
    function(n) {
        return n === +n && n === (n|0);
    },
    function(n) {
        return parseInt(n) === n;
    },
    function(n) {
        return /^-?[0-9]+$/.test(n.toString());
    },
    function(n) {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    },
    function(n) {
        return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
    }
];
vals = [
    [1,true],
    [-1,true],
    [1.1,false],
    [-1.1,false],
    [[],false],
    [{},false],
    [true,false],
    [false,false],
    [null,false],
    ["",false],
    ["a",false],
    ["1",null],
    ["-1",null],
    ["1.1",null],
    ["-1.1",null]
];

for (var i in funcs) {
    var pass = true;
    console.log("Testing function "+i);
    for (var ii in vals) {
        var n = vals[ii][0];
        var ns;
        if (n === null) {
            ns = n+"";
        } else {
            switch (typeof(n)) {
                case "string":
                    ns = "'" + n + "'";
                    break;
                case "object":
                    ns = Object.prototype.toString.call(n);
                    break;
                default:
                    ns = n;
            }
            ns = "("+typeof(n)+") "+ns;
        }

        var x = vals[ii][1];
        var xs;
        if (x === null) {
            xs = "(ANY)";
        } else {
            switch (typeof(x)) {
                case "string":
                    xs = "'" + n + "'";
                    break;
                case "object":
                    xs = Object.prototype.toString.call(x);
                    break;
                default:
                    xs = x;
            }
            xs = "("+typeof(x)+") "+xs;
        }

        var rms;
        try {
            var r = funcs[i](n);
            var rs;
            if (r === null) {
                rs = r+"";
            } else {
                switch (typeof(r)) {
                    case "string":
                        rs = "'" + r + "'";
                        break;
                    case "object":
                        rs = Object.prototype.toString.call(r);
                        break;
                    default:
                        rs = r;
                }
                rs = "("+typeof(r)+") "+rs;
            }

            var m;
            var ms;
            if (x === null) {
                m = true;
                ms = "N/A";
            } else if (typeof(x) == 'object') {
                m = (xs === rs);
                ms = m;
            } else {
                m = (x === r);
                ms = m;
            }
            if (!m) {
                pass = false;
            }
            rms = "Result: "+rs+", Match: "+ms;
        } catch (e) {
            rms = "Test skipped; function threw exception!"
        }

        console.log("    Value: "+ns+", Expect: "+xs+", "+rms);
    }
    console.log(pass ? "PASS!" : "FAIL!");
}

मैं भी # 8 फ़ंक्शन के साथ बेंचमार्क को सूची में जोड़ा गया। मैं परिणाम पोस्ट नहीं करूंगा, क्योंकि वे थोड़े शर्मनाक हैं (जैसे कि फ़ंक्शन तेज़ नहीं है) ...

संक्षिप्त (संक्षिप्त - मैंने सफल परीक्षण हटा दिए हैं, क्योंकि आउटपुट काफी लंबा है) परिणाम निम्नानुसार हैं:

Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!

Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

मैंने विफलताओं में छोड़ दिया है ताकि आप यह देख सकें कि प्रत्येक फ़ंक्शन कहाँ विफल हो रहा है, और (स्ट्रिंग) '#' परीक्षण ताकि आप देख सकें कि प्रत्येक फ़ंक्शन कैसे स्ट्रिंग में पूर्णांक और फ्लोट मानों को संभालता है, क्योंकि कुछ इन संख्याओं और कुछ के रूप में पार्स कर सकते हैं। शायद नहीं।

परीक्षण किए गए 10 कार्यों में से, जो वास्तव में ओपी की आवश्यकताओं को पूरा करते हैं, वे हैं [1,3,5,6,8,9]

Answer 29

अस्थायी मान्यता के लिए कंडिशनिंग:

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

पूर्णांक सत्यापन के लिए संक्षेपण:

if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

आशा है कि यह मददगार हो सकता है।

Answer 30

function int(a) {
  return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
  return a - a === 0 && a.toString(32).indexOf('.') !== -1
}

typeof a === 'number'यदि आप स्ट्रिंग्स को बाहर करना चाहते हैं तो आप जोड़ सकते हैं ।