1. Calcule com js
12,32 * 7 Qual é o resultado? Resposta: 86,24000000000001
Por que esse problema ocorre? Como resolver isso?
Existe um bug em js ao lidar com multiplicação e divisão de decimais. A solução pode ser: converter decimais em inteiros para processamento.
O cálculo acima pode ser alterado para:
12,32*100*7/100
O resultado é: 86,24, correto.
Faça também alguns cálculos:
8,80*100*12/100
Resultado: 105,60000000000002
Problemas semelhantes ocorrerão com 38,80.
Precisão aumentada em 10 vezes:
8,80*1000*12/1000
Resultado: 105,6
É normal.
16,40 * 1.000.000 * 6/1.000.000
Também há um problema com o resultado
Para tornar a execução do js mais precisa, no futuro cálculo decimal do js, expanda diretamente o valor em 10.000 vezes e depois divida-o por 10.000 para resolver o problema.
varnum = 38,80;
var num2 = 13;
alerta(num * 10000 * 12/10000);
O número a ser multiplicado e dividido foi testado e considerado 10.000. Se for menor, alguns números causarão problemas. Se for maior (1.000.000), alguns números também causarão problemas.
dois,
Copie o código do código da seguinte forma:
<adiamento de script>
Número.prototype.rate=function(){
varoStr=this.toString();
if(oStr.indexOf(".")==-1)
retorno1;
outro
returnMath.pow(10,parseInt(oStr.length-oStr.indexOf(".")-1));
}
functiontran(){
args=tran.argumentos;
vartemp=1;
for(i=0;i<args.comprimento;i++)
temp*=args[i]*args[i].rate();
for(i=0;i<args.comprimento;i++)
temp/=args[i].taxa();
temperatura de retorno
}
alerta(tran(11,22.9));
</script>
Esta solução é um pouco mais complicada, mas dá uma ideia do processo real de resolução deste problema.
Copie o código do código da seguinte forma:
//Função de divisão, usada para obter resultados de divisão precisos
//Nota: O resultado da divisão do JavaScript terá erros, que serão mais óbvios ao dividir dois números de ponto flutuante. Esta função retorna um resultado de divisão mais preciso.
//Chamada: accDiv(arg1,arg2)
//Valor de retorno: o resultado exato da divisão de arg1 por arg2
função accDiv(arg1,arg2){
var t1=0,t2=0,r1,r2;
tente{t1=arg1.toString().split(".")[1].length}catch(e){}
tente{t2=arg2.toString().split(".")[1].length}catch(e){}
com(Matemática){
r1=Número(arg1.toString().replace(".",""))
r2=Número(arg2.toString().replace(".",""))
retornar (r1/r2)*pow(10,t2-t1);
}
}
//Adicione um método div ao tipo Number para tornar a chamada mais conveniente.
Número.prototype.div = função (arg){
return accDiv(este, arg);
}
//Função de multiplicação, usada para obter resultados de multiplicação precisos
//Nota: O resultado da multiplicação do JavaScript terá erros, que serão mais óbvios quando dois números de ponto flutuante forem multiplicados. Esta função retorna um resultado de multiplicação mais preciso.
//Chamada: accMul(arg1,arg2)
//Valor de retorno: o resultado exato da multiplicação de arg1 por arg2
função accMul(arg1,arg2)
{
var m=0,s1=arg1.toString(),s2=arg2.toString();
tente{m+=s1.split(".")[1].length}catch(e){}
tente{m+=s2.split(".")[1].length}catch(e){}
retornar Número(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
}
// Adicione um método mul ao tipo Number para tornar a chamada mais conveniente.
Número.prototype.mul = função (arg){
return accMul(arg, este);
}
//Função de adição, usada para obter resultados de adição precisos
//Nota: O resultado da adição do JavaScript terá erros, que serão mais óbvios ao adicionar dois números de ponto flutuante. Esta função retorna um resultado de adição mais preciso.
//Chama: accAdd(arg1,arg2)
// Valor de retorno: o resultado exato de arg1 mais arg2
função accAdd(arg1,arg2){
var r1,r2,m;
tente{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
tente{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2))
retornar (arg1*m+arg2*m)/m
}
//Adicione um método add ao tipo Number para tornar a chamada mais conveniente.
Número.prototype.add = função (arg){
return accAdd(arg,este);
}