JavaScript % (modulo) 给出负数的负数结果

Question

根据Google Calculator(-13) % 64是51。

根据 Javascript（参见 JSBin），它是 -13。

我该如何解决这个问题？

Answer 1

Number.prototype.mod = function (n) {
  return ((this % n) + n) % n;
};

摘自这篇文章：The JavaScript Modulo Bug

Answer 2

一个“mod”函数返回一个肯定的结果。

var mod = function (n, m) {
    var remain = n % m;
    return Math.floor(remain >= 0 ? remain : remain + m);
};
mod(5,22)   // 5
mod(25,22)  // 3
mod(-1,22)  // 21
mod(-2,22)  // 20
mod(0,22)   // 0
mod(-1,22)  // 21
mod(-21,22) // 1

当然还有

mod(-13,64) // 51

Answer 3

使用Number.prototype 很慢，因为每次使用原型方法时，您的号码都会被包裹在Object 中。而不是这个：

Number.prototype.mod = function(n) {
  return ((this % n) + n) % n;
}

用途：

function mod(n, m) {
  return ((n % m) + m) % m;
}

见：http://jsperf.com/negative-modulo/2

比使用原型快 97%。如果性能对您当然很重要..

Answer 4

这不是错误，有 3 个函数来计算模数，你可以使用适合你需要的一个（我建议使用欧几里德函数）

截断小数部分函数

console.log(  41 %  7 ); //  6
console.log( -41 %  7 ); // -6
console.log( -41 % -7 ); // -6
console.log(  41 % -7 ); //  6

整数部分函数

Number.prototype.mod = function(n) {
    return ((this%n)+n)%n;
};

console.log( parseInt( 41).mod( 7) ); //  6
console.log( parseInt(-41).mod( 7) ); //  1
console.log( parseInt(-41).mod(-7) ); // -6
console.log( parseInt( 41).mod(-7) ); // -1

欧几里得函数

Number.prototype.mod = function(n) {
    var m = ((this%n)+n)%n;
    return m < 0 ? m + Math.abs(n) : m;
};

console.log( parseInt( 41).mod( 7) ); // 6
console.log( parseInt(-41).mod( 7) ); // 1
console.log( parseInt(-41).mod(-7) ); // 1
console.log( parseInt( 41).mod(-7) ); // 6

Answer 5

如果x 是整数且n 是2 的幂，则可以使用x & (n - 1) 代替x % n。

> -13 & (64 - 1)
51 

Answer 6

有一个 NPM 包可以为您完成这项工作。您可以使用以下命令安装它。

npm install just-modulo --save

从自述文件中复制的用法

import modulo from 'just-modulo';

modulo(7, 5); // 2
modulo(17, 23); // 17
modulo(16.2, 3.8); // 17
modulo(5.8, 3.4); //2.4
modulo(4, 0); // 4
modulo(-7, 5); // 3
modulo(-2, 15); // 13
modulo(-5.8, 3.4); // 1
modulo(12, -1); // NaN
modulo(-3, -8); // NaN
modulo(12, 'apple'); // NaN
modulo('bee', 9); // NaN
modulo(null, undefined); // NaN

GitHub 存储库可以通过以下链接找到：

https://github.com/angus-c/just/tree/master/packages/number-modulo

Answer 7

我也处理负a和负n

 //best perf, hard to read
   function modul3(a,n){
        r = a/n | 0 ;
        if(a < 0){ 
            r += n < 0 ? 1 : -1
        }
        return a - n * r 
    }
    // shorter code
    function modul(a,n){
        return  a%n + (a < 0 && Math.abs(n)); 
    }

    //beetween perf and small code
    function modul(a,n){
        return a - n * Math[n > 0 ? 'floor' : 'ceil'](a/n); 
    }

Answer 8

因此，如果您尝试调整度数（如果您有 -50 度 - 200 度），您可能希望使用类似：

function modrad(m) {
    return ((((180+m) % 360) + 360) % 360)-180;
}

Answer 9

接受的答案让我有点紧张，因为它重复使用了 % 运算符。如果 Javascript 将来改变行为怎么办？

这是一个不重复使用 % 的解决方法：

function mod(a, n) {
    return a - (n * Math.floor(a/n));
}

mod(1,64); // 1
mod(63,64); // 63
mod(64,64); // 0
mod(65,64); // 1
mod(0,64); // 0
mod(-1,64); // 63
mod(-13,64); // 51
mod(-63,64); // 1
mod(-64,64); // 0
mod(-65,64); // 63

Answer 10

JavaScript 中的% 运算符是余数运算符，而不是模运算符（主要区别在于如何处理负数）：

-1 % 8 // -1, not 7

Answer 11

虽然它的行为不像您预期​​的那样，但这并不意味着 JavaScript 没有“行为”。这是 JavaScript 为其模计算所做的选择。因为，根据定义，任何一个答案都是有意义的。

参见来自维基百科的this。您可以在右侧看到不同的语言如何选择结果的符号。