Mesmo com aritmética exata, arredondar em lugares diferentes produz resultados diferentes. Três itens de R$ 0,35 com 10% de desconto: se o desconto é calculado no total, R$ 1,05 vezes 10% dá R$ 0,105, que vira R$ 0,11. Se é calculado por item, cada R$ 0,035 vira R$ 0,04, e o desconto total é R$ 0,12. Nenhum dos dois está errado. Errado é o sistema fazer de um jeito e o gateway, a nota fiscal ou o ERP fazerem de outro.
- Descubra a granularidade do documento de referência: a nota fiscal arredonda tributo por item, então o sistema também precisa arredondar por item e somar depois.
- Escolha o modo de arredondamento e escreva no código: metade para longe do zero é o que o Postgres faz em numeric e o que a maioria das regras fiscais espera; metade para o par reduz viés em somas grandes e aparece em regras bancárias.
- Arredonde uma vez, no fim de cada cálculo que gera valor cobrado. Valores intermediários, como preço por grama ou câmbio, ficam com mais casas e só viram centavo no último passo.
- Parcela e rateio não se dividem: se alocam. O total é fixo e as partes precisam somar exatamente o total.
O módulo abaixo resolve as três operações sem passar por float: converte string decimal para centavos em BigInt, multiplica e divide com o modo de arredondamento explícito e faz o rateio pelo método do maior resto. Ele usa só a biblioteca padrão e cabe no projeto sem dependência nova.
// money.js
// Valor monetário entra e sai como string decimal ("123.45") e vive como BigInt em centavos.
// Number nunca: um parseFloat no caminho reintroduz o erro de representação.
const DECIMAL_RE = /^(-)?(\d+)(?:\.(\d{1,2}))?$/;
export function toCents(value) {
if (typeof value !== 'string') {
throw new TypeError('valor monetário deve chegar como string, nunca como number');
}
const match = DECIMAL_RE.exec(value.trim());
if (!match) throw new RangeError(`valor monetário inválido: ${value}`);
const [, sign, units, fraction = ''] = match;
const cents = BigInt(units) * 100n + BigInt(fraction.padEnd(2, '0'));
return sign ? -cents : cents;
}
export function fromCents(cents) {
const negative = cents < 0n;
const abs = negative ? -cents : cents;
const fraction = (abs % 100n).toString().padStart(2, '0');
return `${negative ? '-' : ''}${abs / 100n}.${fraction}`;
}
// a * b / d com arredondamento explícito, sem passar por float.
// 'half-up': metade para longe do zero, igual a round(numeric) no Postgres.
// 'half-even': metade para o par (arredondamento bancário).
export function mulDiv(a, b, d, mode = 'half-up') {
if (d === 0n) throw new RangeError('divisão por zero');
const n = a * b;
const negative = (n < 0n) !== (d < 0n);
const absN = n < 0n ? -n : n;
const absD = d < 0n ? -d : d;
let q = absN / absD;
const twice = (absN % absD) * 2n;
if (mode === 'half-up' && twice >= absD) q += 1n;
if (mode === 'half-even' && (twice > absD || (twice === absD && q % 2n === 1n))) q += 1n;
return negative ? -q : q;
}
// Rateio pelo maior resto: a soma das partes é sempre igual ao total.
// Para estorno, rateie o valor absoluto e inverta o sinal.
export function allocate(totalCents, weights) {
if (totalCents < 0n) throw new RangeError('rateie o valor absoluto');
const totalWeight = weights.reduce((sum, w) => sum + w, 0n);
if (totalWeight <= 0n || weights.some((w) => w < 0n)) {
throw new RangeError('pesos precisam ser não negativos e somar mais que zero');
}
const shares = weights.map((w, index) => ({
index,
cents: (totalCents * w) / totalWeight,
remainder: (totalCents * w) % totalWeight,
}));
let leftover = totalCents - shares.reduce((sum, s) => sum + s.cents, 0n);
// Os centavos que sobraram vão para as partes com maior resto.
const byRemainder = [...shares].sort((a, b) =>
b.remainder === a.remainder ? a.index - b.index : b.remainder > a.remainder ? 1 : -1,
);
for (const share of byRemainder) {
if (leftover === 0n) break;
share.cents += 1n;
leftover -= 1n;
}
return shares.map((s) => s.cents);
}
// uso.js
import { allocate, fromCents, mulDiv, toCents } from './money.js';
// 10% de desconto sobre 3 itens de R$ 0,35 (R$ 1,05): 0,105 vira 11 centavos.
const subtotal = toCents('0.35') * 3n; // 105n
const desconto = mulDiv(subtotal, 10n, 100n); // 11n
// R$ 100,00 em 3 parcelas: soma 100,00, não 99,99.
const parcelas = allocate(toCents('100.00'), [1n, 1n, 1n]);
parcelas.map(fromCents); // ['33.34', '33.33', '33.33']
// Formatação só na borda, a partir da string exata.
const brl = new Intl.NumberFormat('pt-BR', { style: 'currency', currency: 'BRL' });
brl.format(fromCents(subtotal - desconto)); // 'R$ 0,94'
O rateio pelo maior resto é o que impede o R$ 99,99. Cada parte recebe o quociente inteiro, e os centavos que sobram são distribuídos, um a um, para as partes com maior resto, em ordem estável. Com pesos iguais, o centavo extra fica na primeira parcela; com pesos proporcionais, como o rateio de frete pelo valor de cada item, ele vai para quem perdeu mais no arredondamento. A propriedade que importa é testável: a soma das partes é sempre igual ao total.