Kiểm tra xem một giá trị là lẻ hay chẵn

Tôi quyết định tạo hàm isEven và isOdd đơn giản với thuật toán rất đơn giản:

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

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

Điều đó là ổn nếu n với một số tham số nhất định, nhưng thất bại trong nhiều tình huống. Vì vậy, tôi đã đặt ra để tạo ra các hàm mạnh mẽ mang lại kết quả chính xác cho nhiều kịch bản nhất có thể, để chỉ các số nguyên trong giới hạn của số javascript được kiểm tra, mọi thứ khác đều trả về sai (bao gồm cả + và - vô cùng). Lưu ý rằng số 0 là chẵn.

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

Bất cứ ai có thể nhìn thấy bất kỳ vấn đề với ở trên? Có phiên bản nào tốt hơn (tức là chính xác hơn, nhanh hơn hoặc ngắn gọn hơn mà không bị xáo trộn) không?

Có nhiều bài viết liên quan đến các ngôn ngữ khác, nhưng dường như tôi không thể tìm thấy phiên bản dứt khoát cho ECMAScript.

Sử dụng mô đun:

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

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

Bạn có thể kiểm tra xem mọi giá trị trong Javascript có thể bị ép buộc thành một số với:

Number.isFinite(parseFloat(n))

Kiểm tra này tốt nhất nên được thực hiện bên ngoài isEvenvà các isOddchức năng, vì vậy bạn không phải nhân đôi xử lý lỗi trong cả hai chức năng.

Tôi thích sử dụng một bài kiểm tra bit:

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

Điều này kiểm tra xem bit đầu tiên nằm trên đó biểu thị một số lẻ.

Làm thế nào về sau đây? Tôi chỉ thử nghiệm điều này trong IE, nhưng thật vui khi xử lý các chuỗi đại diện cho các số có độ dài bất kỳ, số thực là số nguyên hoặc số float và cả hai hàm đều trả về false khi truyền một boolean, không xác định, null, một mảng hoặc một đối tượng. (Tùy thuộc vào việc bạn muốn bỏ qua khoảng trống hàng đầu hay dấu kiểm khi chuỗi được truyền vào - Tôi đã giả sử rằng chúng không bị bỏ qua và khiến cả hai hàm trả về sai.)

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

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

Lưu ý: cũng có số âm.

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

Ở đâu

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

Tại sao không làm điều này:

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

Để hoàn thành bài kiểm tra bit của Robert Brisita.

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

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

Một sửa đổi / cải tiến đơn giản của câu trả lời Steve Mayne!

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

Lưu ý: Trả về false nếu không hợp lệ!

Chúng tôi chỉ cần một dòng mã cho việc này!

Đây là một cách mới hơn và thay thế để làm điều này, sử dụng cú pháp ES6 mới cho các hàm JS và cú pháp một dòng cho if-elselệnh gọi:

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

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

Một vài

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

Cách khác:

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

isEven(69)

Mặt khác sử dụng chuỗi vì tại sao không

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

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

Có lẽ điều này? if (ourNumber% 2! == 0)

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

Để kiểm tra xem bạn có số lẻ hay số chẵn hay không, điều này cũng hoạt động.

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

Sử dụng kiểu javascript hiện đại:

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)

Cái này đơn giản hơn!

  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}

khi 0 / thậm chí muốn nhưng

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

Hay nói, là một tài tài của, qua, qua, qua một tài khác, qua giữ, qua một tài khác

if (i % 2) {
return odd numbers
}

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