Testen, ob ein Wert ungerade oder gerade ist

Ich habe beschlossen, einfache isEven- und isOdd- Funktionen mit einem sehr einfachen Algorithmus zu erstellen :

function isEven(n) {
  n = Number(n);
  return n === 0 || !!(n && !(n%2));
}

function isOdd(n) {
  return isEven(Number(n) + 1);
}

Das ist in Ordnung, wenn n bestimmte Parameter enthält, schlägt jedoch in vielen Szenarien fehl. Deshalb habe ich mich vorgenommen, robuste Funktionen zu erstellen, die für so viele Szenarien wie möglich korrekte Ergebnisse liefern, sodass nur Ganzzahlen innerhalb der Grenzen von Javascript-Zahlen getestet werden und alles andere false zurückgibt (einschließlich + und - unendlich). Beachten Sie, dass Null gerade ist.

// Returns true if:
//
//    n is an integer that is evenly divisible by 2
//
// Zero (+/-0) is even
// Returns false if n is not an integer, not even or NaN
// Guard against empty string

(function (global) {

  function basicTests(n) {

    // Deal with empty string
    if (n === '') 
      return false;

    // Convert n to Number (may set to NaN)
    n = Number(n);

    // Deal with NaN
    if (isNaN(n)) 
      return false;

    // Deal with infinity - 
    if (n === Number.NEGATIVE_INFINITY || n === Number.POSITIVE_INFINITY)
      return false;

    // Return n as a number
    return n;
  }

  function isEven(n) {

    // Do basic tests
    if (basicTests(n) === false)
      return false;

    // Convert to Number and proceed
    n = Number(n);

    // Return true/false
    return n === 0 || !!(n && !(n%2));
  }
  global.isEven = isEven;

  // Returns true if n is an integer and (n+1) is even
  // Returns false if n is not an integer or (n+1) is not even
  // Empty string evaluates to zero so returns false (zero is even)
  function isOdd(n) {

    // Do basic tests
    if (basicTests(n) === false)
      return false;

    // Return true/false
    return n === 0 || !!(n && (n%2));
  }
  global.isOdd = isOdd;

}(this));

Kann jemand irgendwelche Probleme mit den oben genannten sehen? Gibt es eine bessere (dh genauere, schnellere oder präzisere Version, ohne verschleiert zu werden) Version?

Es gibt verschiedene Beiträge zu anderen Sprachen, aber ich kann anscheinend keine endgültige Version für ECMAScript finden.

Modul verwenden:

function isEven(n) {
   return n % 2 == 0;
}

function isOdd(n) {
   return Math.abs(n % 2) == 1;
}

Sie können überprüfen, ob ein beliebiger Wert in Javascript zu einer Zahl gezwungen werden kann mit:

Number.isFinite(parseFloat(n))

Diese Überprüfung sollte vorzugsweise außerhalb der Funktionen isEvenund durchgeführt isOddwerden, damit Sie die Fehlerbehandlung nicht in beiden Funktionen duplizieren müssen.

Ich bevorzuge einen kleinen Test:

if(i & 1)
{
    // ODD
}
else
{
    // EVEN
}

Dies testet, ob das erste Bit aktiviert ist, das eine ungerade Zahl anzeigt.

Wie wäre es mit folgendem? Ich habe dies nur im IE getestet, aber es war ziemlich glücklich, Zeichenfolgen zu verarbeiten, die Zahlen beliebiger Länge darstellen, tatsächliche Zahlen, die Ganzzahlen oder Gleitkommazahlen sind, und beide Funktionen haben false zurückgegeben, wenn ein Boolescher Wert, ein undefinierter Wert, ein Array oder ein Objekt übergeben wurde. (Es liegt an Ihnen, ob Sie führende oder nachfolgende Leerzeichen ignorieren möchten, wenn eine Zeichenfolge übergeben wird. Ich habe angenommen, dass sie nicht ignoriert werden und beide Funktionen false zurückgeben.)

function isEven(n) {
   return /^-?\d*[02468]$/.test(n);
}

function isOdd(n) {
   return /^-?\d*[13579]$/.test(n);
}

Hinweis: Es gibt auch negative Zahlen.

function isOddInteger(n)
{
   return isInteger(n) && (n % 2 !== 0);
}

wo

function isInteger(n)
{
   return n === parseInt(n, 10);
}

Warum nicht einfach so machen:

    function oddOrEven(num){
        if(num % 2 == 0)
            return "even";
        return "odd";
    }
    oddOrEven(num);

Um den Bittest von Robert Brisita abzuschließen.

if ( ~i & 1 ) {
    // Even
}

var isEven = function(number) {
    // Your code goes here!
    if (number % 2 == 0){
       return(true);
    }
    else{
       return(false);    
    }
};

Eine einfache Modifikation / Verbesserung der Antwort von Steve Mayne!

function isEvenOrOdd(n){
    if(n === parseFloat(n)){
        return isNumber(n) && (n % 2 == 0);
    }
    return false;
}

Hinweis: Gibt bei Ungültigkeit false zurück!

Wir brauchen dafür nur eine Codezeile!

Hier eine neuere und alternative Möglichkeit, dies mithilfe der neuen ES6- Syntax für JS-Funktionen und der einzeiligen Syntax für den if-elseAnweisungsaufruf zu tun :

const isEven = num => ((num % 2) == 0) ? true : false;

alert(isEven(8));  //true
alert(isEven(9));  //false
alert(isEven(-8)); //true

Ein paar

x % 2 == 0; // Check if even

!(x & 1); // bitmask the value with 1 then invert.

((x >> 1) << 1) == x; // divide value by 2 then multiply again and check against original value

~x&1; // flip the bits and bitmask

Anders:

var isEven = function(number) {
  // Your code goes here!
  if (((number/2) - Math.floor(number/2)) === 0) {return true;} else {return false;};
};

isEven(69)

Ansonsten mit Strings, weil warum nicht

function isEven(__num){
    return String(__num/2).indexOf('.') === -1;
}

if (testNum == 0);
else if (testNum % 2  == 0);
else if ((testNum % 2) != 0 );

Vielleicht das? if (ourNumber% 2! == 0)

var num = someNumber
    isEven;
parseInt(num/2) === num/2 ? isEven = true : isEven = false;

Dies funktioniert auch, um zu testen, ob Sie eine ungerade oder eine gerade Zahl haben.

const comapare = x => integer(checkNumber(x));

function checkNumber (x) {
   if (x % 2 == 0) {
       return true;
   } 
   else if (x % 2 != 0) {
       return false;
    }
}

function integer (x) {
   if (x) {
       console.log('even');
   } 
   else {
       console.log('odd');
    }
}

Verwendung des modernen Javascript-Stils:

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

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

Dieser ist einfacher!

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

  alert(aa[num % 2]);

function isEven(n) {return parseInt(n)%2===0?true:parseInt(n)===0?true:false}

wenn 0 / wollte aber doch

isEven(0) //true
isEven(1) //false
isEven(2) //true
isEven(142856) //true
isEven(142856.142857)//true
isEven(142857.1457)//false

.

if (i % 2) {
return odd numbers
}

if (i % 2 - 1) {
return even numbers
}