如何在 JavaScript 中执行整数除法并分别获取余数

Question

在 JavaScript 中，如何获取：

1. 给定整数进入另一个整数的总次数？
2. 剩下的呢？

Answer 1

对于某些数字 y 和某些除数 x 计算商 (quotient)^[1] 和余数 ( >余数）为：

const quotient = Math.floor(y/x);
const remainder = y % x;

示例：

const quotient = Math.floor(13/3); // => 4 => the times 3 fits into 13  
const remainder = 13 % 3;          // => 1

---

[1] 一个数除以另一个数所得的整数

Answer 2

我不是按位运算符方面的专家，但这里有另一种获取整数的方法：

var num = ~~(a / b);

这对于负数也适用，而 Math.floor() 将以错误的方向舍入。

这似乎也是正确的：

var num = (a / b) >> 0;

注意：仅使用 ~~ 作为 Math.trunc() 当您确信输入范围在 32 位范围内时整数。

Answer 3

我在 Firefox 上做了一些速度测试。

-100/3             // -33.33..., 0.3663 millisec
Math.floor(-100/3) // -34,       0.5016 millisec
~~(-100/3)         // -33,       0.3619 millisec
(-100/3>>0)        // -33,       0.3632 millisec
(-100/3|0)         // -33,       0.3856 millisec
(-100-(-100%3))/3  // -33,       0.3591 millisec

/* a=-100, b=3 */
a/b                // -33.33..., 0.4863 millisec
Math.floor(a/b)    // -34,       0.6019 millisec
~~(a/b)            // -33,       0.5148 millisec
(a/b>>0)           // -33,       0.5048 millisec
(a/b|0)            // -33,       0.5078 millisec
(a-(a%b))/b        // -33,       0.6649 millisec

以上均基于 1000 万次试验。

结论：使用(a/b>>0)（或(~~(a/b))或(a /b|0)) 实现约 20% 的效率提升。另请记住，当 a/b<0 && 时，它们都与 Math.floor 不一致。 a%b!=0。

Answer 4

ES6 引入了新的 Math.trunc< /code> 方法。这允许修复@MarkElliot的答案，使其也适用于负数：

var div = Math.trunc(y/x);
var rem = y % x;

请注意数学与按位运算符相比，方法的优势在于它们可以处理超过 2³¹ 的数字。

Answer 5

我通常使用：

const quotient =  (a - a % b) / b;
const remainder = a % b;

它可能不是最优雅的，但它有效。

Answer 6

var remainder = x % y;
return (x - remainder) / y;

Answer 7

您可以使用函数parseInt来获取截断的结果。

parseInt(a/b)

要获得余数，请使用 mod 运算符：

a%b

parseInt 对于字符串有一些陷阱，要避免使用基数为 10 的基数参数

parseInt("09", 10)

在某些情况下，数字的字符串表示形式可能是科学记数法，在这种情况下，parseInt 将产生错误的结果。

parseInt(100000000000000000000000000000000, 10) // 1e+32

该调用将产生 1 作为结果。

Answer 8

Math.floor(operation) 返回运算的向下舍入值。

第一个^第问题示例：

const x = 5;
const y = 10.4;
const z = Math.floor(x + y);

console.log(z);

第二个问题示例：

const x = 14;
const y = 5;
const z = Math.floor(x % y);

console.log(x);

Answer 9

我们可以使用下面的方法。

quotient = dividend / divisor | 0;

以及我们可以通过模运算符获得提醒的任何方式

remainder = dividend % divisor;

Answer 10

使用：

const idivmod = (a, b) => [a/b |0, a%b];

还有一个正在研究的提案：
模数和附加整数数学

Answer 11

JavaScript 按照负数的下限和非整数的余数计算它们的数学定义。

FLOOR被定义为“小于参数的最大整数”，因此：

• 正数：FLOOR(X)=X的整数部分；
• 负数：FLOOR(X)=X 的整数部分减 1（因为它必须比参数小，即负数更大！）

REMAINDER 定义为除法的“剩余部分”（欧几里得算术）。当被除数不是整数时，商通常也不是整数，即没有余数，但如果强制商为整数（这就是当有人试图获取余数或模数时会发生的情况）浮点数），显然会有一个非整数“剩余”。

JavaScript 确实会按预期计算所有内容，因此程序员必须小心提出正确的问题（人们应该小心回答所问的问题！）Yarin 的第一个问题不是“X 除以 Y 的整数除法是什么”，而是，相反，“给定整数进入另一个整数的全部次数”。对于正数，两者的答案相同，但对于负数则不同，因为整数除法（除以除数）将比一个数字（除数）“进入”另一个数字（被除数）的时间小 -1。换句话说，FLOOR 将返回负数整数除法的正确答案，但 Yarin 没有问这个！

gammax 回答正确，该代码按照 Yarin 的要求工作。另一方面，塞缪尔错了，我猜他没有做数学，否则他会发现它确实有效（而且，他没有说他的例子的除数是什么，但我希望它是3):

余数 = X % Y = -100 % 3 = -1

GoesInto = (X - 余数) / Y = (-100 - -1) / 3 = -99 / 3 = -33

顺便说一句，我测试了在 Firefox 27.0.1 上运行代码，它按预期工作，对于正数和负数以及非整数值（对于股息和除数）。示例：

-100.34 / 3.57: GoesInto = -28, Remainder = -0.3800000000000079

是的，我注意到，那里有一个精度问题，但我没有时间检查它（我不知道这是否是 Firefox 的问题） 、Windows 7 或使用我的 CPU 的 FPU）。不过，对于 Yarin 的问题（仅涉及整数），gammax 的代码运行得很好。

Answer 12

原始函数 div（计算除法的商）和 mod（计算余数）有多种可能的定义 的除法）满足以下约束：

• Number.isInteger(div(x, y));
• x === div(x, y) * y + mod(x, y);
• Math.abs((mod(x, y)) 。

计算机科学文献和编程语言中常用的定义基于

• 截断除法，也满足 mod(x, y) * x >= 0：

  函数 div(x, y) {
    返回 Math.trunc(x / y);
  }
  
  函数 mod(x, y) {
    返回x%y；
  }
  

• 地板除法，也满足满足 mod(x, y) * y >= 0:

  函数 div(x, y) {
    返回 Math.floor(x / y);
  }
  
  函数 mod(x, y) {
    返回 ((x % y) + y) % y;
  }
  

• 欧几里得除法，也满足满足 mod(x, y) >= 0:

  函数 div(x, y) {
    return Math.sign(y) * Math.floor(x / Math.abs(y));
  }
  
  函数 mod(x, y) {
    const z = Math.abs(y);
    返回 ((x % z) + z) % z;
  }
  

因此，

• 如果 x >= 0 且 >y> 0，则截断除法、落地除法和欧几里得除法一致；
• 如果 x >= 0 且 y 0，则截断除法和欧氏除法一致；
• 如果 x <= 0 且 y > 0，则落地除法和欧几里得除法一致；
• 如果 x <= 0 且 y < 0，则截断除法和地板除法一致。

根据论文'函数 div 和 mod 的欧几里得定义' 作者：Raymond Boute：

在本文中，我们阐明了各种定义之间的差异，特别是 Knuth 定义的基于截断除法（T 定义）和基于下限除法（F 定义）的定义。我们还提出了另一个定义，我们将其称为欧几里得，因为它基于欧几里得定理（E 定义）。这种替代方案在文献中很少讨论，但经过仔细分析，无论是在理论上还是在实际应用中，它在规律性和有用的数学特性方面都是有利的。在我们经历过需要 div-mod 函数对的各种代表性应用领域中，欧几里得定义通常是最直接的选择。

Answer 13

Alex Moore-Niemi 的评论作为答案：

对于 Rubyists，请在 Google 中搜索 divmod，你可以这样实现它：

function divmod(x, y) {
  var div = Math.trunc(x/y);
  var rem = x % y;
  return [div, rem];
}

结果：

// [2, 33]

Answer 14

如果您需要计算非常大的整数的余数，而 JS 运行时无法这样表示（任何大于 2^32 的整数都表示为浮点数，因此会丢失精度），您需要采取一些技巧。

这对于检查我们日常生活中许多情况下出现的许多校验数字尤其重要（银行帐号，信用卡......）

首先，您需要将您的号码作为字符串（否则您已经失去了精度其余的没有意义）。

str = '123456789123456789123456789'

现在，您需要将字符串拆分为更小的部分，足够小，以便任何剩余部分和一段字符串的串联可以容纳 9 位数字。

digits = 9 - String(divisor).length

准备一个正则表达式来分割字符串

splitter = new RegExp(`.{1,${digits}}(?=(.{${digits}})+$)`, 'g')

例如，如果 digits 为 7，则正则表达式为

/.{1,7}(?=(.{7})+$)/g

它匹配最大长度为 7 的非空子字符串，其后面是 ((?=...) 是正向前瞻），字符数是 7 的倍数。“g”是使表达式遍历所有字符串，而不是在第一次匹配时停止。

现在将每个部分转换为整数，并通过 reduce 计算余数（添加回之前的余数 - 或 0 - 乘以 10 的正确幂）：

reducer = (rem, piece) => (rem * Math.pow(10, digits) + piece) % divisor

由于“减法”余数算法，这将起作用：

n mod d = (n - kd) mod d

它允许用余数替换数字十进制表示的任何“初始部分”，而不影响最终余数。

最终代码如下所示：

function remainder(num, div) {
  const digits = 9 - String(div).length;
  const splitter = new RegExp(`.{1,${digits}}(?=(.{${digits}})+$)`, 'g');
  const mult = Math.pow(10, digits);
  const reducer = (rem, piece) => (rem * mult + piece) % div;

  return str.match(splitter).map(Number).reduce(reducer, 0);
}

Answer 15

如果您只是除以 2 的幂，则可以使用按位运算符：（

export function divideBy2(num) {
  return [num >> 1, num & 1];
}

export function divideBy4(num) {
  return [num >> 2, num & 3];
}

export function divideBy8(num) {
  return [num >> 3, num & 7];
}

第一个是商，第二个是余数）

Answer 16

function integerDivison(dividend, divisor) {

    this.Division = dividend/divisor;
    this.Quotient = Math.floor(dividend/divisor);
    this.Remainder = dividend%divisor;
    this.calculate = () => {
        return {Value:this.Division, Quotient:this.Quotient, Remainder:this.Remainder};
    }
}

var divide = new integerDivison(5, 2);
console.log(divide.Quotient)     // To get the quotient of two values
console.log(divide.division)     // To get the floating division of two values
console.log(divide.Remainder)    // To get the remainder of two values
console.log(divide.calculate())  // To get the object containing all the values

Answer 17

如果您需要一些愚蠢的大数字的商，您可以使用：

Math.trunc((x/y) + (Number.EPSILON * (2 ** Math.ceil(Math.log2(Math.abs(x/y))))) * Math.sign(x/y))

注意：这只适用于x和y值的情况，即被除数和除数，即使经过任何舍入以使它们大于Number.MAX_SAFE_INTEGER时也可以作为整数工作，也能准确表示。

例如，如果我们有：

x = 45000000000000000000000000000 = 4.5e+28
y =   500000000000000000000000000 =   5e+26

那么本页给出的答案将为您提供：

89.99999999999999: x/y
90: Math.trunc((x/y) + (Number.EPSILON * (2 ** Math.ceil(Math.log2(Math.abs(x/y))))) * Math.sign(x/y))
89: Math.floor(x/y)
89: ~~(x/y)
89: (x/y)>>0
89: x/y|0
89: (x-(x%y))/y

正确答案是 90，因此，如您所见，我上面给出的方程是唯一提供正确答案的方程回答。

该方程也适用于负结果。如果我们将 x 设为负数，那么我们会得到：

-89.99999999999999: x/y
-90: Math.trunc((x/y) + (Number.EPSILON * (2 ** Math.ceil(Math.log2(Math.abs(x/y))))) * Math.sign(x/y))
-90: Math.floor(x/y)
-89: ~~(x/y)
-89: (x/y)>>0
-89: x/y|0
-89: (x-(x%y))/y

只有该方程和 Math.floor() 才能给出正确答案。

并且，只是为了确认一些给出稍大值的不同值：

x = -45000000000000000000000000 = -4.5e+25
y =    500000000000000000000000 =    5e+23

我们得到：

-90.00000000000001: x/y
-90: Math.trunc((x/y) + (Number.EPSILON * (2 ** Math.ceil(Math.log2(Math.abs(x/y))))) * Math.sign(x/y))
-91: Math.floor(x/y)
-90: ~~(x/y)
-90: (x/y)>>0
-90: x/y|0
-90.00000000000001: (x-(x%y))/y

在这种情况下，Math.floor()和(x-(x%y))/y 失败，这意味着，虽然它可能不快或不漂亮，这个答案给出的代码是在所有情况下给出正确结果的唯一方法， 前提是除数和被除数是能够准确地表示出来。 （或者，至少是我所知道的所有情况。）

如果您想知道如何获得大数的正确余数，请参阅：

• JavaScript 中大数的除法和求余
• JavaScript 中的模 - 大数

附录：如果您只处理正数，那么您可以将其缩短为这样:

Math.trunc((x/y) + (Number.EPSILON * (2 ** Math.ceil(Math.log2(x/y)))))

Answer 18

您还可以使用三元运算符来决定如何处理正整数值和负整数值。

var myInt = (y > 0) ? Math.floor(y/x) : Math.floor(y/x) + 1

如果该数字是正数，则一切正常。如果数字是负数，则会加 1，因为 Math.floor 处理负数的方式。

Answer 19

这将始终截断为零。

function intdiv(dividend, divisor) {
    divisor = divisor - divisor % 1;
    if (divisor == 0) throw new Error("division by zero");
    dividend = dividend - dividend % 1;
    var rem = dividend % divisor;
    return {
        remainder: rem,
        quotient: (dividend - rem) / divisor
    };
}

Answer 20

计算页数可以一步完成：

Math.ceil(x/y)

Answer 21

这是一种方法来做到这一点。 （我个人不会这样做，但我认为这是一种有趣的示例方式。）前面的答案中提到的方法肯定更好，因为这调用了多个函数，因此速度较慢，并且会占用更多空间。

function intDivide(numerator, denominator) {
  return parseInt((numerator/denominator).toString().split(".")[0]);
}

let x = intDivide(4,5);
let y = intDivide(5,5);
let z = intDivide(6,5);
console.log(x);
console.log(y);
console.log(z);