245

Qualcuno può indicarmi un codice per determinare se un numero in JavaScript è pari o dispari?

javascript

— Jannie Theunissen
fonte

6

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

— epascarello

1

@DavidThomas Sono in parte d'accordo, ma ho due avvertimenti: 1. Se dovessi scegliere, preferirei che un programmatore principiante conoscesse l' %operatore piuttosto che &, e 2. Sebbene &teoricamente sia più veloce, in realtà non importa .

— Kojiro,

3

@kojiro: Preferirei presentare più opzioni (valide) a uno studente; Inoltre non avevo mai pensato di usare bit per bit e in questo modo prima, quindi è una scelta interessante. Ad ogni modo, dato che si tratta di un imbroglione, ho segnalato per la fusione con la domanda preesistente. Speriamo, quindi, che le risposte qui (almeno quella particolare risposta) non andranno perse.

— David dice di reintegrare Monica il

1

@kojiro Ho paura di dire che il tuo violino è abbastanza inutile, poiché la maggior parte del tempo di calcolo è occupato dalle chiamate di funzione. Ma nessuno userà una chiamata di funzione per determinare se un numero è pari o dispari ... Ho fatto una terza revisione del tuo test, ma ora sono sul mio telefono ...

— MaxArt

1

possibile duplicato di Testing se un valore è pari o dispari

— bummi

347

Usa il codice qui sotto:

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

Espandi frammento

1 rappresenta un numero dispari, mentre 0 rappresenta un numero pari.

— Chii
fonte

97

Nota che questo restituirà 0o 1(o NaNse gli dai qualcosa che non è un numero e non può essere forzato in uno), che funzionerà bene per la maggior parte delle situazioni. Ma se vuoi un vero trueo false:return (num % 2) == 1;

— TJ Crowder,

3

sì, una buona nota sulla NaN. Ma di solito, vuoi che JavaScript sia sincero o falso, motivo per cui l'ho scritto come ho fatto io.

— Chii,

9

Giusto per chiarire, l'operatore modulo (%) fornisce il resto di una divisione. Quindi il 3% 2 sarebbe 3/2, lasciando 1 come resto, quindi il 3% 2 restituirà 1.

— Abuh

6

Oltre a ciò che ha detto TJ, questo restituirà una frazione se numnon è un numero intero. Che funzionerà comunque se si confronta isOdd(1.5)==true(perché un valore frazionario non è uguale a true), ma sarebbe meglio se la funzione restituita trueo falsecome implicita dal nome "isOdd".

— nnnnnn,

6

Puoi anche fare return !!(num % 2)un booleano

— Duncan il

115

Usa l' ANDoperatore bit a bit .

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>

Espandi frammento

Se non vuoi un valore di ritorno stringa, ma piuttosto un valore booleano, usa questo:

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

— 0x499602D2
fonte

5

+1, la tua risposta è decisamente migliore della mia, per non parlare del fatto che hai l'unica risposta che non usa X % Y!

— s0d4pop,

4

Non sono sicuro che il mio test sia accurato, ma AND AND bit a bit sembra essere 40 volte più lento dell'operatore modulo per un numero fisso e 2 volte più lento per un numero casuale: jsperf.com/odd-or-even

— Blender

8

Si noti che questo restituirà "dispari" o "pari" per i numeri che non sono neanche (ad esempio 3.14).

— nnnnnn,

2

Oppure: function isEven(n){return !(n & 1);}.

— RobG

7

@Gnuey Ogni numero è composto da una serie di bit. Tutti i numeri dispari hanno il bit meno significativo (all'estrema destra) impostato su 1, tutti i numeri pari 0. x & 1Controlla se l'ultimo bit è impostato nel numero (perché 1 È un numero con tutti i bit impostati su 1 tranne il bit meno significativo ): Se lo è , il numero è dispari, altrimenti pari.

— 0x499602D2

31

Potresti fare qualcosa del genere:

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

— TNC
fonte

9

Non sembra che tu sappia cosa sia un booleano. if (condition) { answer=true; } else { answer=false; }è solo una versione inutilmente prolissa di answer = (bool) condition;. Riduci la tua funzione function isEven(value) { return (bool) (value%2 == 0); }e saremo tutti felici.

— awm

9

Non c'è bisogno di diventare snarky, perché programma qualcosa di diverso.

— TNC,

5

@awm - Sembra che tu non conosca JavaScript. Non è possibile eseguire il cast in booleano (bool)(che darà un errore) e in ogni caso non è necessario: return value%2 == 0;farà il lavoro poiché l' ==operatore restituisce un booleano.

— nnnnnn,

2

Wow, l'ho davvero scritto? Sì, è ovviamente sbagliato; dovrebbe essere qualcosa di simile answer = !!(condition). Il punto che stavo cercando di sottolineare, ovviamente, è che puoi semplicemente return value%2==0e non devi preoccuparti del condizionale.

— awm

Lo trovo elegante: value%2===0

— carlodurso il

17

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

— CloudyMarble
fonte

13

Devo creare un array davvero grande che abbia molti numeri pari

No. Usa il modulo (%). Ti dà il resto dei due numeri che stai dividendo.

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.

Questo significa che se modifichi un numero x per 2, ottieni 0 o 1 o -1. 0 significherebbe che è pari. Qualsiasi altra cosa significherebbe che è strano.

— Isaac Fife
fonte

8

Questo può essere risolto con un piccolo frammento di codice:

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

Spero che questo ti aiuti :)

— s0d4pop
fonte

6

Come molte lingue, Javascript ha un operatore di modulo% , che trova il resto della divisione. Se non vi è resto dopo la divisione per 2, un numero è pari:

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

Questo è un linguaggio molto comune per testare anche numeri interi.

— pb2q
fonte

3

Tuttavia, il modulo può essere complicato / indefinito per valori negativi. Assicurati di consultare le specifiche del linguaggio appropriate.

6

Con bit a bit, codegolfing:

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

— Katia Punter
fonte

5

Una semplice funzione che puoi passare. Utilizza l'operatore modulo %:

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

is_even(3)
false
is_even(6)
true

— DGH
fonte

1

Se i risultati nell'operatore ternario sono "vero" o "falso", in realtà non è necessario l'operatore ternario. Qui, potresti / dovresti semplicemente fare:return !(x % 2);

— dom_watson il

4

Usa le mie estensioni:

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

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

poi

var a=5; 
 a.isEven();

== false

 a.isOdd();

== true

se non si è sicuri che si tratti di un numero, verificarlo con la seguente ramificazione:

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

AGGIORNARE :

se non useresti la variabile:

(5).isOdd()

Prestazione :

Si scopre che il paradigma procedurale è migliore del paradigma OOP. A proposito, ho eseguito la profilazione in questo FIDDLE . Tuttavia, il modo OOP è ancora più bello.

— Abdennour TOUMI
fonte

Grazie amico, per questa logica, nell'intervistato qualcuno ha chiesto questo tipo di logica, non ha potuto rispondere, ora l'ho capito, grazie .. ma c'è qualche vantaggio nelle prestazioni seguendo questo metodo? avremmo potuto scrivere isEven (x); ecc.

— Shoib Mohammed,

@ShoibMohammedA: il confronto è stato fatto! jsfiddle.net/abdennour/jL2uyksa/3

— Abdennour TOUMI

-1 non estende le funzioni del prototipo nativo. ( Stackoverflow.com/questions/14034180/... )

— tfmontague

3

Sottrai 2 in modo ricorsivo fino a raggiungere -1 o 0 (ovviamente funziona solo con numeri interi positivi) :)

— asimmetrico
fonte

Con numeri negativi invece aumenti 2 ad esso

— Hydroper

E ci vuole un tempo infernale quando n = 2 ^ 52 e una quantità infinita per n> 2 ^ 53

— rioV8

3

È possibile utilizzare un'istruzione for e una condizionale per determinare se un numero o una serie di numeri è dispari:

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

Questo stamperà ogni numero dispari tra 1 e 5.

— bastardo sfacciato
fonte

3

Ho appena eseguito questo in Adobe Dreamweaver ... funziona perfettamente. ho usato if (isNaN (mynmb))

per verificare se il valore dato è un numero o meno e ho anche usato Math.abs (mynmb% 2) per convertire il numero negativo in positivo e calcolare

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

— Srivastav
fonte

3

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

— Kirandeep Singh
fonte

2

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

Sostituisci X con il tuo numero (può provenire da una variabile). L'istruzione If viene eseguita quando il numero è pari, Else quando è dispari.

Se vuoi solo sapere se un determinato numero è dispari:

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

Ancora una volta, sostituisci X con un numero o una variabile.

— Gui Premonsa
fonte

2

Ogni numero dispari se diviso per due foglie rimane come 1 e ogni numero pari quando diviso per zero lascia uno zero come resto. Quindi possiamo usare questo codice

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

— Augusto Francesco
fonte

2

Cosa ne pensi di questo...

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

    alert(aa[num % 2]);

— AndroidManifester
fonte

2

Questo è quello che ho fatto

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

Per qualche motivo ho dovuto assicurarmi che la lunghezza dell'array fosse inferiore di uno. Quando non lo faccio, ottengo "indefinito" nell'ultimo elemento dell'array oddNumbers.

— Zakher Masri
fonte

2

È perché la condizione è impostata su minore o uguale "<=" alla lunghezza dell'array. Ho rimosso il segno di uguale ed è il risultato era come desiderato.

— Zakher Masri,

2

Quando devi verificare se qualche variabile è dispari, dovresti prima verificare se è intera . Si noti inoltre che quando si calcola il resto sul numero negativo, il risultato sarà negativo ( -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
}

Se Number.isInteger è disponibile, puoi anche semplificare questo codice per:

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

Nota: qui, testiamo value % 2 !== 0invece di value % 2 === 1è a causa di -3 % 2 === -1. Se non si desidera -1superare questo test, potrebbe essere necessario modificare questa riga.

Ecco alcuni casi di test:

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

— tsh
fonte

2

L'utilizzo %ti aiuterà a fare questo ...

Puoi creare un paio di funzioni per farlo per te ... Preferisco separare le funzioni che non sono collegate a Number in Javascript in questo modo, che controlla anche se passi il numero o meno:

funzione dispari:

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

funzione pari:

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

e chiamalo così:

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

— Alireza
fonte

2

Una fodera in ES6 solo perché è pulita.

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

— damdeez
fonte

2

Molte persone fraintendono il significato di strano

isOdd("str")dovrebbe essere falso.
Solo un numero intero può essere dispari.
isOdd(1.223)e isOdd(-1.223)dovrebbe essere falso.
Un float non è un numero intero.
isOdd(0)dovrebbe essere falso.
Zero è un numero intero pari ( https://en.wikipedia.org/wiki/Parity_of_zero ).
isOdd(-1)dovrebbe essere vero.
È un numero intero dispari.

Soluzione

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 (se necessario): https://jsfiddle.net/9dzdv593/8/

1-liner

Soluzione Javascript da 1 liner. Per coloro che non si preoccupano della leggibilità.

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

— tfmontague
fonte

Puoi ancora accelerare la soluzione. cioè, nelle dichiarazioni finali puoi semplicemente restituire !! (n% 2), questo opzionalmente lo farà funzionare con i numeri con segno (cioè, quando n% 2 restituisce 0, è falso, ma quando -1 o 1 restituito, questo sarebbe ritorno vero). La tua soluzione in realtà sta restituendo false per i numeri dispari poiché sta controllando se il modulo restituito è 0, ma dovrebbe controllare 1, e 1 fallirebbe per i numeri negativi, quindi return !! (n% 2) è più sicuro. E comunque, {} (istruzione di blocco) non causa problemi di minimizzazione e non è presente nella discussione.

— Idroper

@TheProHands - Grazie per le note. (1) Il problema era che la versione del modulo aveva un refuso; avrebbe dovuto essere (n % 2) !== 0invece di (n % 2) === 0. (2) Il mio consiglio è di evitare !!(n % 2), perché (a) ha prestazioni più lente rispetto a (n % 2) !== 0( jsperf.com/notnot-vs-strict-not ), (b) è un hack - costringe un valore falso 0in false, e (c) è oscuro (i linguaggi di programmazione di alto livello non dovrebbero leggere come Pascal per motivi di prestazioni - questo è il lavoro del compilatore). (3) Sì, le {}dichiarazioni di blocco mancanti causano diversi problemi (come aggiornato nella mia risposta).

— tfmontague,

Non evito mai le istruzioni di blocco perché mi preoccupo della leggibilità, ma sto cercando di dire che la ricerca di istruzioni di blocco non provoca problemi, ma solo nel mantenimento del codice. Vale a dire, l'uso di espressioni di sequenza unite a istruzioni di espressioni anziché istruzioni di blocco potrebbe rendere il codice illeggibile e brutto, ovvero:, if (0) call1(), assign = 0, call2()ma una singola istruzione non è male: if (0) return; if (0) ;; if (0); break; if (0) continue;e comunque preferisco continuare a usare le istruzioni di blocco di interruzione quando ho condizioni a lungo termine.

— Idroper

controlli di tipo / null come il vostro isNaN(n)sono sciocchi - che si copriva il NaNcaso, ma isOdd(null), isOdd(undefined), isOdd({x:1})tutto il ritorno falseche io ritengo essere un errore; a meno che ovviamente non specifichi solo che la tua funzione ha un comportamento corretto su un determinato dominio: solo input di tipo numerico. In tal caso, rilasciare il isNaNsegno di spunta e forzare l'utente a chiamarlo con il tipo corretto. La programmazione difensiva è terribile. Quindi la tua funzione è semplificata a isOdd = x => Math.floor(x) === x && x & 1 === 1- non è necessario restituire valori espliciti trueo falsevalori

— Grazie

null, undefinedE gli oggetti {}non sono interi dispari, e quindi la funzione ritorna false- non so perché si considera che un errore. Il isNaNcontrollo è per le prestazioni (non per la difesa), consente alla funzione di uscire prematuramente senza eseguire gli altri controlli.

— tfmontague,

1

Lo implementerei per restituire un valore booleano:

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

Funzionerà su numeri sia non firmati che firmati. Quando il modulo ritorna -1o 1verrà tradotto in true.

Soluzione non modulo:

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

— Hydroper
fonte

1

Un approccio più funzionale nel javascript moderno:

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)

— Gunn
fonte

1

in ES6:

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

— Darryl Mendonez
fonte

3

Quando aggiungi una risposta a una domanda di otto anni con 26 risposte esistenti, è davvero utile spiegare quale nuovo aspetto della domanda affronta la tua risposta e se il passare del tempo e le nuove versioni influiscono sulla risposta. Una risposta di solo codice può quasi sempre essere migliorata con l'aggiunta di alcune spiegazioni e in questo caso alcuni esempi di chiamate che mostrano l'utilizzo.

— Jason Aller il

1

il titolo è "Come determinare se un numero è dispari in JavaScript" e non è stata pubblicata una soluzione ES6 per ciò che viene richiesto.

— Darryl Mendonez,

0

Usando l'operatore ternario, puoi trovare i numeri pari dispari:

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

Espandi frammento

— Mahendra Kulkarni
fonte

0

questo funziona per gli array:

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

questo dovrebbe disconnettersi: 4,92 1,9,21,41

solo per un numero:

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

  return "odd";
}

console.log(evenOrOdd(4));

questo dovrebbe essere trasmesso anche alla console

— JuicY_Burrito
fonte