Cómo determinar si un número es impar en JavaScript

245

¿Alguien puede señalarme algún código para determinar si un número en JavaScript es par o impar?

javascript 
— Jannie Theunissen
fuente
66
— epascarello
1
@DavidThomas Estoy parcialmente de acuerdo, pero tengo dos advertencias: 1. Si tuviera que elegir, preferiría un programador principiante que supiera sobre el %operador &, y 2. Si bien &es teóricamente más rápido, realmente no importa .
— kojiro
3
@kojiro: Prefiero presentar más opciones (válidas) a un alumno; Además, nunca había pensado usar bitwise- y de esta manera antes, así que es una toma interesante. De todos modos, dado que es un engaño, he marcado la fusión con la pregunta preexistente. Con suerte, entonces, las respuestas aquí (esa respuesta en particular al menos) no se perderán.
— David dice que reinstale a Mónica el
1
@kojiro Me temo decir que su violín es bastante inútil, ya que la mayor parte del tiempo computacional lo toman las llamadas a funciones. Pero nadie usará una llamada de función para determinar si un número es par o impar ... Hice una tercera revisión de su prueba, pero ahora estoy en mi teléfono ...
— MaxArt
1
posible duplicado de Prueba si un valor es par o impar
— bummi

Respuestas:

347

Use el siguiente código:

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

1 representa un número impar, mientras que 0 representa un número par.

— Chii
fuente
97
Tenga en cuenta que esto regresará 0o 1(o NaNsi lo alimenta con algo que no es un número y no se puede forzar en uno), lo que funcionará bien para la mayoría de las situaciones. Pero si quieres un verdadero trueo false:return (num % 2) == 1;
— TJ Crowder
3
sí buena nota sobre el NaN. Pero, por lo general, desea que JavaScript sea verdadero o falso, por eso lo escribí de la manera que lo hice.
— Chii
99
Solo para aclarar, el operador de módulo (%) da el resto de una división. Entonces 3% 2 sería 3/2, dejando 1 como resto, por lo tanto 3% 2 devolverá 1.
— Abuh
66
Además de lo que dijo TJ, esto devolverá una fracción si numno es un número entero. Lo que aún funcionará si compara isOdd(1.5)==true(porque un valor fraccionario no es igual a true), pero sería mejor si la función regresara trueo falsecomo lo implica el nombre "isOdd".
— nnnnnn
66
También puede hacer return !!(num % 2)para obtener un booleano
— Duncan
115

Use el ANDoperador 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>
Expandir fragmento

Si no desea un valor de retorno de cadena, sino un valor booleano, use esto:

var isOdd = function(x) { return x & 1; };
var isEven  = function(x) { return !( x & 1 ); };
— 0x499602D2
fuente
55
+1, tu respuesta definitivamente supera a la mía, ¡sin mencionar que tienes la única respuesta que no usa X % Y!
— s0d4pop
44
No estoy seguro de si mi prueba es precisa, pero el Y bit a bit parece ser 40 veces más lento que el operador de módulo para un número fijo y 2 veces más lento para un número aleatorio: jsperf.com/odd-or-even
— Blender
8
Tenga en cuenta que esto devolverá "impar" o "par" para los números que tampoco lo son (por ejemplo, 3.14).
— nnnnnn
2
O: function isEven(n){return !(n & 1);}.
— RobG
77
@Gnuey Cada número se compone de una serie de bits. Todos los números impares tienen el bit menos significativo (más a la derecha) establecido en 1, todos los números pares 0. x & 1Comprueba si el último bit está establecido en el número (porque 1 es un número con todos los bits establecidos en 1 excepto el bit menos significativo ): Si es así , el número es impar, de lo contrario, par.
— 0x499602D2
31

Podrías hacer algo como esto:

function isEven(value){
    if (value%2 == 0)
        return true;
    else
        return false;
}
— TNC
fuente
99
No parece que sepas qué es un booleano. if (condition) { answer=true; } else { answer=false; }es solo una versión innecesariamente prolija de answer = (bool) condition;. Reduzca su función function isEven(value) { return (bool) (value%2 == 0); }y todos seremos felices.
— awm
99
No es necesario ser sarcástico, porque programo algo diferente.
— TNC
55
@awm - Parece que no sabes JavaScript. No puede convertir a booleano con (bool)(eso dará un error) y, en cualquier caso, no necesita: return value%2 == 0;hará el trabajo ya que el ==operador devuelve un booleano.
— nnnnnn
2
Wow, ¿realmente escribí eso? Sí, eso obviamente está mal; debe ser algo así answer = !!(condition). El punto que estaba tratando de hacer, por supuesto, es que puedes simplemente return value%2==0y no necesitas molestarte con el condicional.
— awm
Me parece elegante: value%2===0
— carlodurso
13

¿Tengo que hacer una matriz realmente grande que tenga muchos números pares

No. Use el módulo (%). Te da el resto de los dos números que estás dividiendo.

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.

Esto significa que si modificas cualquier número x por 2, obtienes 0 o 1 o -1. 0 significaría que es par. Cualquier otra cosa significaría que es extraño.

— Isaac Fife
fuente
8

Esto se puede resolver con un pequeño fragmento de código: 

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

Espero que esto ayude :)

— s0d4pop
fuente
6

Al igual que muchos idiomas, Javascript tiene un operador de módulo% , que encuentra el resto de la división. Si no queda ningún resto después de la división por 2, un número es par:

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

Este es un idioma muy común para probar incluso números enteros.

— pb2q
fuente
3
Sin embargo, el módulo puede ser complicado / indefinido para valores negativos ... asegúrese de consultar la especificación de lenguaje apropiada.
5

Una función simple que puedes pasar. Utiliza el operador de módulo %:

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

is_even(3)
false
is_even(6)
true
— dgh
fuente
1
Si sus resultados en el operador ternario son 'verdadero' o 'falso', realmente no necesita el operador ternario. Aquí, usted podría / debería hacer:return !(x % 2);
— dom_watson
4

Usa mis extensiones: 

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

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

luego 

var a=5; 
 a.isEven();

== falso

 a.isOdd();

== verdadero

Si no está seguro de si es un Número, pruébelo mediante la siguiente ramificación: 

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

ACTUALIZACIÓN

si no usarías la variable: 

(5).isOdd()

Actuación :

Resulta que el paradigma procesal es mejor que el paradigma OOP. Por cierto, realicé la creación de perfiles en este FIDDLE . Sin embargo, la forma OOP sigue siendo la más bonita.

ingrese la descripción de la imagen aquí

— Abdennour TOUMI
fuente
Gracias amigo, por esta lógica, en el entrevistado alguien preguntó este tipo de lógica, no podía responder, ahora lo tengo, gracias ... pero ¿hay algún beneficio en el rendimiento al seguir este método? podríamos haber escrito isEven (x); etc.
— Shoib Mohammed A
@ShoibMohammedA: ¡Se ha hecho la comparación! jsfiddle.net/abdennour/jL2uyksa/3
— Abdennour TOUMI
-1 no amplía las funciones prototipo nativas. ( stackoverflow.com/questions/14034180/… )
— tfmontague
3

Reste 2 recursivamente hasta llegar a -1 o 0 (obviamente solo funciona para enteros positivos) :)

— asimétrico
fuente
Con números negativos, en cambio, aumenta 2 a él
— Hydroper
Y lleva un tiempo infernal cuando n = 2 ^ 52, y una cantidad infinita para n> 2 ^ 53
— rioV8
3

Puede usar un enunciado for y un condicional para determinar si un número o serie de números es impar:

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

Esto imprimirá cada número impar entre 1 y 5.

— bastardo descarado
fuente
3

Acabo de ejecutar este en Adobe Dreamweaver ... funciona perfectamente. solía if (isNaN (mynmb))

para verificar si el valor dado es un número o no, y también usé Math.abs (mynmb% 2) para convertir un número negativo a positivo y calcular

    <!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
fuente
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
fuente
2 
if (X % 2 === 0){
} else {
}

Reemplace X con su número (puede provenir de una variable). La instrucción If se ejecuta cuando el número es par, el otro cuando es impar.

Si solo quieres saber si algún número es impar:

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

Nuevamente, reemplace X con un número o variable.

— Gui Premonsa
fuente
2

Cada número impar cuando se divide entre dos deja el resto como 1 y cada número par cuando se divide entre cero deja un cero como resto. Por lo tanto, podemos usar este código

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

Qué tal esto...

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

    alert(aa[num % 2]);
— AndroidManifester
fuente
2

Esto es lo que hice

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

Por alguna razón tuve que asegurarme de que la longitud de la matriz sea menor en uno. Cuando no hago eso, me aparece "indefinido" en el último elemento de la matriz oddNumbers.

— Zakher Masri
fuente
2
Es porque la condición se establece en menor o igual a "<=" a la longitud de la matriz. Eliminé el signo igual y el resultado fue el deseado
— Zakher Masri
2

Cuando necesite probar si alguna variable es impar, primero debe probar si es entera . Además, tenga en cuenta que cuando calcule el resto en un número negativo, el resultado será 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
}

Si Number.isInteger está disponible, también puede simplificar este código para:

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

Nota: aquí, probamos en value % 2 !== 0lugar de value % 2 === 1es por -3 % 2 === -1. Si no desea -1pasar esta prueba, es posible que deba cambiar esta línea.

Aquí hay algunos casos de prueba:

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

Utilizando % te ayudará a hacer esto ...

Puede crear un par de funciones para que lo haga por usted ... Prefiero separar las funciones que no están unidas a Number en Javascript como esta, que también comprueba si pasa un número o no:

Función impar:

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

incluso función:

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

y llámalo así:

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

Un revestimiento en ES6 solo porque está limpio.

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

— Damdeez
fuente
2

Mucha gente no entiende el significado de extraño

  • isOdd("str")debería ser falso
    Solo un número entero puede ser impar.
  • isOdd(1.223)y isOdd(-1.223)debe ser falso
    Un flotador no es un número entero.
  • isOdd(0)debería ser falso
    Zero es un entero par ( https://en.wikipedia.org/wiki/Parity_of_zero ).
  • isOdd(-1)Debería ser cierto.
    Es un entero extraño.

Solución

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 (si es necesario): https://jsfiddle.net/9dzdv593/8/

1 liner

Solución Javascript 1-liner. Para aquellos a quienes no les importa la legibilidad.

const isOdd = n => !(isNaN(n) && ((n % 1) !== 0) && (n === 0)) && ((n % 2) !== 0) ? true : false;
— tfmontague
fuente
Puede acelerar la solución todavía. es decir, en las declaraciones finales solo puede devolver !! (n% 2), esto opcionalmente hará que funcione con números con signo (es decir, cuando n% 2 devuelve 0, es falso, pero cuando -1 o 1 devuelto, esto sería volver verdadero). Su solución en realidad está devolviendo falso para números impares, ya que está verificando si el retorno del módulo es 0, pero debería verificar 1, y 1 fallaría para números negativos, por lo tanto, el retorno !! (n% 2) es más seguro. Y de todos modos, {} (declaración de bloque) no causa problemas de minificación y no está presente en la discusión.
— Hydroper
@TheProHands - Gracias por las notas. (1) El problema era que la versión del módulo tenía un error tipográfico; debería haber sido en (n % 2) !== 0lugar de (n % 2) === 0. (2) Mi consejo es evitar !!(n % 2), porque (a) tiene un rendimiento más lento que (n % 2) !== 0( jsperf.com/notnot-vs-strict-not ), (b) que es un truco - que coacciona a un valor Falsey- 0en false, y (c) es oscuro (los lenguajes de programación de alto nivel no deberían leerse como Pascal en aras del rendimiento, ese es el trabajo del compilador). (3) Sí, las {}declaraciones de bloque que faltan resultan en varios problemas (como se actualizó en mi respuesta).
— tfmontague
Nunca evito las declaraciones de bloque porque me importa la legibilidad, pero estoy tratando de decir que buscar declaraciones de bloque no genera problemas, solo el mantenimiento del código. Es decir, el uso de expresiones de secuencia fusionadas con la declaración de expresión en lugar de la declaración de bloque puede hacer que el código sea ilegible y feo, es decir if (0) call1(), assign = 0, call2(), pero una sola declaración no es mala: if (0) return; if (0) ;; if (0); break; if (0) continue;y de todos modos prefiero continuar usando declaraciones de bloque de línea de corte cuando he condiciones en línea larga.
— Hydroper
Cheques / null como tu isNaN(n)son tontos - Seguro que cubría el NaNcaso, pero isOdd(null), isOdd(undefined), isOdd({x:1})todos regresan falseque considero un error; a menos, por supuesto, que solo esté especificando que su función tiene un comportamiento correcto sobre un dominio dado: solo entradas de tipo Numérico. En ese caso, simplemente suelte el isNaNcheque y obligue al usuario a llamarlo con el tipo correcto. La programación defensiva es horrible. Luego, su función se simplifica a isOdd = x => Math.floor(x) === x && x & 1 === 1- regresar explícito trueo los falsevalores no son necesarios
— Gracias
null, undefinedy los objetos {}no son enteros impares y, por lo tanto, la función regresa false; no estoy seguro de por qué lo considera un error. La isNaNcomprobación es para el rendimiento (no para la defensa), permite que la función salga prematuramente sin realizar las otras comprobaciones.
— tfmontague
1

Implementaría esto para devolver un booleano:

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

Funcionará tanto en números sin signo como con signo. Cuando regrese el módulo -1o 1se traducirá atrue .

Solución sin módulo:

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

Un enfoque más funcional en 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
fuente
1

en ES6:

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

— Darryl Mendonez
fuente
3
Al agregar una respuesta a una pregunta de ocho años con 26 respuestas existentes, es realmente útil explicar qué nuevo aspecto de la pregunta aborda su respuesta, y si el paso del tiempo y las nuevas versiones impactan la respuesta. Una respuesta de solo código casi siempre se puede mejorar mediante la adición de alguna explicación y en este caso algunas llamadas de ejemplo que muestran el uso.
— Jason Aller
1
el título es "Cómo determinar si un número es impar en JavaScript" y no se publicó ninguna solución ES6 para lo que se solicita.
— Darryl Mendonez
0

Al usar el operador ternario, podemos encontrar los números pares impares:

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

— Mahendra Kulkarni
fuente
0

esto funciona para matrices:

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

esto debería cerrar sesión: 4,92 1,9,21,41

por solo un número:

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

  return "odd";
}

console.log(evenOrOdd(4));

esto debería salir incluso a la consola

— JuicY_Burrito
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.