【JavaScript】数值精度与数值范围

最新推荐文章于 2024-04-17 12:21:50 发布
最新推荐文章于 2024-04-17 12:21:50 发布
阅读量3.2k 收藏 6
点赞数 2
分类专栏： JavaScript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45389633/article/details/108462073
版权

本篇文章为整合文，相关原文传送：

另附一篇个人觉得比本篇写的更详细的文章

文章目录

一、整数与浮点数

JavaScript 内的数字没有 int(整数型) 与 float(浮点型) 之分，即 1 与 1.0 相同，为同一个数。
JavaScript 内所有数字都是浮点数，若遇到需要整数才能运算的情况，JavaScript 会自行将64位浮点数转成32位整数，再进行运算，而这个转换过程，便导致了精度丢失。

0.1 + 0.2
// 0.30000000000000004

0.1 + 0.7
// 0.7999999999999999

0.3 / 0.1
// 2.9999999999999996

(0.3 - 0.2) === (0.2 - 0.1)
// false

1. 浮点数的64个二进制位

根据国际标准 IEEE 754，JavaScript 采用双精度存储（double precision），占用 64 bit。从最左边开始，是这样组成的：
在这里插入图片描述

  • 第1位：符号位，0表示正数，1表示负数
  • 第2位到第12位（共11位）：指数部分
  • 第13位到第64位（共52位）：小数部分（即有效数字、尾数）

2. 二进制表示浮点数

计算机的二进制实现和位数限制有些数无法有限表示。就像一些无理数不能有限表示，如 圆周率 3.1415926…，1.3333… 等。

比如：

  • 浮点数 >> 二进制
0.1 >> 0.0001 1001 1001 1001…（1001无限循环）
//Number(0.1).toString(2) === "0.0001100110011001100110011001100110011001100110011001101"

0.2 >> 0.0011 0011 0011 0011…（0011无限循环）
//Number(0.2).toString(2) === "0.001100110011001100110011001100110011001100110011001101"

此时只能模仿十进制进行四舍五入了，但是二进制只有 0 和 1 两个，于是变为 0 舍 1 入。这即是计算机中部分浮点数运算时出现误差，丢失精度的根本原因。

可以知道，看似有穷的数字, 在计算机的二进制表示里却是无穷的，由于存储位数限制因此存在“舍去”，精度丢失就发生了。

3. 二进制表示整数

整数的精度丢失和浮点数本质上是一样的，尾数位最大是 52 位。

  • 整数 >> 二进制
9007199254740992     >> 10000000000000...000 // 共计 53 个 0

9007199254740992 + 1 >> 10000000000000...001 // 中间 52 个 0
// 9007199254740992 + 1 = 9007199254740993

9007199254740992 + 2 >> 10000000000000...010 // 中间 51 个 0
// 9007199254740992 + 2 = 9007199254740994

实际上：

9007199254740992 + 1 >> 10000000000000...000 // 【丢失】
// 9007199254740992 + 1 = 9007199254740992 【丢失】

4. 解决精度丢失

对于整数，前端出现问题的几率可能比较低，毕竟很少有业务需要需要用到超大整数，只要运算结果不超过 Math.pow(2, 53) 就不会丢失精度。

但对于小数，前端出现问题的几率还是很多的，尤其在一些电商网站涉及到金额等数据。

所以最主要的，还是解决浮点数精度丢失带来的问题。点击下滑到解决方案👈👈👈


二、整数

1. 整数精度

精度最多只能到53个二进制位，这意味着，绝对值 小于 253 的整数，即 (-253, 253) 【开区间，不含】内的整数，都可以精确表示。

Math.pow(2, 53)
// 9007199254740992【未丢失】

Math.pow(2, 53) + 1
// 9007199254740992【丢失】

Math.pow(2, 53) + 2
// 9007199254740994【未丢失】

Math.pow(2, 53) + 3
// 9007199254740996【丢失】

Math.pow(2, 53) + 4
// 9007199254740996【未丢失】

// etc...

由于 253 是一个16位的十进制数值，所以简单的法则就是，JavaScript 对15位的十进制数都可以精确处理。

2. 安全整数

一个安全整数是一个符合下面条件的整数：

  • 可以准确地表示为一个 IEEE-754 双精度数字,
  • 其 IEEE-754 表示不能是舍入任何其他整数以适应IEEE-754表示的结果。

比如，253 - 1 是一个安全整数，它能被精确表示，在任何 IEEE-754 舍入模式（rounding mode）下，没有其他整数舍入结果为该整数。作为对比，253 就不是一个安全整数，它能够使用 IEEE-754 表示，但是 253 + 1 不能使用 IEEE-754 直接表示，在就近舍入（round-to-nearest）和向零舍入中，会被舍入为 253。

// 即：由于在 js 中，Math.pow(2, 53) 存在与它相等的另一个值 "Math.pow(2, 53) + 1"，并不安全。所以不属于安全整数。

Math.pow(2, 53) === 9007199254740992	// 未丢失

Math.pow(2, 53) + 1 === 9007199254740992	// 丢失

安全整数范围为 “-(253 - 1)” 到 “253 - 1” 之间的整数，包含 -(253 - 1) 和 253 - 1。

利用 isSafeInteger() 方法来判断一个值是否为安全整数：（IE 不兼容）

Number.isSafeInteger(3);                    // true
Number.isSafeInteger(Math.pow(2, 53))       // false
Number.isSafeInteger(Math.pow(2, 53) - 1)   // true
Number.isSafeInteger(NaN);                  // false
Number.isSafeInteger(Infinity);             // false
Number.isSafeInteger("3");                  // false
Number.isSafeInteger(3.1);                  // false
Number.isSafeInteger(3.0);                  // true

3. 返回最小、最大安全整数

【注意：IE 不支持 MIN_SAFE_INTEGER 和 MAX_SAFE_INTEGER，这两个常量是 ES6 引入的，在此之前只能作为事实标准。】

Number.MIN_SAFE_INTEGER 常量，表示在 JavaScript中最小的安全整数 “-(253 - 1)”。值为 -9007199254740991。
Number.MAX_SAFE_INTEGER 常量，表示在 JavaScript 中最大的安全整数 “253 - 1”。值为 9007199254740991。

Number.MIN_SAFE_INTEGER === -(Math.pow(2, 53) - 1);
// true

Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1;
// true

三、可表示的数值范围

根据 IEEE 754 标准，64位浮点数的指数部分的长度是11个二进制位，意味着指数部分的最大值是2047（211-1 = 2047）。分出一半表示正数，一半表示负数，则 JavaScript 能够表示的数值范围为 (21024, 2-1023) 【开区间，不含】，超出这个范围的数无法表示。

1. 正向溢出与负向溢出

  • 【正向溢出】如果一个数大于等于 21024，那么就会发生 “正向溢出”，即 JavaScript 无法表示这么大的数，这时就会返回Infinity。
  • 【负向溢出】如果一个数小于等于 2-1075（指数部分最小值-1023，再加上小数部分的52位），那么就会发生为 “负向溢出”，即 JavaScript 无法表示这么小的数，这时会直接返回0。
// 正向溢出
Math.pow(2, 1024) // Infinity【正数数值非常大，无法表示，正向溢出，只能返回正无穷】

// 负向溢出
Math.pow(2, -1075) // 0【正数数值非常小，无法表示，负向溢出，返回 0】

2. 利用 Number 对象返回具体最大值和最小值

  • MAX_VALUE，JavaScript 里最接近 1.79E+308 的值，大于 MAX_VALUE 的值代表 “Infinity”。
  • MIN_VALUE，JavaScript 里最接近 0 的正值，而不是最小的负值。
Number.MAX_VALUE // 1.7976931348623157e+308
// 正数最接近正无穷的值，再大就会返回正无穷

Number.MIN_VALUE // 5e-324
// 正数最接近零的值，再小就会返回 0


Number.MAX_VALUE < Math.pow(2, 1024)
// true
Number.MAX_VALUE > Math.pow(2, 1024)
// false

Number.MIN_VALUE > Math.pow(2, -1075)
// true
Number.MIN_VALUE < Math.pow(2, -1075)
// false

MAX_VALUE 比 Math.pow(2, 1024) 更具体些。值可以等于 MAX_VALUE 而不会返回 “Infinity”，但等于 Math.pow(2, 1024) 则会返回 “Infinity”。
MIN_VALUE 比 Math.pow(2, -1075) 更具体些。值可以等于 MIN_VALUE 而不会返回 “0”，但等于 Math.pow(2, -1075) 则会返回 “0”。

示例：

// 当两数乘积小于或等于 MAX_VALUE 时，调用 func1()，否则调用 func2();
if (num1 * num2 <= Number.MAX_VALUE) {
	// 在可正常表示范围内
	func1();
} else {
	// 正向溢出，返回 Infinity
	func2();
}

// 当两个数相除大于或等于 MIN_VALUE 时，调用 func1()，否则调用 func2();
if (num1 / num2 >= Number.MIN_VALUE) {
	// 在可正常表示范围内
	func1();
} else {
	// 负向溢出，返回 0
	func2();
}

3. 注意

Number.MAX_VALUE + 1 !== Infinity

IEEE 754 标准规定：只有大于等于 1.7976931348623158e+308 的数才会被 round 到 “Infinity”。而 Number.MAX_VALUE 才 1.7976931348623157e+308，加上 1 还远远不到 Infinity。

这个数比 Number.MAX_VALUE 大 (254 - 1) * 2970 - (253 - 1) * 2971 = 2970。

但 IEEE754 能表示的精度有限，事实上有无数个 2970 附近的数被表示成了 2970，更准确的说，应该是：

要让 Number.MAX_VALUE 变成 “Infinity”，至少要加上一个被 IEEE754 四舍五入为 2970 的数。
在这里插入图片描述


四、浮点数精度的修复

ECMA 给出的解决方法是：将浮点数分别乘 10n 转为整数，再除以 10n。但却并不怎么实用。
比如：((0.01 * 100) + (0.02 * 100)) / 100 === 0.03;

以下是我在网络上找到的比较好的两个解决方案。
【注意：转换后的整数依然不能超过 9007199254740992。】

1. 方案一

// 来源：https://www.cnblogs.com/snandy/p/4943138.html

/**
 * floatObj 包含加减乘除四个方法，能确保浮点数运算不丢失精度
 *
 * 我们知道计算机编程语言里浮点数计算会存在精度丢失问题（或称舍入误差），其根本原因是二进制和实现位数限制有些数无法有限表示
 * 以下是十进制小数对应的二进制表示
 *      0.1 >> 0.0001 1001 1001 1001…（1001无限循环）
 *      0.2 >> 0.0011 0011 0011 0011…（0011无限循环）
 * 计算机里每种数据类型的存储是一个有限宽度，比如 JavaScript 使用 64 位存储数字类型，因此超出的会舍去。舍去的部分就是精度丢失的部分。
 *
 * ** method **
 *  add / subtract / multiply /divide
 *
 * ** explame **
 *  0.1 + 0.2 == 0.30000000000000004 （多了 0.00000000000004）
 *  0.2 + 0.4 == 0.6000000000000001  （多了 0.0000000000001）
 *  19.9 * 100 == 1989.9999999999998 （少了 0.0000000000002）
 *
 * floatObj.add(0.1, 0.2) >> 0.3
 * floatObj.multiply(19.9, 100) >> 1990
 *
 */
var floatObj = function() {
    
    /*
     * 判断obj是否为一个整数
     */
    function isInteger(obj) {
        return Math.floor(obj) === obj
    }
    
    /*
     * 将一个浮点数转成整数，返回整数和倍数。如 3.14 >> 314，倍数是 100
     * @param floatNum {number} 小数
     * @return {object}
     *   {times:100, num: 314}
     */
    function toInteger(floatNum) {
        // 初始化对象, times：10 的次方，num：去除小数点后返回的整数
        var ret = {times: 1, num: 0};
        var isNegative = floatNum < 0;
        // 若该浮点数是整数，则直接返回
        if (isInteger(floatNum)) {
            ret.num = floatNum;
            return ret;
        }
        // 转为字符串类型，再检测小数点
        var strfi  = floatNum + '';
        var dotPos = strfi.indexOf('.');
        // 提取小数点后的数字，并获取长度，作为 10 的幂
        var len    = strfi.substr(dotPos+1).length;
        // 浮点数转为整数后的倍数（几个小数位就几个次方）
        var times  = Math.pow(10, len)
        // 获取整数绝对值，parseInt() 方法不会对小数点及后面的数字进行转换，而加 0.5 是为了进行四舍五入
        var intNum = parseInt(Math.abs(floatNum) * times + 0.5, 10);
        // 浮点数为负数
        if (isNegative) {
            intNum = -intNum;
        }
        // 对象赋值
        ret.times  = times;
        ret.num = intNum;
        // 返回对象
        return ret;
    }
    
    /*
     * 核心方法，实现加减乘除运算，确保不丢失精度
     * 思路：把小数放大为整数（乘），进行算术运算，再缩小为小数（除）
     *
     * @param a {number} 运算数1
     * @param b {number} 运算数2
     * @param digits {number} 精度，保留的小数点数，比如 2, 即保留为两位小数
     * @param op {string} 运算类型，有加减乘除（add/subtract/multiply/divide）
     *
     */
    function operation(a, b, digits, op) {
        // 将浮点数转为整数，返回对象
        var o1 = toInteger(a);
        var o2 = toInteger(b);
        // 获取转换后的整数与小数位
        var n1 = o1.num;
        var n2 = o2.num;
        var t1 = o1.times;
        var t2 = o2.times;
        // 判断两个小数位大小
        var max = t1 > t2 ? t1 : t2;
        // 初始化变量
        var result = null;
        switch (op) {
            // 加
            case 'add':
                if (t1 === t2) { // 两个小数位数相同
                    result = n1 + n2;
                } else if (t1 > t2) { // o1 小数位 大于 o2
                    result = n1 + n2 * (t1 / t2);
                } else { // o1 小数位 小于 o2
                    result = n1 * (t2 / t1) + n2;
                }
                return result / max;
            // 减
            case 'subtract':
                if (t1 === t2) {
                    result = n1 - n2;
                } else if (t1 > t2) {
                    result = n1 - n2 * (t1 / t2);
                } else {
                    result = n1 * (t2 / t1) - n2;
                }
                return result / max;
            // 乘
            case 'multiply':
                result = (n1 * n2) / (t1 * t2);
                return result;
            // 除
            case 'divide':
                result = (n1 / n2) * (t2 / t1);
                return result;
        }
    }
    
    // 加减乘除的四个接口
    function add(a, b, digits) {
        return operation(a, b, digits, 'add');
    }
    function subtract(a, b, digits) {
        return operation(a, b, digits, 'subtract');
    }
    function multiply(a, b, digits) {
        return operation(a, b, digits, 'multiply');
    }
    function divide(a, b, digits) {
        return operation(a, b, digits, 'divide');
    }
    
    // exports
    return {
        add: add,
        subtract: subtract,
        multiply: multiply,
        divide: divide
    }
}();

// toFixed 修复【解决 chrome 浏览器中，toFixed() 四舍五入不准的问题，但浏览器早已修复】
function toFixed(num, s) {
    var times = Math.pow(10, s);
    var des = num * times + 0.5;
    des = parseInt(des, 10) / times;
    return des + '';
}

在这里插入图片描述

2. 方案二

// 来源：https://www.iteye.com/blog/talentluke-1767138

// 两个浮点数求和
function accAdd(num1, num2) {
  var r1, r2, m;
  try {
    r1 = num1.toString().split('.')[1].length;
  } catch(e) {
    r1 = 0;
  }
  try {
    r2 = num2.toString().split(".")[1].length;
  } catch(e) {
    r2 = 0;
  }
  m = Math.pow(10,Math.max(r1,r2));
  // return (num1*m+num2*m)/m;
  return Math.round(num1*m+num2*m)/m;
}

// 两个浮点数相减
function accSub(num1, num2) {
  var r1, r2, m;
  try {
    r1 = num1.toString().split('.')[1].length;
  } catch(e) {
    r1 = 0;
  }
  try {
    r2 = num2.toString().split(".")[1].length;
  } catch(e) {
    r2 = 0;
  }
  m = Math.pow(10,Math.max(r1,r2));
  n = (r1 >= r2) ? r1 : r2;
  return Number((Math.round(num1*m-num2*m)/m).toFixed(n));
}

// 两个浮点数相除
function accDiv(num1, num2) {
  var t1, t2, r1, r2;
  try {
    t1 = num1.toString().split('.')[1].length;
  } catch(e) {
    t1 = 0;
  }
  try {
    t2 = num2.toString().split(".")[1].length;
  } catch(e) {
    t2 = 0;
  }
  r1 = Number(num1.toString().replace(".",""));
  r2 = Number(num2.toString().replace(".",""));
  return (r1/r2)*Math.pow(10,t2-t1);
}

// 两个浮点数相乘
function accMul(num1, num2) {
  var m = 0, s1 = num1.toString(), s2 = num2.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);
}

在这里插入图片描述

iuukai
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
js的数值精度和数值范围
A-Select °
02-14 2624
1、整数和浮点数 JavaScript 内部，所有数字都是以64位浮点数形式储存，即使整数也是如此。所以，1与1.0是相同的，是同一个数。 1 === 1.0 // true 这就是说，JavaScript 语言的底层根本没有整数，所有数字都是小数（64位浮点数）。容易造成混淆的是，某些运算只有整数才能完成，此时 JavaScript 会自动把64位浮点数，转成32位整数，然后再进行运算，参见《...
详谈javascript精度问题与调整
01-19
一个经典的问题： 0.1+0.2==0.3 答案是：false 因为：0.1+0.2=0.30000000000000004 第一次看到这个结果就是无比惊讶，下巴碰到地上，得深入了解下问题出在哪里，该怎么去调整。 产生问题的原因 在JS中数值类型就只有number类型，没有int，float，double之分，number类型实际上存储的就是IEEE754标准的浮点数，计算规则也是。 在表达式计算前，先要按照标准将两个数转成浮点数。 IEEE 754规定： 1.32位的浮点数（单精度），最高的1位是符号位S，接着的8位是指数E，剩下的23位为有效数字M。 浮点数的表现形式： x=(-1)^S*
js中的数字表示范围
WEB_YH的博客
05-22 4225
在js中Number类型的实质是64为浮点数，javaScript所能表示的数值范围为正负1.7976931348623157乘以10的308次方，其最小所能表示的小数为正负5乘以10的负324次方，这两个边界值可以分别通过访问Number对象的MAX_VALUE属性和MIN_VALUE属性来获取. 对于整数，在ECMAScript5规范中规定，无论正负数的值都不能大于2^53,在这个范围内，j
关于js使用protobuf中的int64的问题
最新发布
robinfoxnan的专栏
04-17 396
默认情况下，生成的js代码中使用number表示int64，这样在具体交互过程中，数据就不精准;具体可以使用[jstype = JS_STRING] 标记让JS按照字符串处理；
JS 能表示的最大数值及JS Number类型数字位数及IEEE754标准1
08-03
大整数的精度丢失和浮点数本质上是一样的，尾数位最大是 52 位，因此 JS 中能精准表示的最大整数是 Math.pow(2, 53)，十进制即大于 900719
JavaScript数值计算时精度问题处理
X01动力装甲的专栏
08-29 3463
Big.js 是一个 JavaScript 的 “任意精度” 数字库，能够处理普通数字无法表示的大数字计算。当使用 JavaScript 进行数值计算时，会面临一些精度问题，这些问题可能会导致不正确的结果。解决方案：可以使用 BigInt 类型进行更大范围的整数运算，但是要注意支持性不够广泛，需在浏览器和 Node.js 环境中提供额外的支持。Luckily, Big.js 提供了相关方法。在处理大数值时，使用 big.js 这样的高精度库可以避免 JavaScript 中 Number 类型的精度问题。
数据精度
q2826621520的博客
06-03 2664
存储单位1B = 8 b; //1字节 = 8个2进制位 1KB=1024B; 1MB=1024KB; 1GB=1024MB; 1TB=1024GB;整型一个字节(8位)可表示数的范围:1.无符号数 = 0 ~ 2的8次方-1 = (0~255) 0000 0000 0000 0001 … 0111 1111 1000 0000 1000 0001 … 1111 11
JS数字精度
高先生的猫
09-22 2917
0.前言 最近在看计算机组成原理的浮点数部分，突然想起之前看过的一道快手面试题 为什么js中0.1+0.2不等于0.3,应该如何解决？ 这里我们可以借这道题来说一下js的精度问题 1.JS数的储存 二进制和浮点数和定点数 首先计算机里面的数据肯定以二进制形式存储 对于同一段二进制码，不同的解读方式肯定有不同的意义 对于小数，我们有定点数和浮点数两种表示方法 目前计算机大多用浮点数，精度高，表示范围大 一个数以浮点数二进制码形式储存，我们从二进制浮点数码中能算出表达的二进制，然后二进制又可.
详解JavaScript 浮点数运算的精度问题
10-16
在这里，大于`Number.MAX_SAFE_INTEGER`(9007199254740991)的整数可能会丢失精度，因为它们超出了53位二进制的有效数字范围。因此，对于大整数的比较和计算，可能会出现意外的相等性判断。 解决JavaScript浮点数...
numjs:JavaScript 中的快速数值操作
06-06
《numjs：JavaScript中的快速数值操作深度解析》 在当今的Web开发领域，JavaScript已经不再仅仅是前端脚本语言，它也广泛应用于后端、科学计算、数据可视化等多个领域。随着需求的增长，对JavaScript进行高效数值...
详解JavaScript中精度失准问题及解决方法
11-21
⑤符号位决定了一个数的正负，指数部分决定了数值的大小，小数部分决定了数值的精度，因此，JavaScript提供的有效 数字最长为53个二进制位（64位浮点的后52位+有效数字第一位的1） 知道Number的具体存储特征后，...
H5带范围滑块拖动数值特效特效代码
03-20
综上所述，"H5带范围滑块拖动数值特效特效代码"涉及到HTML5的`<input type="range">`元素、CSS3样式设计、JavaScript事件处理、数据绑定、响应式设计以及兼容性优化等多个技术层面，通过这些技术的综合运用，实现了...
JavaScript数值最大精度
sunny05296的博客
01-17 4064
JavaScript数值最大精度 根据国际标准 IEEE 754，JavaScript 浮点数的64个二进制位，从最左边开始，是这样组成的： 第1位：符号位，0表示正数，1表示负数 第2位到第12位：指数部分 第13位到第64位：小数部分（即有效数字） 符号位决定了一个数的正负，指数部分决定了数值的大小，小数部分决定了数值的精度 0-4  5-8  9-12 13-16 ...
JavaScript：解决计算精度问题/mathjs/bignumber.js/big.js/decimal.js
snowball的博客
03-24 1万+
这个标准定义了表示浮点数的格式（包括负零-0）与反常值（denormal number）），一些特殊数值（无穷（Inf）与非数值（NaN）），以及这些数值的“浮点数运算符”；JavaScript 内部只有一种数字类型Number，也就是说，JavaScript 语言的底层根本没有整数，所有数字都是以IEEE-754标准格式64位浮点数形式储存，1与1.0是相同的。例如，你可以使用a-calc的add方法来计算两个数的和，使用multiply方法来计算两个数的乘积。isGreaterThan--是否大于。
JavaScript中精度问题以及解决方案
蜗牛的博客
12-21 5274
JavaScript中精度问题以及解决方案
JavaScript浮点数精度问题
weixin_45463061的博客
08-06 3074
只不过在很多其他语言中已经封装好了方法来避免精度的问题，而 JavaScript 是一门弱类型的语言，从设计思想上就没有对浮点数有个严格的数据类型，所以精度误差的问题就显得格外突出。为了验证该例子，我们得先知道怎么将浮点数转换为二进制，整数我们可以用除 2 取余的方式，小数我们则可以用乘 2 取整的方式。像数字，大数字（超出安全数的数字），复数，分数，单位和矩阵。功能强大，易于使用。符号位决定了一个数的正负，指数部分决定了数值的大小，小数部分决定了数值的精度。...
JS中的数值精度问题（二）
m0_37566921的博客
09-18 605
双精度浮点数
基本数据类型的精度和范围
热门推荐
lrhaoya
09-17 1万+
Java中的数据类型分为：基本数据类型和引用数据类型。如下图所示： 下面主要要讨论的是基本数据类型的数据表示范围是如何得到的。 1.首先应该对计算机的存储单元有一定的了解。 在计算机里无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”,我们又称其为“比特位”，通常用小写字母b表示。 而计算机最小的存储单元叫“字节（byte）”,通常用大写字母B表示，字母...
数值精度问题
斯瓦馨阁
10-09 1250
输出数值的精度C++#include <iostream> #include <iomanip> using namespace std;int main(void) { const double value = 12.3456789; cout << value << endl; // 默认以6精度，所以输出为 12.3457 cout << setprecision(4) <
js中 数值精度问题怎么解决
07-13
在 JavaScript 中，由于浮点数的内部表示方式，可能会导致一些精度问题。为了解决这个问题，你可以采取以下几种方法： 1. 使用整数运算：将小数转换为整数，进行计算后再转回小数。例如，可以将金额从以元为单位转换为以分为单位进行计算，避免小数计算带来的精度问题。 2. 使用内置工具：JavaScript 提供了一些内置工具来处理精度问题，如 `toFixed()` 方法和 `toPrecision()` 方法。这些方法可以控制数字的小数位数，从而减少精度问题。 3. 使用第三方库：还可以使用一些第三方库来处理精度问题，比如 `decimal.js` 和 `big.js` 等。这些库提供了更高精度的计算功能，并且可以避免浮点数计算引起的精度损失。 4. 比较浮点数：在比较两个浮点数是否相等时，不要直接使用等号（== 或 ===），而是使用一个误差范围来进行比较。例如，可以判断两个浮点数的差值是否小于一个很小的数值（如 0.000001），来判断它们是否近似相等。 总之，解决 JavaScript 中的数值精度问题需要根据具体情况选择合适的方法，以确保计算结果的准确性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值