Как выполнить целочисленное деление и отдельно получить остаток в JavaScript?

ES6 представляет новый метод Math.trunc. Это позволяет исправить ответ @ MarkElliot, чтобы он работал и для отрицательных чисел:

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

Обратите внимание, что Math методы имеют преимущество перед побитовыми операторами в том, что они работают с числами, превышающими 2 ³¹.

Обычно я использую:

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

Наверное, не самый элегантный, но работает.

Вы можете использовать функцию parseInt, чтобы получить усеченный результат.

parseInt(a/b)

Чтобы получить остаток, используйте оператор мода:

a%b

parseInt имеет некоторые подводные камни со строками, чтобы избежать использования параметра radix с основанием 10

parseInt("09", 10)

В некоторых случаях строковое представление числа может быть научной записью, в этом случае parseInt выдаст неверный результат.

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

Результатом этого вызова будет 1.

Math.floor(operation) возвращает округленное в меньшую сторону значение операции.

Пример 1 ^st вопроса:

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

console.log(z);

Консоль:

15

Пример 2 ^nd вопроса:

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

console.log(x);

Консоль:

4

JavaScript вычисляет нижний предел отрицательных чисел и остаток нецелых чисел, следуя математическим определениям для них.

FLOOR определяется как «наибольшее целое число, меньшее, чем параметр», таким образом:

• положительные числа: FLOOR (X) = целая часть X;
• отрицательные числа: FLOOR (X) = целая часть X минус 1 (потому что она должна быть МЕНЬШЕ, чем параметр, т.е. более отрицательной!)

REMAINDER определяется как «остаток» от деления (евклидова арифметика). Когда делимое не является целым числом, частное обычно также не является целым числом, т. Е. Нет остатка, но если частное принудительно должно быть целым числом (и это то, что происходит, когда кто-то пытается получить остаток или модуль число с плавающей запятой), очевидно, останется нецелое число.

JavaScript действительно рассчитывает все, как ожидалось, поэтому программист должен быть осторожен, задавая правильные вопросы (и люди должны быть осторожны, чтобы отвечать на то, что задают!) Первый вопрос Ярина НЕ был «каково целочисленное деление X на Y», но, вместо этого "ВСЕ раз, когда данное целое число ВХОДИТ В другое". Для положительных чисел ответ одинаков для обоих, но не для отрицательных чисел, потому что целочисленное деление (делимое на делитель) будет на -1 меньше, чем количество раз, когда число (делитель) «переходит» в другое (делимое). Другими словами, FLOOR вернет правильный ответ при целочисленном делении отрицательного числа, но Ярин этого не спрашивал!

gammax ответил правильно, этот код работает так, как просил Ярин. С другой стороны, Самуэль ошибается, я думаю, он не занимался математикой, иначе он бы увидел, что это действительно работает (кроме того, он не сказал, что было делителем в его примере, но я надеюсь, что это было 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, остаток = -0,3800000000000079

Да, я заметил, там есть проблема с точностью, но у меня не было времени проверить это (я не знаю, проблема ли это в Firefox, Windows 7 или с FPU моего процессора). Однако на вопрос Ярина, который включает только целые числа, код gammax работает отлично.

Ответ Алекса Мур-Ниеми в качестве ответа:

Для рубистов из Google в поисках divmod вы можете реализовать это как таковое:

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

Результат:

// [2, 33]

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

есть также предложение, работающее над этим Модуль и дополнительная целочисленная математика

Если вы просто делите степень двойки, вы можете использовать побитовые операторы:

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];
}

(Первое - частное, второе - остаток)

Подсчитать количество страниц можно за один шаг: Math.ceil (x / y)

Вы можете использовать тернарность, чтобы решить, как обрабатывать положительные и отрицательные целые числа.

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

Если число положительное, все в порядке. Если число отрицательное, оно добавит 1 из-за того, как Math.floor обрабатывает негативы.

Это всегда будет усекаться до нуля. Не уверен, что уже слишком поздно, но вот оно:

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

Если вам нужно вычислить остаток для очень больших целых чисел, которые среда выполнения 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);
}

Вот способ сделать это. (Лично я бы не стал делать это таким образом, но подумал, что это интересный способ сделать это для примера)

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