यह निर्धारित करने के लिए कि जावास्क्रिप्ट में कोई संख्या विषम है या नहीं

Question

क्या कोई भी मुझे यह निर्धारित करने के लिए कुछ कोड का उल्लेख कर सकता है कि जावास्क्रिप्ट में संख्या समान है या विषम?

Comments

developer.mozilla.org/en/JavaScript/Reference/Operators/…

— epascarello

@DavidThomas मैं आंशिक रूप से सहमत हूं, लेकिन मेरे पास दो चेतावनी हैं: 1. अगर मुझे चुनना था, तो मैं इसके बजाय एक शुरुआती प्रोग्रामर को %ऑपरेटर के बारे में जानता था &, और 2. जबकि &सैद्धांतिक रूप से तेज़ है, यह वास्तव में कोई फर्क नहीं पड़ता ।

— कोजीरो

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

— डेविड का कहना है कि मोनिका

@ कोकोजी मुझे यह कहते हुए डरता है कि आपका फिडल काफी बेकार है, क्योंकि अधिकांश कम्प्यूटेशनल समय फ़ंक्शन कॉल द्वारा लिया जाता है। लेकिन कोई भी यह निर्धारित करने के लिए फ़ंक्शन कॉल का उपयोग नहीं करेगा कि कोई संख्या विषम है या यहां तक ​​कि ... मैंने आपके परीक्षण का तीसरा संशोधन किया है, लेकिन मैं अभी अपने फोन पर हूं ...

— MaxArt

परीक्षण

— bummi

Answer 1

नीचे दिए गए कोड का उपयोग करें:

function isOdd(num) { return num % 2;}
console.log("1 is " + isOdd(1));
console.log("2 is " + isOdd(2));
console.log("3 is " + isOdd(3));
console.log("4 is " + isOdd(4));

1 एक विषम संख्या का प्रतिनिधित्व करता है, जबकि 0 एक सम संख्या का प्रतिनिधित्व करता है।

Comments

ध्यान दें कि यह वापस आ जाएगी 0या 1(या NaNआप यह कुछ है कि एक नंबर नहीं है और एक मजबूर नहीं किया जा सकता फ़ीड अगर) है, जो ज्यादातर स्थितियों के लिए ठीक से काम करेगा। लेकिन अगर आप असली trueया false:return (num % 2) == 1;

— टीजे क्राउडर

हाँ NaN के बारे में अच्छा ध्यान दें। लेकिन आमतौर पर, आप चाहते हैं कि जावास्क्रिप्ट सच या गलत हो, यही वजह है कि मैंने इसे वैसे ही लिखा जैसे मैंने किया था।

— Chii

बस स्पष्ट करने के लिए, modulo ऑपरेटर (%) शेष विभाजन देता है। तो 3% 2 3/2 होगा, 1 को शेष के रूप में छोड़कर, इसलिए 3% 2 वापस आ जाएगा 1.

— अबू

आगे टीजे ने क्या कहा, यदि numपूर्णांक नहीं है तो यह एक अंश लौटाएगा । यदि आप तुलना करते हैं तब भी काम करेंगे isOdd(1.5)==true(क्योंकि एक भिन्नात्मक मूल्य इसके बराबर नहीं है true), लेकिन यह बेहतर होगा यदि फ़ंक्शन वापस लौटा trueया falseजैसा कि "ओडीडी" नाम से निहित है।

— nnnnnn

आप return !!(num % 2)बूलियन प्राप्त करने के लिए भी कर सकते हैं

— डंकन

Answer 2

बिटवाइज ANDऑपरेटर का उपयोग करें ।

function oddOrEven(x) {
  return ( x & 1 ) ? "odd" : "even";
}

function checkNumber(argNumber) {
  document.getElementById("result").innerHTML = "Number " + argNumber + " is " + oddOrEven(argNumber);
}
 
checkNumber(17);

<div id="result" style="font-size:150%;text-shadow: 1px 1px 2px #CE5937;" ></div>

यदि आप एक स्ट्रिंग वापसी मूल्य नहीं चाहते हैं, लेकिन एक बूलियन एक, यह प्रयोग करें:

var isOdd = function(x) { return x & 1; };
var isEven  = function(x) { return !( x & 1 ); };

Comments

+1, आप निश्चित रूप से जवाब देते हैं कि मेरी धड़कन है, यह उल्लेख करने के लिए नहीं कि आपके पास एकमात्र उत्तर है जो उपयोग नहीं करता हैX % Y !

— s0d4pop 22

मुझे यकीन नहीं है कि मेरा परीक्षण सही है, लेकिन बिटवाइड और

— Blender

ध्यान दें कि यह उन संख्याओं के लिए "विषम" या "सम" लौटाएगा जो या तो नहीं हैं (उदाहरण के लिए, 3.14)।

— nnnnnn

या: function isEven(n){return !(n & 1);}।

— रॉब

@Gnuey हर संख्या बिट्स की एक श्रृंखला से युक्त है। सभी विषम संख्याओं में कम से कम महत्वपूर्ण (सबसे दाहिना) बिट 1 पर सेट है, सभी सम संख्याओं में। 0. x & 1यदि अंतिम बिट संख्या में सेट किया गया है, तो जांच करें (क्योंकि 1 कम से कम महत्वपूर्ण बिट को छोड़कर सभी बिट्स की संख्या 1 है। ): यदि यह है , तो संख्या विषम है, अन्यथा भी।

— 0x499602D2

Answer 3

आप ऐसा कुछ कर सकते हैं:

function isEven(value){
    if (value%2 == 0)
        return true;
    else
        return false;
}

Comments

ऐसा नहीं लगता कि आप जानते हैं कि एक बूलियन क्या है। if (condition) { answer=true; } else { answer=false; }सिर्फ एक अनावश्यक रूप से वर्डी संस्करण है answer = (bool) condition;। अपने कार्य को कम करें function isEven(value) { return (bool) (value%2 == 0); }और हम सभी खुश रहेंगे।

— AWM

झपकी लेने की आवश्यकता नहीं है, क्योंकि मैं कुछ अलग तरह से कार्यक्रम करता हूं।

— टीएनसी

@ मम - ऐसा लगता है कि आप जावास्क्रिप्ट नहीं जानते हैं। आप बूलियन के साथ नहीं जा सकते (bool)(जो एक त्रुटि देगा) और किसी भी मामले में आपको इसकी आवश्यकता नहीं है: ऑपरेटर बूलियन वापस करने के return value%2 == 0;बाद से काम करेगा ==।

— nnnnnn

वाह, क्या मैंने सचमुच ऐसा लिखा है? हां, यह स्पष्ट रूप से गलत है; की तरह कुछ किया जाना चाहिए answer = !!(condition)। जिस बिंदु को मैं बनाने की कोशिश कर रहा था, निश्चित रूप से यह है कि आप सिर्फ return value%2==0और सिर्फ सशर्त से परेशान होने की जरूरत नहीं है।

— शाम

मुझे यह बहुत अच्छा लगता है: value%2===0

— carlodurso

Answer 4

function isEven(x) { return (x%2)==0; }
function isOdd(x) { return !isEven(x); }

Answer 5

क्या मुझे एक ऐसा सरणी बनाना है, जिसमें बहुत सारी संख्याएँ हों

सं। मापांक (%) का प्रयोग करें। यह आपको उन दो नंबरों की शेष राशि देता है जिन्हें आप विभाजित कर रहे हैं।

Ex. 2 % 2 = 0 because 2/2 = 1 with 0 remainder.

Ex2. 3 % 2 = 1 because 3/2 = 1 with 1 remainder.

Ex3. -7 % 2 = -1 because -7/2 = -3 with -1 remainder.

इसका मतलब है कि यदि आप किसी भी संख्या को 2 से मापते हैं, तो आपको 0 या 1 या -1 मिलता है। 0 का मतलब यह भी होगा। कुछ भी मतलब होगा कि यह अजीब है।

Answer 6

इसे कोड के छोटे स्निपेट के साथ हल किया जा सकता है:

function isEven(value) {
    if (value%2 == 0)
    return true;
else
    return false;
}

उम्मीद है की यह मदद करेगा :)

Answer 7

कई भाषाओं की तरह, जावास्क्रिप्ट में एक मापांक ऑपरेटर होता है% , जो शेष विभाजन को पाता है। यदि विभाजन के बाद 2 शेष नहीं है, तो एक संख्या है:

// this expression is true if "number" is even, false otherwise
(number % 2 == 0)

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

Comments

हालांकि, नकारात्मक मूल्यों के लिए मापांक मुश्किल / अपरिभाषित हो सकता है .. उचित भाषा विनिर्देश से परामर्श करना सुनिश्चित करें।

Answer 8

बिटवाइज़ के साथ, कोडगुल्फ़िंग:

var isEven=n=>(n&1)?"odd":"even";

Answer 9

एक साधारण फ़ंक्शन जिसे आप पास कर सकते हैं। मोडुलो ऑपरेटर का उपयोग करता है %:

var is_even = function(x) {
    return !(x % 2); 
}

is_even(3)
false
is_even(6)
true

Comments

यदि टर्नरी ऑपरेटर में आपके परिणाम या तो 'सही' या 'गलत' हैं, तो आपको वास्तव में टर्नेरी ऑपरेटर की आवश्यकता नहीं है। यहाँ, आपको बस करना चाहिए:return !(x % 2);

— dom_watson

Answer 10

मेरे एक्सटेंशन का उपयोग करें:

Number.prototype.isEven=function(){
     return this % 2===0;
};

Number.prototype.isOdd=function(){
     return !this.isEven();
}

फिर

var a=5; 
 a.isEven();

== झूठी

 a.isOdd();

== सच

यदि आप सुनिश्चित नहीं हैं कि यह एक संख्या है, तो निम्नलिखित शाखा द्वारा इसका परीक्षण करें:

if(a.isOdd){
    a.isOdd();
}

अपडेट करें :

यदि आप चर का उपयोग नहीं करेंगे:

(5).isOdd()

प्रदर्शन :

यह पता चला है कि प्रक्रियात्मक प्रतिमान OOP प्रतिमान से बेहतर है। वैसे, मैंने इस FIDDLE में प्रोफाइलिंग की । हालाँकि, OOP तरीका अभी भी दिखावा है।

Comments

धन्यवाद दोस्त, इस तर्क के लिए, इंटरव्यू में किसी ने इस तरह के तर्क पूछे, जवाब नहीं दे सका, अब मुझे मिल गया, धन्यवाद .. लेकिन क्या इस पद्धति का पालन करने से प्रदर्शन में कोई लाभ है? हम लिख सकते थे ईवेन (x); आदि

— शोएब मोहम्मद एक

@ShoibMohammedA: तुलना की जा चुकी है! jsfiddle.net/abdennour/jL2uyksa/3

— अब्देनौर TOUMI

-1 देशी प्रोटोटाइप कार्यों का विस्तार न करें। ( stackoverflow.com/questions/14034180/… )

— tfmontague

Answer 11

जब तक आप -1 या 0 तक नहीं पहुंचते तब तक इसे 2 तक घटाएं (केवल सकारात्मक पूर्णांक के लिए काम करता है) :)

Comments

नकारात्मक संख्या के साथ आप इसके बजाय 2 को

— बढ़ाते हैं

और यह उस समय का नरक है जब n = 2 ^ 52, और n> 2 ^ 53

— rioV8

Answer 12

यदि संख्या या संख्याओं की श्रृंखला विषम है, तो यह निर्धारित करने के लिए आप स्टेटमेंट और एक सशर्त का उपयोग कर सकते हैं:

for (var i=1; i<=5; i++) 
if (i%2 !== 0) {
    console.log(i)
}

यह 1 और 5 के बीच हर विषम संख्या को प्रिंट करेगा।

Answer 13

बस Adobe Dreamweaver में इसे निष्पादित किया गया..यह पूरी तरह से काम करता है। मैंने इस्तेमाल किया अगर (isNaN (mynmb))

यह जांचने के लिए कि दिए गए मान एक संख्या है या नहीं, और मैंने ऋणात्मक संख्या को सकारात्मक और गणना करने के लिए Math.abs (mynmb% 2) का भी उपयोग किया

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>

</head>
<body bgcolor = "#FFFFCC">
    <h3 align ="center"> ODD OR EVEN </h3><table cellspacing = "2" cellpadding = "5" bgcolor="palegreen">
        <form name = formtwo>
            <td align = "center">
                <center><BR />Enter a number: 
                    <input type=text id="enter" name=enter maxlength="10" />
                    <input type=button name = b3 value = "Click Here" onClick = compute() />
                      <b>is<b> 
                <input type=text id="outtxt" name=output size="5" value="" disabled /> </b></b></center><b><b>
                <BR /><BR />
            </b></b></td></form>
        </table>

    <script type='text/javascript'>

        function compute()
        {
          var enter = document.getElementById("enter");
          var outtxt = document.getElementById("outtxt");

          var mynmb = enter.value;
          if (isNaN(mynmb)) 
          { 
            outtxt.value = "error !!!"; 
            alert( 'please enter a valid number');
            enter.focus();
            return;
          }
          else 
          { 
             if ( mynmb%2 == 0 ) { outtxt.value = "Even"; }  
             if ( Math.abs(mynmb%2) == 1 ) { outtxt.value = "Odd"; }
          }
        }

    </script>
</body>
</html>

Answer 14

   <script>
        function even_odd(){
            var num =   document.getElementById('number').value;

            if ( num % 2){
                document.getElementById('result').innerHTML = "Entered Number is Odd";
            }
            else{
                document.getElementById('result').innerHTML = "Entered Number is Even";
            }
        }
    </script>
</head>
<body>
    <center>
        <div id="error"></div>
        <center>
            <h2> Find Given Number is Even or Odd </h2>
            <p>Enter a value</p>
            <input type="text" id="number" />
            <button onclick="even_odd();">Check</button><br />
            <div id="result"><b></b></div>
        </center>
    </center>
</body>

Answer 15

if (X % 2 === 0){
} else {
}

अपने नंबर के साथ एक्स को बदलें (एक चर से आ सकता है)। यदि संख्या विषम है तो स्टेटमेंट चलता है, विषम होने पर।

यदि आप जानना चाहते हैं कि क्या कोई संख्या विषम है:

if (X % 2 !== 0){
}

फिर, X को एक नंबर या वेरिएबल से बदलें।

Answer 16

प्रत्येक विषम संख्या जब दो पत्तियों से विभाजित होती है तो 1 के रूप में शेष होती है और जब शून्य से विभाजित होती है तब भी प्रत्येक संख्या शून्य से शेष रहती है। इसलिए हम इस कोड का उपयोग कर सकते हैं

  function checker(number)  {
   return number%2==0?even:odd;
   }

Answer 17

इस बारे में कैसा है...

    var num = 3 //instead get your value here
    var aa = ["Even", "Odd"];

    alert(aa[num % 2]);

Answer 18

यह जो मैंने किया है

//Array of numbers
var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,32,23,643,67,5876,6345,34,3453];
//Array of even numbers
var evenNumbers = [];
//Array of odd numbers
var oddNumbers = [];

function classifyNumbers(arr){
  //go through the numbers one by one
  for(var i=0; i<=arr.length-1; i++){
     if (arr[i] % 2 == 0 ){
        //Push the number to the evenNumbers array
        evenNumbers.push(arr[i]);
     } else {
        //Push the number to the oddNumbers array
        oddNumbers.push(arr[i]);
     }
  }
}

classifyNumbers(numbers);

console.log('Even numbers: ' + evenNumbers);
console.log('Odd numbers: ' + oddNumbers);

किसी कारण से मुझे यह सुनिश्चित करना पड़ा कि सरणी की लंबाई एक से कम हो। जब मैं ऐसा नहीं करता हूं, तो मुझे विषम तत्वों के अंतिम तत्व में "अपरिभाषित" मिलता है।

Comments

यह इसलिए है क्योंकि हालत सरणी की लंबाई के लिए "<=" से कम या बराबर है। मैंने बराबर चिह्न हटा दिया है और परिणाम वांछित है।

— जाखड़ मासरी

Answer 19

जब आपको परीक्षण करने की आवश्यकता होती है कि क्या कुछ चर विषम है, तो आपको पहले यह परीक्षण करना चाहिए कि क्या यह पूर्णांक है । इसके अलावा, ध्यान दें कि जब आप ऋणात्मक संख्या पर शेष की गणना करते हैं, तो परिणाम नकारात्मक होगा ( -3 % 2 === -1)।

function isOdd(value) {
  return typeof value === "number" && // value should be a number
    isFinite(value) &&                // value should be finite
    Math.floor(value) === value &&    // value should be integer
    value % 2 !== 0;                  // value should not be even
}

यदि Number.isInteger उपलब्ध है, तो आप इस कोड को सरल भी कर सकते हैं:

function isOdd(value) {
  return Number.isInteger(value)      // value should be integer
    value % 2 !== 0;                  // value should not be even
}

नोट: यहाँ, हम परीक्षण value % 2 !== 0के बजाय value % 2 === 1की वजह से है -3 % 2 === -1। यदि आप -1इस परीक्षा को पास नहीं करना चाहते हैं, तो आपको इस लाइन को बदलने की आवश्यकता हो सकती है।

यहाँ कुछ परीक्षण मामले हैं:

isOdd();         // false
isOdd("string"); // false
isOdd(Infinity); // false
isOdd(NaN);      // false
isOdd(0);        // false
isOdd(1.1);      // false
isOdd("1");      // false
isOdd(1);        // true
isOdd(-1);       // true

Answer 20

इसका उपयोग %करने से आपको ऐसा करने में मदद मिलेगी ...

आप इसे करने के लिए कुछ फ़ंक्शन बना सकते हैं ... मैं सेपरेट फ़ंक्शंस पसंद करता हूं जो इस तरह से जावास्क्रिप्ट में नंबर से जुड़ी नहीं हैं, जो यह भी जाँचता है कि क्या आप नंबर पास कर रहे हैं या नहीं:

पुराना फंक्शन:

var isOdd = function(num) {
  return 'number'!==typeof num ? 'NaN' : !!(num % 2);
};

यहां तक ​​कि समारोह:

var isEven = function(num) {
  return isOdd(num)==='NaN' ? isOdd(num) : !isOdd(num);
};

और इसे इस तरह से कॉल करें:

isOdd(5); // true
isOdd(6); // false
isOdd(12); // false
isOdd(18); // false
isEven(18); // true
isEven('18'); // 'NaN'
isEven('17'); // 'NaN'
isOdd(null); // 'NaN'
isEven('100'); // true

Answer 21

ES6 में एक लाइनर सिर्फ इसलिए क्योंकि यह साफ है।

const isEven = (num) => num % 2 == 0;

Answer 22

बहुत से लोग विषम का अर्थ गलत समझते हैं

• isOdd("str")झूठा होना चाहिए।
  केवल एक पूर्णांक विषम हो सकता है।
• isOdd(1.223)और isOdd(-1.223)झूठा होना चाहिए।
  एक फ्लोट पूर्णांक नहीं है।
• isOdd(0)झूठा होना चाहिए।
  शून्य एक पूर्णांक ( https://en.wikipedia.org/wiki/Parity_of_zero ) है।
• isOdd(-1)सच होना चाहिए।
  यह एक अजीब पूर्णांक है।

उपाय

function isOdd(n) {

  // Must be a number
  if (isNaN(n)) {
    return false;
  }

  // Number must not be a float
  if ((n % 1) !== 0) {
    return false;
  }

  // Integer must not be equal to zero
  if (n === 0) {
    return false;
  }

  // Integer must be odd
  if ((n % 2) !== 0) {
    return true;
  }

  return false;
}

JS Fiddle (यदि आवश्यक हो): https://jsfiddle.net/9dzdv593/8/

1-लाइनर

जावास्क्रिप्ट 1-लाइनर समाधान। उन लोगों के लिए जो पठनीयता की परवाह नहीं करते हैं।

const isOdd = n => !(isNaN(n) && ((n % 1) !== 0) && (n === 0)) && ((n % 2) !== 0) ? true : false;

Comments

आप अभी तक समाधान में तेजी ला सकते हैं। यानी, अंतिम वक्तव्यों में आप बस वापस आ सकते हैं !! (n% 2), यह वैकल्पिक रूप से हस्ताक्षरित संख्याओं के साथ काम करेगा (यानी, जब n% 2 रिटर्न 0 होता है, तो यह गलत है, लेकिन जब -1 या 1 वापस आ जाता है, तो यह वापस आ जाएगा) सच लौटना)। आपका समाधान वास्तव में विषम संख्याओं के लिए गलत लौट रहा है क्योंकि यह जाँच कर रहा है कि क्या मापांक वापसी 0 है, लेकिन 1 के लिए जाँच करनी चाहिए, और 1 नकारात्मक संख्या के लिए विफल होगा, इस प्रकार वापसी !! (n% 2) सुरक्षित है। और वैसे भी, {} (ब्लॉक स्टेटमेंट) मिनिफिकेशन मुद्दों का कारण नहीं बनता है और चर्चा में मौजूद नहीं है।

— हाइड्रोपर

@ TheProHands - नोट्स के लिए धन्यवाद। (१) मुद्दा यह था कि मॉडुलस संस्करण में एक टाइपो था; इसके (n % 2) !== 0बजाय होना चाहिए था (n % 2) === 0। (2) मेरी सलाह यह है कि इससे बचना चाहिए !!(n % 2), क्योंकि (ए) की तुलना में इसका प्रदर्शन धीमा है (n % 2) !== 0( jsperf.com/notnot-vs-strict-not ), (b) यह हैक है - यह एक गलत मूल्य 0को बढ़ाता है false, और (c) यह अस्पष्ट है (उच्च स्तरीय प्रोग्रामिंग भाषाओं को प्रदर्शन के लिए पास्कल की तरह नहीं पढ़ा जाना चाहिए - यह संकलक का काम है)। (3) हां, लापता {}ब्लॉक स्टेटमेंट कई मुद्दों (जैसा कि मेरे उत्तर में अद्यतन किया गया है) में परिणाम करते हैं।

— tfmontague

मैं ब्लॉक स्टेटमेंट से कभी नहीं बचता क्योंकि मुझे पठनीयता की परवाह है, लेकिन मैं यह बताने की कोशिश कर रहा हूं कि ब्लॉक स्टेटमेंट मांगने से मुद्दों का परिणाम नहीं होता है, केवल कोड मेंटेन होता है। यानी, ब्लॉक स्टेटमेंट के बजाय एक्सप्रेशन स्टेटमेंट के साथ मर्ज किए गए सीक्वेंस एक्सप्रेशन का उपयोग करके कोड को अपठनीय और बदसूरत बना दिया जा सकता है, अर्थात:, if (0) call1(), assign = 0, call2()लेकिन एक भी स्टेटमेंट खराब नहीं है: if (0) return; if (0) ;; if (0); break; if (0) continue;और वैसे भी जब मैं ब्रेक-लाइन ब्लॉक स्टेटमेंट का उपयोग करना जारी रखना पसंद करता हूं लंबी-लंबी इनलाइन स्थितियां।

— हाइड्रोपर

अपने तरह के प्रकार / बातिल चेकों isNaN(n)मूर्ख हैं - सुनिश्चित करें कि आप कवर NaNमामला है, लेकिन isOdd(null), isOdd(undefined), isOdd({x:1})सभी वापसी falseजो मैं एक त्रुटि पर विचार; जब तक कि आप केवल यह निर्दिष्ट नहीं कर रहे हैं कि आपके फ़ंक्शन का किसी दिए गए डोमेन पर सही व्यवहार है: केवल नंबर-प्रकार के इनपुट। जिस स्थिति में, बस isNaNचेक को ड्रॉप करें और उपयोगकर्ता को सही प्रकार से कॉल करने के लिए मजबूर करें। रक्षात्मक प्रोग्रामिंग भयानक है। तब आपका कार्य सरल हो जाता है isOdd = x => Math.floor(x) === x && x & 1 === 1- स्पष्ट trueया falseमूल्यों को लौटाना आवश्यक नहीं है

— धन्यवाद

null, undefinedऔर ऑब्जेक्ट्स {}अजीब पूर्णांक नहीं हैं, और इसलिए फ़ंक्शन वापस लौटता है false- सुनिश्चित नहीं है कि आप उस त्रुटि को क्यों मानते हैं। isNaNचेक (रक्षा के लिए नहीं) प्रदर्शन के लिए है, यह अन्य चेक के बिना प्रदर्शन समय से पहले ही समारोह से बाहर निकलें करने देता है।

— tfmontague

Answer 23

मैं इसे बूलियन वापस करने के लिए लागू करूंगा:

function isOdd (n) {
    return !!(n % 2);
    // or ((n % 2) !== 0).
}

यह अहस्ताक्षरित और हस्ताक्षरित संख्याओं पर काम करेगा। जब मापांक वापस आएगा -1या 1इसका अनुवाद किया जाएगा true।

गैर मापांक समाधान:

var is_finite = isFinite;
var is_nan = isNaN;

function isOdd (discriminant) {
    if (is_nan(discriminant) && !is_finite(discriminant)) {
        return false;
    }

    // Unsigned numbers
    if (discriminant >= 0) {
        while (discriminant >= 1) discriminant -= 2;

    // Signed numbers
    } else {
        if (discriminant === -1) return true;
        while (discriminant <= -1) discriminant += 2;
    }

    return !!discriminant;
}

Answer 24

आधुनिक जावास्क्रिप्ट में एक अधिक कार्यात्मक दृष्टिकोण:

const NUMBERS = "nul one two three four five six seven ocho nueve".split(" ")

const negate = f=> (...args)=> !f(...args)
const isOdd  = n=> NUMBERS[n % 10].indexOf("e")!=-1
const isEven = negate(isOdd)

Answer 25

ES6 में:

const isOdd = num => num % 2 == 1;

Comments

26 मौजूदा उत्तरों के साथ आठ साल पुराने प्रश्न के उत्तर को जोड़ने पर यह वास्तव में यह समझाने के लिए उपयोगी है कि आपके उत्तर के प्रश्नों का नया पहलू क्या है, और यदि समय और नए संस्करण का उत्तर उत्तर को प्रभावित करता है। एक कोड केवल उत्तर लगभग हमेशा कुछ स्पष्टीकरण के अलावा द्वारा सुधार किया जा सकता है और इस मामले में कुछ उदाहरण उपयोग दिखाते हैं।

— जेसन एलर

शीर्षक है 'जावास्क्रिप्ट में कोई संख्या विषम है या नहीं, यह कैसे निर्धारित किया जाए' और कहा गया कि कोई ईएस 6 समाधान पोस्ट नहीं किया गया है।

— डैरिल मेंडोंज

Answer 26

टर्नरी ऑपरेटर का उपयोग करके, आप विषम संख्याओं को पा सकते हैं:

var num = 2;
result = (num % 2 == 0) ? 'even' : 'odd'
console.log(result);

Answer 27

यह सरणियों के लिए काम करता है:

function evenOrOdd(numbers) {
  const evenNumbers = [];
  const oddNumbers = [];
  numbers.forEach(number => {
    if (number % 2 === 0) {
      evenNumbers.push(number);
    } else {
      oddNumbers.push(number);
    }
  });

  console.log("Even: " + evenNumbers + "\nOdd: " + oddNumbers);
}

evenOrOdd([1, 4, 9, 21, 41, 92]);

यह लॉग आउट होना चाहिए: 4,92 1,9,21,41

सिर्फ एक संख्या के लिए:

function evenOrOdd(number) {
  if (number % 2 === 0) {
    return "even";
  }

  return "odd";
}

console.log(evenOrOdd(4));

यह कंसोल के लिए भी आउटपुट होना चाहिए