245

Alguém pode me indicar algum código para determinar se um número em JavaScript é par ou ímpar?

javascript

— Jannie Theunissen
fonte

6

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

— epascarello

1

@DavidThomas Em parte, concordo, mas tenho duas ressalvas: 1. Se eu tivesse que escolher, prefiro que um programador iniciante soubesse sobre o %operador do que &e 2. Embora &seja teoricamente mais rápido, realmente não importa .

— Kojiro

3

@kojiro: Prefiro que mais opções (válidas) sejam apresentadas a um aluno; além disso, eu nunca tinha pensado em usar bit a bit - e dessa maneira antes, por isso é uma abordagem interessante. De qualquer forma, como é uma bobagem, eu sinalizei a fusão com a pergunta pré-existente. Felizmente, então, as respostas aqui (pelo menos essa resposta específica) não serão perdidas.

— David diz que restabelece Monica

1

@kojiro Tenho medo de dizer que seu violino é bastante inútil, pois a maior parte do tempo computacional é gasto pelas chamadas de função. Mas ninguém vai usar uma chamada de função para determinar se um número é par ou ímpar ... Eu fiz uma terceira revisão do seu teste, mas estou no meu telefone agora ...

— maxart

1

possível duplicata de testar se um valor é par ou ímpar

— Bummi

347

Use o código abaixo:

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 snippet

1 representa um número ímpar, enquanto 0 representa um número par.

— Chii
fonte

97

Observe que isso retornará 0ou 1(ou NaNse você alimentar algo que não é um número e não pode ser coagido em um), o que funcionará bem na maioria das situações. Mas se você quer um real trueou false:return (num % 2) == 1;

— TJ Crowder

3

sim boa nota sobre o NaN. Mas geralmente, você deseja que o javascript seja verdade ou falsey, e é por isso que escrevi da maneira que escrevi.

— Chii

9

Apenas para esclarecer, o operador do módulo (%) fornece o restante de uma divisão. Então 3% 2 seria 3/2, deixando 1 como um remanescente, portanto 3% 2 retornará 1.

— Abuh

6

Além do que TJ disse, isso retornará uma fração se numnão for um número inteiro. O que ainda funcionará se você comparar isOdd(1.5)==true(porque um valor fracionário não é igual a true), mas seria melhor se a função retornasse trueou falseconforme implícita no nome "isOdd".

— Nnnnnn

6

Você também pode fazer return !!(num % 2)para obter um booleano

— Duncan

115

Use o 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 snippet

Se você não deseja um valor de retorno de string, mas um valor booleano, use este:

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

— 0x499602D2
fonte

5

+1, sua resposta definitivamente supera a minha, sem mencionar que você tem a única resposta que não usa X % Y!

— S0d4pop

4

Não sei se meu teste é preciso, mas o AND bit a bit parece 40 vezes mais lento que o operador de módulo para um número fixo e 2 vezes mais lento para um número aleatório: jsperf.com/odd-or-even

— Blender

8

Observe que isso retornará "ímpar" ou "par" para números que não são (por exemplo, 3,14).

— Nnnnnn

2

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

— RobG 12/08

7

@Gnuey Todo número é composto por uma série de bits. Todos os números ímpares têm o bit menos significativo (mais à direita) definido como 1, todos os números pares 0. x & 1Verifica se o último bit está definido no número (porque 1 É um número com todos os bits definidos como 1, exceto o bit menos significativo ): Se for , o número é ímpar, caso contrário, é par.

— 0404602D2

31

Você poderia fazer algo assim:

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

— TNC
fonte

9

Não parece que você sabe o que é um booleano. if (condition) { answer=true; } else { answer=false; }é apenas uma versão desnecessariamente prolixo de answer = (bool) condition;. Reduza sua função function isEven(value) { return (bool) (value%2 == 0); }e todos seremos felizes.

— AWM

9

Não há necessidade de se irritar, porque eu programa algo diferente.

— TNC

5

@awm - Parece que você não sabe JavaScript. Você não pode converter para booleano com (bool)(isso dará um erro) e, em qualquer caso, não precisará: return value%2 == 0;fará o trabalho, pois o ==operador retorna um booleano.

— Nnnnnn

2

Uau, eu realmente escrevi isso? Sim, isso está obviamente errado; deve ser algo parecido answer = !!(condition). O ponto que eu estava tentando enfatizar, é claro, é que você pode apenas return value%2==0e não precisa se preocupar com o condicional.

— AWM

Acho elegante: value%2===0

— carlodurso 26/03

17

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

— CloudyMarble
fonte

13

Preciso criar uma matriz muito grande que possua muitos números pares

Não. Use o módulo (%). Ele fornece o restante dos dois números que você está dividindo.

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.

Isso significa que, se você modificar qualquer número x por 2, receberá 0 ou 1 ou -1. 0 significaria que é par. Qualquer outra coisa significaria que é estranho.

— Isaac Fife
fonte

8

Isso pode ser resolvido com um pequeno trecho de código:

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

Espero que isto ajude :)

— s0d4pop
fonte

6

Como muitas linguagens, o Javascript possui um operador de módulo% , que encontra o restante da divisão. Se não houver resto após a divisão por 2, um número é par:

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

Esse é um idioma muito comum para testar números inteiros pares.

— pb2q
fonte

3

No entanto, o módulo pode ser complicado / indefinido para valores negativos. Consulte a especificação de idioma apropriada.

6

Com o bit a bit, codegolfing:

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

— Katia Punter
fonte

5

Uma função simples que você pode transmitir. Usa o operador modulo %:

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

is_even(3)
false
is_even(6)
true

— dgh
fonte

1

Se seus resultados no operador ternário são 'true' ou 'false', você realmente não precisa do operador ternário. Aqui, você poderia / deveria apenas fazer:return !(x % 2);

— dom_watson

4

Use minhas extensões:

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

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

então

var a=5; 
 a.isEven();

== False

 a.isOdd();

== Verdadeiro

se você não tiver certeza se é um número, teste-o pela seguinte ramificação:

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

ATUALIZAÇÃO:

se você não usaria a variável:

(5).isOdd()

Atuação :

Acontece que o paradigma processual é melhor que o paradigma OOP. A propósito, eu realizei a criação de perfis neste FIDDLE . No entanto, o modo POO ainda é mais bonito.

— Abdennour TOUMI
fonte

Valeu cara, por essa lógica, no entrevistado alguém perguntou esse tipo de lógica, não conseguiu responder, agora entendi, obrigado .. mas existe algum benefício no desempenho seguindo esse método? nós poderíamos ter escrito isEven (x); etc.

— Shoib Mohammed A

@ShoibMohammedA: A comparação foi feita! jsfiddle.net/abdennour/jL2uyksa/3

— Abdennour TOUMI

-1 não estende funções nativas de protótipo. ( stackoverflow.com/questions/14034180/… )

— tfmontague 28/05

3

Subtraia 2 a ele recursivamente até chegar a -1 ou 0 (funciona apenas para números inteiros positivos, obviamente) :)

— assimétrico
fonte

Com números negativos você em vez aumentar 2 a ele

— Hydroper

E leva um inferno de um tempo em que n = 2 ^ 52, e uma quantidade infinita para n> 2 ^ 53

— rioV8

3

Você pode usar uma instrução for e uma condicional para determinar se um número ou série de números é ímpar:

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

Isso imprimirá todos os números ímpares entre 1 e 5.

— cheekybastard
fonte

3

Acabei de executar este no Adobe Dreamweaver .. ele funciona perfeitamente. eu usei if (isNaN (mynmb))

para verificar se o valor fornecido é um número ou não, e também usei Math.abs (mynmb% 2) para converter número negativo em positivo e 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
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 {
}

Substitua X pelo seu número (pode vir de uma variável). A instrução If é executada quando o número é par e Else quando é ímpar.

Se você quer apenas saber se algum número é ímpar:

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

Mais uma vez, substitua X por um número ou variável.

— Gui Premonsa
fonte

2

Todo número ímpar, quando dividido por duas, deixa o restante como 1 e todo número par, quando dividido por zero, deixa o zero como restante. Portanto, podemos usar esse código

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

— Augustus Francis
fonte

2

Que tal agora...

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

    alert(aa[num % 2]);

— AndroidManifester
fonte

2

Foi o que eu fiz

//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 alguma razão, tive que garantir que o comprimento da matriz fosse menor em um. Quando não faço isso, fico "indefinido" no último elemento da matriz oddNumbers.

— Zakher Masri
fonte

2

Isso ocorre porque a condição é definida como menor ou igual a "<=" ao comprimento da matriz. Eu removi o sinal de igual e é o resultado foi o desejado.

— Zakher Masri

2

Quando você precisar testar se alguma variável é ímpar, primeiro teste se ela é inteira . Além disso, observe que, quando você calcula o restante no número negativo, o 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
}

Se Number.isInteger estiver disponível, você também poderá simplificar esse código para:

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

Nota: aqui, testamos em value % 2 !== 0vez de value % 2 === 1é por causa de -3 % 2 === -1. Se você não quiser -1passar neste teste, pode ser necessário alterar esta linha.

Aqui estão alguns casos de teste:

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

Usando % ajudará você a fazer isso ...

Você pode criar algumas funções para fazer isso por você ... Prefiro separar funções que não estão anexadas a Number em Javascript como este, que também verificam se você está passando número ou não:

Função estranha:

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

função par:

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

e chame assim:

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

Um revestimento no ES6 apenas porque é limpo.

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

— damdeez
fonte

2

Muitas pessoas entendem mal o significado de

isOdd("str")deve ser falso.
Somente um número inteiro pode ser ímpar.
isOdd(1.223)e isOdd(-1.223)deve ser falso.
Um flutuador não é um número inteiro.
isOdd(0)deve ser falso.
Zero é um número inteiro par ( https://en.wikipedia.org/wiki/Parity_of_zero ).
isOdd(-1)deve ser verdade.
É um número inteiro ímpar.

Solução

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 necessário): https://jsfiddle.net/9dzdv593/8/

1 liner

Solução Javascript de 1 liner. Para quem não se importa com legibilidade.

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

— tfmontague
fonte

Você pode acelerar a solução ainda. ou seja, nas declarações finais, você pode simplesmente retornar !! (n% 2), opcionalmente, fazê-lo funcionar com números assinados (ou seja, quando n% 2 retorna 0, é falso, mas quando -1 ou 1 retornou, isso seria retornar verdadeiro). Sua solução está retornando false para números ímpares, pois está verificando se o retorno do módulo é 0, mas deve verificar se há 1 e 1 falhará em números negativos; portanto, o retorno !! (n% 2) é mais seguro. De qualquer forma, {} (declaração de bloco) não causa problemas de minificação e não está presente na discussão.

— Hydroper

@ TheProHands - Obrigado pelas anotações. (1) A questão era que a versão do módulo apresentava um erro de digitação; deveria ter sido em (n % 2) !== 0vez de (n % 2) === 0. (2) O meu conselho é para evitar !!(n % 2), porque (a) tem desempenho mais lento que (n % 2) !== 0( jsperf.com/notnot-vs-strict-not ), (b) é um hack - que coage um valor Falsey 0em false, e (c) é obscuro (linguagens de programação de alto nível não devem ser como Pascal por causa do desempenho - esse é o trabalho do compilador). (3) Sim, as {}declarações de bloco ausentes resultam em vários problemas (conforme atualizado na minha resposta).

— Tfmontague

Eu nunca evito instruções de bloco porque me preocupo com a legibilidade, mas estou tentando dizer que a busca de instruções de bloco não resulta em problemas, apenas na manutenção do código. Ou seja, o uso de expressões de sequência mescladas com instrução de expressão em vez de instrução de bloco pode tornar o código ilegível e feio, ou seja if (0) call1(), assign = 0, call2(), mas uma única instrução não é ruim: if (0) return; if (0) ;; if (0); break; if (0) continue;e, de qualquer forma, prefiro continuar usando instruções de bloco de linha de quebra quando tiver condições em linha longa.

— Hydroper

verificações de tipo / nulos como o seu isNaN(n)são tolas - certeza de que cobriu o NaNcaso, mas isOdd(null), isOdd(undefined), isOdd({x:1})todo o retorno falseque eu considero ser um erro; a menos, claro, que você esteja apenas especificando que sua função tem comportamento correto em um determinado domínio: apenas entradas do tipo Number. Nesse caso, basta largar a isNaNverificação e forçar o usuário a chamá-la com o tipo correto. A programação defensiva é horrível. Em seguida, sua função é simplificada para isOdd = x => Math.floor(x) === x && x & 1 === 1- retornando explícito trueou falsevalores não são necessários

— Obrigado

null, undefinede objetos {}não são números inteiros ímpares e, portanto, a função retorna false- não sei por que você considera isso um erro. A isNaNverificação é para desempenho (não para defesa), permite que a função saia prematuramente sem executar as outras verificações.

— tfmontague 11/05/19

1

Eu implementaria isso para retornar um booleano:

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

Funcionará em números não assinados e assinados. Quando o módulo retornar -1ou 1será traduzido paratrue .

Solução sem 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
fonte

1

Uma abordagem mais funcional no 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

no ES6:

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

— Darryl Mendonez
fonte

3

Ao adicionar uma resposta a uma pergunta de oito anos com 26 respostas existentes, é realmente útil explicar que aspecto novo da pergunta sua resposta aborda e se a passagem do tempo e as novas versões afetam a resposta. Uma resposta apenas de código quase sempre pode ser aprimorada com a adição de algumas explicações e, nesse caso, alguns exemplos de chamadas que mostram o uso.

— Jason Aller

1

o título é 'Como determinar se um número é ímpar em JavaScript' e não houve solução ES6 postada para o que é solicitado.

— Darryl Mendonez 14/01

0

Usando o operador ternário, podemos encontrar os números pares ímpares:

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

Expandir snippet

— Mahendra Kulkarni
fonte

0

isso funciona para matrizes:

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

isso deve sair: 4,92 1,9,21,41

por apenas um número:

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

  return "odd";
}

console.log(evenOrOdd(4));

isso deve gerar até mesmo para o console

— JuicY_Burrito
fonte