saber - Cómo determinar si un número es impar en JavaScript
numeros pares html (26)
¿Tengo que hacer una matriz realmente grande que tenga muchos números pares?
Oh Dios, no. Use 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.
¿Alguien puede indicarme algún código para determinar si un número en JavaScript es par o impar?
Al usar un operador ternario, podemos encontrar los números impares pares:
var num = 2;
result = (num % 2 == 0) ? ''even'' : ''odd''
console.log(result);
¡Advertencia! Revisé todas las demás respuestas y no son correctas.
Solo un entero puede ser impar.
-
isOdd("someString")debe ser falso.
Una cadena no es un número entero. -
isOdd(1.223)eisOdd(-1.223)deben ser falsos.
Un flotador no es un número entero. -
isOdd(0)debe ser falso.
Zero es un entero par ( https://en.wikipedia.org/wiki/Parity_of_zero ). -
isOdd(-1)debe ser verdadero.
Es un entero impar.
Mi 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/
Razonamiento que entró en el código
- El tipo de devolución debe ser booleano. Las palabras clave
trueofalseson nativas, por lo que no es necesario devolver cadenas, 0 o 1, que tienen significados ambiguos. - La convención de Javascript es usar camel-case
isOdd - Una instrucción
ifdebe tener llaves{}. La falta de llaves puede generar problemas de minificación, una compilación de Javascript más lenta e ilegibilidad del código si se produce un problema de formato.
Acabo de ejecutar este en Adobe Dreamweaver ... funciona perfectamente. utilicé if (isNaN (mynmb))
para verificar si el Valor dado es un número o no, y también utilicé 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>
Al igual que muchos idiomas, Javascript tiene un operador de módulo % , que encuentra el resto de la división. Si no hay residuo 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)
Esta es una expresión muy común para probar incluso enteros.
Aquí hay un ejemplo de trabajo simple:
function myFunction() {
userInput = document.getElementById("myValue").value;
if (userInput%2 == 0) {
document.getElementById("demo").innerHTML= "even";
} else {
document.getElementById("demo").innerHTML = "odd";
}
Input:<input id="myValue">
<button onclick="myFunction()">Try it</button>
Cada número impar cuando está dividido por dos deja el resto como 1 y cada número par cuando se divide por cero deja un cero como resto. Por lo tanto, podemos usar este código
function checker(number) {
return number%2==0?even:odd;
}
Con bitwise, codegolfing:
var isEven=n=>(n&1)?"odd":"even";
Cuando necesite probar si alguna variable es impar, primero debe probar si es un número entero . Además, observe que cuando calcule el resto en el 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 el value % 2 !== 0 lugar del value % 2 === 1 es a causa de -3 % 2 === -1 . Si no quiere -1 pase esta prueba, puede necesitar 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
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 menos de uno. Cuando no hago eso, me pongo "indefinido" en el último elemento de la matriz oddNumbers.
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 :)
Implementaré esto para devolver un booleano:
function isOdd (n) {
return !!(n % 2);
// or ((n % 2) !== 0).
}
Funcionará con números firmados y sin firmar. Cuando el módulo devuelva -1 o 1 , se traducirá a true .
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;
}
Podrías hacer algo como esto:
function isEven(value){
if (value%2 == 0)
return true;
else
return false;
}
Puede usar una instrucción for y una 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.
Qué tal esto...
var num = 3 //instead get your value here
var aa = ["Even", "Odd"];
alert(aa[num % 2]);
Resta 2 de forma recursiva hasta llegar a -1 o 0 (solo funciona para enteros positivos, obviamente) :)
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)
Una función simple que puedes pasar. Utiliza el operador de módulo% y el operador ternario?
var is_even = function(x) {
return !(x % 2);
}
is_even(3)
false
is_even(6)
true
Usa mis extensiones:
Number.prototype.isEven=function(){
return this % 2===0;
};
Number.prototype.isOdd=function(){
return !this.isEven();
}
entonces
var a=5;
a.isEven();
== False
a.isOdd();
== Verdadero
si no está seguro de si es un número, pruébelo con la siguiente bifurcación:
if(a.isOdd){
a.isOdd();
}
ACTUALIZAR:
si no usarías la variable:
(5).isOdd()
Actuación :
Resulta que el paradigma procedimental es mejor que el paradigma OOP. Por cierto, realicé perfiles en esta FIDDLE . Sin embargo, la forma de OOP es aún más bonita.
Usar % te ayudará a hacer esto ...
Puede crear un par de funciones para que lo haga por usted ... Prefiero funciones separadas que no están asociadas al número en Javascript como este, que también verifica si está pasando el 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
Use el operador AND bit a bit.
function oddOrEven(x) {
return ( x & 1 ) ? "odd" : "even";
}
Si no desea un valor de retorno de cadena, sino uno booleano, use esto:
var isOdd = function(x) { return x & 1; };
var isEven = function(x) { return !( x & 1 ); };
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));
1 representa un número impar, mientras que 0 representa un número par.
var sumSoFar = 0;
var oddnumber=0;
function Sum(data){
for(var i=0;i<data.length;i++){
if(data[i] % 2 == 1){
console.log(data[i]);
sumSoFar += data[i];
}else{
oddnumber+= data[i];
} }
console.log(sumSoFar);
console.log(oddnumber);
}
var sumOfNum=Sum([3,2,4,5,4,3,3,4,3,6,4]);
<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>
function isEven(x) { return (x%2)==0; }
function isOdd(x) { return !isEven(x); }
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 un número dado es impar:
if (X % 2 !== 0){
}
Nuevamente, reemplace X con un número o variable.