Целочисленное разделение с остатком в JavaScript?

В JavaScript, как мне получить:

  • целое число раз заданное целое число переходит в другое?
  • остаток?
+616
источник поделиться
14 ответов

Для некоторого числа y и некоторого divisor x вычислите коэффициент (quotient) и остаток (remainder) как:

var quotient = Math.floor(y/x);
var remainder = y % x;
+817
источник

Я не разбираюсь в побитовых операторах, но вот еще один способ получить целое число:

var num = ~~(a / b);

Это будет нормально работать и для отрицательных чисел, а Math.floor() - в неправильном направлении.

Это тоже кажется правильным:

var num = (a / b) >> 0;
+273
источник
другие ответы

Связанные вопросы


Похожие вопросы

Я сделал некоторые тесты скорости в 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

Вышеуказанное основано на 10 миллионах проб для каждого.

Вывод: Используйте (a/b>>0) (или (~~(a/b)) или (a/b|0)) для достижения эффективности в 20%. Также имейте в виду, что все они не соответствуют Math.floor, когда a/b<0 && a%b!=0.

+125
источник

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

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

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

+76
источник
var remainder = x % y;
return (x - remainder) / y;
+19
источник

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

parseInt(a/b)

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

a%b

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

parseInt("09", 10)

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

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

Этот вызов приведет к результату 1.

+10
источник

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

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

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

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

JavaScript вычисляет все так, как ожидалось, поэтому программист должен быть осторожен, чтобы задавать правильные вопросы (и люди должны быть осторожны, чтобы ответить на то, что задано!) Первый вопрос Ярина был НЕ "что такое целочисленное деление X на Y", но вместо этого "WHOLE количество раз заданное целое число GOES INTO another". Для положительных чисел ответ один и тот же для обоих, но не для отрицательных чисел, потому что целочисленное деление (дивиденд на делитель) будет -1 меньше, чем число (делитель) "переходит в другое" (дивиденд). Другими словами, FLOOR вернет правильный ответ для целочисленного деления отрицательного числа, но Ярин не спросил об этом!

gammax правильно ответил, этот код работает по заданию Ярина. С другой стороны, Самуил ошибается, он не делал математики, я думаю, или он бы видел, что это действительно работает (также он не сказал, что было делителем его примера, но я надеюсь, что это было 3):

Остаток = X% Y = -100% 3 = -1

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

Кстати, я протестировал код на Firefox 27.0.1, он работал как ожидалось, с положительными и отрицательными числами, а также с нецелыми значениями, как для дивидендов, так и для делителей. Пример:

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

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

+4
источник

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

+4
источник

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

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

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

0
источник

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

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
    };
}
0
источник

Обычно я использую (a - a % b) / b. Это, вероятно, не самый элегантный, но он работает.

0
источник

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

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

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

Результат:

// [2, 33]
0
источник

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

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

(Первое - это частное, второе - остальное)

0
источник

Вычисление количества страниц может быть выполнено за один шаг: Math.ceil(х/у)

0
источник

Посмотрите другие вопросы по меткам или Задайте вопрос