js数字计算精度

Ⅰ 关于js中小数运算丢失精度的处理办法

浮点数值的最高精度是17位小数，但在进行运算的毁基时候其精确度却远远不如整数；整数在进行运算的时候都会转成10进制； 而java和JavaScript中计算小数运算时，都会先将十进制的小数换算到对应的二进制，一部分散高小数并不能完整的换算为二进制，这里就出现了第一次的误差。待小数都换算为二进制后，再进行二进制间的运算，得到二进制结果。然后再将二进制结果换算为十进制，这里通常会出现第二次的误差。

所以(0.1+0.2)!=03

解决这种问题，可以将小数变成整数进行运算，然后再将结果变为小数。

//乘法

function multiNum (a,b){

  var c = 0,

d = a.toString(),

e = b.toString();

try {

      c += d.split(".")[1].length;

} catch (f) { }

  try {

      c += e.split(".")[1].length;

} catch (f) { }

  return Number(d.replace(".","")) * Number(e.replace(".","")) / Math.pow(10,c);

}

//除法

function divide (a,b){

  var c,d,e = 0,

f = 0;

try {

      e = a.toString().split(".")[1].length;

} catch (g) { }

  try {

     冲余尺 f = b.toString().split(".")[1].length;

} catch (g) { }

  return c = Number(a.toString().replace(".","")),d = Number(b.toString().replace(".","")),this.mul(c / d,Math.pow(10,f - e));

}

//加法

function addNum (a,b){

  var c,d,e;

try {

      c = a.toString().split(".")[1].length;

} catch (f) {

      c = 0;

}

  try {

      d = b.toString().split(".")[1].length;

} catch (f) {

      d = 0;

}

  return e = Math.pow(10,Math.max(c,d)),(multiNum(a,e) + multiNum(b,e)) / e;

}

//减法

function subNum (a,b) {

  var c,d,e;

try {

      c = a.toString().split(".")[1].length;

} catch (f) {

      c = 0;

}

  try {

      d = b.toString().split(".")[1].length;

} catch (f) {

      d = 0;

}

  return e = Math.pow(10,Math.max(c,d)),(multiNum(a,e) - multiNum(b,e)) / e;

}

Ⅱ JavaScript为什么浮点数会丢失精度

JS浮点计算问题

问题

用js进行浮点数计算，结果可能会“超出预期”，大部分计算结果还是对的，但是我们可不想在计算这么严谨的事情上还有意外的惊喜。比如：

• 0.3 + 0.6 = 0.8999999999999999

• 0.3 - 0.2 = 0.09999999999999998

• 0.3 * 1.5 = 0.44999999999999996

• 0.3 / 0.1 = 2.9999999999999996

看完这几个计算结果，如果你没用过js，你可能会有点崩溃。我只能说，这就是js的魅力所在。

分析

在这之前，你需要知道以下几点：

• js中数字类型只有Number；

• js的Number是IEEE 754标准的64-bits的双精度数值

网上有很多关于此问题的解释，由于计算机是用二进制来存储和处理数字，不能精确表示浮点数，而js中没有相应的封装类来处理浮点数运算，直接计算会导致运算精度丢失。其实高级语言（c#，java）也存在此问题，只不过它们自己内部做了处理，把这种精度差异给屏蔽掉了。有些小数转换为二进制位数是无穷的（有循环），但是64位中小数最多只有52位，因此对于位数超过的相当于被截取了，导致了精度的丢失。这个地址可以用来浮点数和IEEE 754标准的64-bits的互转（背后是二进制的转换），用这个我们来验证下0.3-0.2。

• 0.3转换后为0.

• 0.2转换后为0.

• 0.-0.=0.

这和js直接计算的结果0.09999999999999998想吻合。

分析下来，终于明白并不是js自身发育不良，只是没有及时补充营养，我们只能另想出路了。

以上是网上找的

我以前遇到过问题2中浏览器计算的结果 是两种,所以和浏览器也有问题

Ⅲ js 双精度浮点数

一、怎样将一个数据转成浮点数   https://www.hu.com/question/21711083

二、js 的 Number

在 JavaScript 中整数和浮点数都属于 Number 数据类型，所有数字都是以 64 位浮点数形式储存，即便整数也是如此。

三、造成哪些问题？

1、小数计算精度丢失，比如 0.1+0.2 不等于 0.3

2、整数最大范围

整数是按最大54位来算最大(253 - 1，Number.MAX_SAFE_INTEGER,9007199254740991) 和最小(-(253 - 1)，Number.MIN_SAFE_INTEGER,-9007199254740991) 安全整数范围的。所以只要超过这个范围，就会存在被舍去的精度问题。

四、解决办法

开源的库、bigInt、

0.1+0.2-0.3     // 5.551115123125783e-17

5.551115123125783e-17.toFixed(20)      //脊颤   '0.00000000000000005551'

5.551115123125783e-17<Number.EPSILON*Math.pow(2,2)    // true

重新整理

https://zhuanlan.hu.com/p/73699947

回顾一个基础问题，js 中的精度丢失问题。

一、在 js 中只有双精度浮点数来存储的Number，数据存储会有三个步骤：1、十进制转二进制 2、二进制转科学技术法 3、按 IEEE754 标准存储。 

二、双精度浮点一共有 64位，64位比特又可分为三个部分：森轮

符号位S：第 1 位是正负数符号位（sign），0代表正数，1代表负数

指数位E：中间的 11 位存储指数（exponent），用来表示次方数

尾数位M：最后的 52 位是尾数（mantissa），超出的部分自动进一樱春败舍零

三、基于以上知识，在数据小数位在进行转换二进制时，会出现无线循环的情况，而数据转成 IEEE754标准时又仅支持 52 位，所以要发生一个数据截断，也就是精度丢失。

四、常见的丢失场景，

 0.1 + 0.2 === 0.30000000000000004

parseInt(0.58*100,10)=57

(1.335).toFixed(2)

四、解决办法

math.js

bignumber.js

等库以及 es6 针对整数精度丢失的新数据类型BigInt 

Ⅳ js对于计算浮点数据不准确怎么处理

一种就是加ROUND呀。如何不行了？ 另一种是：工具－选项－重新计算，勾选“以显示精度为准”。 如果你能描述详细些，就会找到问题出在哪里。

Ⅳ js小数加减为什么会失精

JavaScript的数字使用的是浮点数，浮点数可以表示的数的个数有限（只有很少一部分数可以表示），其他的数在浮点书里面不存在
其他语言同样有这个问题，只是在语言层面做了处理，开发者可能不需要考虑精度问题，但JavaScript语言并没有对结果进行底层处理，所以就会有问题
提示：js的加减乘除等计算都有问题

Ⅵ js浮点数的加减乘除解决方案

一直知道js的浮点数计算是不精确的， 0.1 + 0.2 !== 0.3，但是也就知道而已，解决方法却不怎么注意盯桐，所以刚做一个项目，尽管了解浮点数精度不精确的问题，但是还是掉坑里了。在此再次默默告诉自己要警惕，端正心态，不可掉以轻心！！！所以下面就分享一些加减乘除的方法。

原理： 把数字转换成字符串，然后从小数点部分切割成两部分，分别算出两个因数的小数点右边的长度，然后用两个因数的小数点右边长度最大的数再乘以10，相当于两个都放大了n倍，然后相加，然后缩小n倍。
注意，这里的放大用了乘法times函数（下面介绍），因为浮点数直接乘以100有可能出现精度不够的情况，如下图

原理和加法一样，放大n倍后相减再缩小n倍

乘法原理稍微变点，放大倍数n是 ‘两个小数点后面长度之和’ 而不是 ‘两个小数点后面长度这两者之间的最大值’

除法原理和乘法一样

这也是一个坑，比如你要保留两位小数，四舍五入的话就要看小数点第三位后面的数字来决定，如2.445四舍五入后就是2.45； 2.444四舍五入就是2.44；做这个需物磨求的时候，我第一反应是Math.toFixed(2)，结果是bug百出啊，这里就不举例了，有兴趣可以自己尝试。然后我是怎么解决的呢？网络了一下，也是得到一些半成品不严谨的函数，原理也很简单，先放大倍数，然后利用Math.round()取整

以上加减乘除方法基本满足一般业务需求了，尤其是电商。但是如果数字计算时超出了 2的1024次方减1 ，也就是 9007199254740992 这个数字的话就不适合了，因为从 2^1024 开始就变成了 Infinity。凯蚂坦

Ⅶ 如何使用javascript编写一个计算器

首先，由于JS的存在数值的精度误差问题：

0.1+0.2 //0.30000000000000004
0.3-0.1 //0.19999999999999998

所以在编写计算器是应首先解决计算精度问题，以下四个代码段分别是js中精确的加减乘除运算函数

//浮点数加法运算
function floatAdd(arg1,arg2){
var r1,r2,m;
try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2));
return (arg1*m+arg2*m)/m
}

//浮点数减法运算
function floatSub(arg1,arg2){
var r1,r2,m,n;
try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2));
//动态控制精度长度
n=(r1>=r2)?r1:r2;
return ((arg1*m-arg2*m)/m).toFixed(n);
}

//浮点数乘法运算
function floatMul(arg1,arg2){
var m=0,s1=arg1.toString(),s2=arg2.toString();
try{m+=s1.split(".")[1].length}catch(e){}
try{m+=s2.split(".")[1].length}catch(e){}
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
}

//浮点数除法运算
function floatDiv(arg1,arg2) {
var t1 = 0, t2 = 0, r1, r2;
try {t1 = arg1.toString().split(".")[1].length} catch (e) {}
try {t2 = arg2.toString().split(".")[1].length} catch (e) {}
with (Math) {
r1 = Number(arg1.toString().replace(".", ""));
r2 = Number(arg2.toString().replace(".", ""));
return (r1 / r2) * pow(10, t2 - t1);
}
}

以下是详细的计算器代码：
HTML5

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>简单计算器</title>
<link href="main.css" rel="stylesheet">
</head>
<body>
<div id="calculator">

<div id="calculator_container">
<h3>计算器</h3>
<table id="calculator_table">
<tbody>
<tr>
<td colspan="5">
<input type="text" id="resultIpt" readonly="readonly" value="" size="17" maxlength="17" style="width:294px;color: black">
</td>
</tr>
<tr>
<td><input type="button" value="←" class="btn_color1 btn_operation"></td>
<td><input type="button" value="全清" class="btn_color1 btn_operation"></td>
<td><input type="button" value="清屏" class="btn_color1"></td>
<td><input type="button" value="﹢/﹣" class="btn_color2 btn_operation"></td>
<td><input type="button" value="1/×" class="btn_color2 btn_operation"></td>
</tr>
<tr>
<td><input type="button" value="7" class="btn_color3 btn_number"></td>
<td><input type="button" value="8" class="btn_color3 btn_number"></td>
<td><input type="button" value="9" class="btn_color3 btn_number"></td>
<td><input type="button" value="÷" class="btn_color4 btn_operation"></td>
<td><input type="button" value="％" class="btn_color2 btn_operation"></td>
</tr>
<tr>
<td><input type="button" value="4" class="btn_color3 btn_number"></td>
<td><input type="button" value="5" class="btn_color3 btn_number"></td>
<td><input type="button" value="6" class="btn_color3 btn_number"></td>
<td><input type="button" value="×" class="btn_color4 btn_operation"></td>
<td><input type="button" value="√" class="btn_color2 btn_operation"></td>
</tr>
<tr>
<td><input type="button" value="1" class="btn_color3 btn_number"></td>
<td><input type="button" value="2" class="btn_color3 btn_number"></td>
<td><input type="button" value="3" class="btn_color3 btn_number"></td>
<td><input type="button" value="－" class="btn_color4 btn_operation"></td>
<td rowspan="2">
<input type="button" value="＝" class="btn_color2" style="height: 82px" id="simpleEqu">
</td>
</tr>
<tr>
<td colspan="2">
<input type="button" value="0" class="btn_color3 btn_number" style="width:112px">
</td>
<td><input type="button" value="." class="btn_color3 btn_number" ></td>
<td><input type="button" value="＋" class="btn_color4 btn_operation"></td>
</tr>
</tbody>
</table>

</div>
</div>
<script type="text/javascript" src="calculator.js"></script>
</body>
</html>

CSS3

* {
margin: 0;
padding: 0;
}
#calculator{
position: relative;
margin: 50px auto;
width: 350px;
height: 400px;
border: 1px solid gray;
-webkit-border-radius: 10px;
-moz-border-radius: 10px;
border-radius: 10px;
-webkit-box-shadow: 2px 2px 4px gray;
-moz-box-shadow: 2px 2px 4px gray;
box-shadow: 2px 2px 4px gray;
behavior:url("ie-css3.htc"); /*IE8-*/
}
#calculator_table{
position: relative;
margin: 10px auto;
border-collapse:separate;
border-spacing:10px 20px;
}
h3{
position: relative;
width: 60px;
height: 30px;
margin: 0 auto;
}
#calculator_table td{
width: 50px;
height: 30px;
border: 1px solid gray;
-webkit-border-radius: 2px;
-moz-border-radius: 2px;
border-radius: 2px;
behavior:url("ie-css3.htc"); /*IE8-*/
}
#calculator_table td input{
font-size: 16px;
border: none;
width: 50px;
height: 30px;
color: white;
}
input.btn_color1{
background-color: orange;
}
input.btn_color2{
background-color: #133645;
}
input.btn_color3{
background-color: #59807d;
}
input.btn_color4{
background-color: seagreen;
}
input:active{
-webkit-box-shadow: 3px 3px 3px gray;
-moz-box-shadow: 3px 3px 3px gray;
box-shadow: 3px 3px 3px gray;
behavior:url("ie-css3.htc"); /*IE8-*/
}

JS

window.onload=function() {
var resultIpt = document.getElementById("resultIpt"); //获取输出文本框
var btns_number = document.getElementsByClassName("btn_number"); //获取数字输入按钮
var btns_operation = document.getElementsByClassName("btn_operation"); //获取操作按钮
var simpleEqu = document.getElementById("simpleEqu"); //获取"="按钮
var temp = "";
var num1= 0,num2=0;
//获取第一个数
for(var i=0;i<btns_number.length;i++){
btns_number[i].onclick=function (){
temp += this.value;
resultIpt.value = temp;
};
}
//对获取到的数进行操作
for(var j=0;j<btns_operation.length;j++) {
btns_operation[j].onclick = function () {
num1=parseFloat(resultIpt.value);
oper = this.value;
if(oper=="1/×"){
num1 = Math.pow(num1,-1); //取倒数
resultIpt.value = num1.toString();
}else if(oper=="﹢/﹣"){ //取相反数
num1 = -num1;
resultIpt.value = num1.toString();
}else if(oper=="√"){ //取平方根
num1 =Math.sqrt(num1);
resultIpt.value = num1.toString();
}else if(oper=="←"){ //删除个位
resultIpt.value = resultIpt.value.substring(0, resultIpt.value.length - 1);

}else if(oper=="全清"){ //清除数字
resultIpt.value = "";
}
else{ //oper=="＋" "－" "×" "÷" "％"时，继续输入第二数字
temp = "";
resultIpt.value = temp;
}
}
}
//输出结果
simpleEqu.onclick=function(){
num2=parseFloat(temp); //取得第二个数字
calculate(num1, num2, oper);
resultIpt.value = result.toString();
}
};

//定义一个计算函数
function calculate(num1, num2, oper) {
switch (oper) {
case "＋":
result=floatAdd(num1, num2); //求和
break;
case "－":
result=floatSub(num1, num2); //求差
break;
case "×":
result=floatMul(num1, num2); //求积
break;
case "÷":
result=floatDiv(num1, num2); //求商
break;
case "％":
result=num1%num2; //求余数
break;
}
}

//精确计算
//浮点数加法运算
function floatAdd(arg1,arg2){
var r1,r2,m;
try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2));
return (arg1*m+arg2*m)/m
}
//浮点数减法运算
function floatSub(arg1,arg2){
var r1,r2,m,n;
try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2));
//动态控制精度长度
n=(r1>=r2)?r1:r2;
return ((arg1*m-arg2*m)/m).toFixed(n);
}
//浮点数乘法运算
function floatMul(arg1,arg2){
var m=0,s1=arg1.toString(),s2=arg2.toString();
try{m+=s1.split(".")[1].length}catch(e){}
try{m+=s2.split(".")[1].length}catch(e){}
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
}
//浮点数除法运算
function floatDiv(arg1,arg2) {
var t1 = 0, t2 = 0, r1, r2;
try {t1 = arg1.toString().split(".")[1].length} catch (e) {}
try {t2 = arg2.toString().split(".")[1].length} catch (e) {}
with (Math) {
r1 = Number(arg1.toString().replace(".", ""));
r2 = Number(arg2.toString().replace(".", ""));
return (r1 / r2) * pow(10, t2 - t1);
}
}