javascript - ऑपर - हिंदी में जावास्क्रिप्ट परिचय




यह जांचने के लिए कि क्या एक चर जावास्क्रिप्ट में एक पूर्णांक है? (20)

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

<html>
    <head>
        <script type="text/javascript">
            var data = 22;
            alert(NaN(data));
        </script>
    </head>
</html>

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

लेकिन अगर आप सख्ती से पूर्णांक मूल्य चाहते हैं तो संभवतः Number.isInteger(value) को चाल Number.isInteger(value) चाहिए।


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

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

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

function isInt(value) {

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

    return er.test(value);
}

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

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

ईसीएमए -262 6.0 ( Number.isInteger 6) मानक में Number.isInteger फ़ंक्शन शामिल है।

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

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

जो शुद्ध ईएस 6 जेएस पॉलीफिल लाइब्रेरी है

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


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

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

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

if(Math.round(data) != data) {
    alert("Variable is not an integer!");
}

ठीक है शून्य, कारण मेरे उदाहरण का वर्णन नहीं किया, तो अधिक उदाहरण :):

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

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

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

if (data === parseInt(data, 10))
    alert("data is integer")
else
    alert("data is not an integer")

फ़ंक्शन isInteger (x) {वापसी (x ^ 0) === x; } निम्नलिखित समाधान भी काम करेगा, हालांकि एक के रूप में सुरुचिपूर्ण नहीं है

ऊपर:

फ़ंक्शन isInteger (x) {वापसी Math.round (x) === x; } ध्यान दें कि उपरोक्त कार्यान्वयन में Math.ceil () या Math.floor () को समान रूप से अच्छी तरह से उपयोग किया जा सकता है (Math.round () के बजाय)।

या वैकल्पिक रूप से: फ़ंक्शन isInteger (x) {वापसी (टाइप x === 'संख्या') && (x% 1 === 0); }

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

फ़ंक्शन isInteger (x) {वापसी parseInt (x, 10) === x; }

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

स्ट्रिंग (1000000000000000000000) '1e + 21'

parseInt (1000000000000000000000, 10) 1

parseInt (1000000000000000000000, 10) === 1000000000000000000000 झूठा


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

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

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

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

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

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 सामान) को स्वीकार करने के लिए फ़ंक्शन की आवश्यकता होती है, तो आप हमेशा dot condition a.indexOf('.') == -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;

    }

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

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

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/

योलपो यहाँ है: http://www.yolpo.com/embed.html?gist=a3c46f837ea7bbb708ae&autoplay=2

प्रदर्शन

परीक्षण से पता चलता है कि शॉर्ट सर्किटिंग समाधान में सर्वश्रेष्ठ प्रदर्शन (ओप / सेक) है।

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

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

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

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

बेशक, मैं सुझाव देना चाहता हूं कि मिनीफायर उस पर ध्यान दें।


लोडाश https://lodash.com/docs#isInteger (4.0.0 के बाद से) यह जांचने के लिए कार्य करता है कि चर एक पूर्णांक है या नहीं:

_.isInteger(3);
// → true

_.isInteger(Number.MIN_VALUE);
// → false

_.isInteger(Infinity);
// → false

_.isInteger('3');
// → false

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

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

alert(typeof data === 'number' && data%1 == 0);

सबसे सरल और साफ-पूर्व प्री-ईसीएमएस्क्रिप्ट -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; }

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

> String(1000000000000000000000)
'1e+21'

> parseInt(1000000000000000000000, 10)
1

> parseInt(1000000000000000000000, 10) === 1000000000000000000000
false

Number.isInteger() जाने का रास्ता प्रतीत होता है।

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

Number.isInteger()

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

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 और ^ ऑपरेटर अच्छी तरह से काम नहीं करेगा।


function isInteger(argument) { return argument == ~~argument; }

उपयोग:

isInteger(1);     // true<br>
isInteger(0.1);   // false<br>
isInteger("1");   // true<br>
isInteger("0.1"); // false<br>

या:

function isInteger(argument) { return argument == argument + 0 && argument == ~~argument; }

उपयोग:

isInteger(1);     // true<br>
isInteger(0.1);   // false<br>
isInteger("1");   // false<br>
isInteger("0.1"); // false<br>

if(Number.isInteger(Number(data))){
    //-----
}





javascript