3个高频Bug搞定英寸换厘米：全栈避坑指南
版本升级后 API 全变了，你的单位换算工具还在用旧逻辑？别急，这篇避坑指南直接给你一套从 Python 到前端的完整方案，专治各种“算不准”和“报错懵”。
项目目标与背景
很多开发者觉得“英寸换厘米”是小儿科，不就是乘以 2.54 吗？但在实际工程里，这往往成为数据链路的“暗雷”。
为什么这么说？因为单位换算看似简单，实则牵涉到精度丢失、浮点数陷阱、前端展示异常以及后端接口兼容性四大痛点。特别是在涉及医疗、精密制造或跨境物流场景时，0.01 厘米的误差都可能导致严重的业务事故。
我们的目标不是写一行 inches * 2.54，而是构建一个高精度、可复用、跨端一致的单位换算服务。我们将基于 RFC 规范中关于数据交换的严谨性要求，设计一套从底层算法到前端交互的完整方案。
核心痛点拆解
浮点数精度地狱：JavaScript 和 Python 默认的浮点数运算存在精度偏差，直接计算可能导致 0.1 + 0.2 != 0.3 类似的诡异结果。
API 版本碎片化：老系统用 float，新系统用 Decimal，前端用 Number，后端用 BigDecimal，接口对接时数据格式不统一，报错频发。
缺乏统一标准：团队内部有人用 in，有人用 inch，有人用 IN，导致数据库字段混乱，查询困难。
目录结构设计
为了保持代码的可维护性，我们采用分层架构。项目结构如下：
unit-converter/
├── backend/
│ ├── app/
│ │ ├── __init__.py
│ │ ├── main.py # FastAPI 入口
│ │ ├── core/
│ │ │ ├── __init__.py
│ │ │ └── converter.py # 核心换算逻辑
│ │ └── schemas/
│ │ ├── __init__.py
│ │ └── unit.py # 数据模型定义
│ ├── requirements.txt
│ └── tests/
│ ├── __init__.py
│ └── test_converter.py
├── frontend/
│ ├── index.html
│ ├── style.css
│ └── script.js
└── README.md
设计思路：
Backend：使用 Python FastAPI，确保高性能和类型提示支持。
Frontend：纯原生 JS + HTML，无框架依赖，便于快速集成到任何现有系统。
Core Logic：独立模块，方便单元测试和复用。
核心代码实现
这是本篇的重头戏。我们将逐行讲解如何实现高精度换算，并解决常见的 API 变更问题。
1. 后端核心逻辑：拒绝浮点数陷阱
很多老代码直接写 return inches * 2.54，这在处理大数或高精度需求时会出错。我们引入 decimal 模块，这是 Python 处理金融和精密计算的标准库。
# backend/app/core/converter.py
from decimal import Decimal, InvalidOperation
from typing import Union
class UnitConverter:
高精度单位转换器
遵循 RFC 规范中关于数值精度的最佳实践
# 定义常量，避免魔法数字
INCH_TO_CM = Decimal('2.54')
@classmethod
def inch_to_cm(cls, inches: Union[str, int, float, Decimal]) - Decimal:
将英寸转换为厘米
:param inches: 输入的英寸值，支持字符串以保留原始精度
:return: 厘米值，类型为 Decimal
:raises ValueError: 当输入无法转换为数值时
try:
# 关键点1：统一转换为 Decimal
# 如果传入的是字符串，直接转换；如果是 float，先转字符串再转 Decimal 以避免二进制误差
if isinstance(inches, float):
inch_decimal = Decimal(str(inches))
else:
inch_decimal = Decimal(inches)
# 关键点2：执行乘法
result = inch_decimal * cls.INCH_TO_CM
# 关键点3：量化处理，保留合理的小数位数
# 这里我们保留 4 位小数，根据业务需求调整
quantized_result = result.quantize(Decimal('0.0001'))
return quantized_result
except InvalidOperation:
raise ValueError(fInvalid number format: {inches})
# 测试用例
if __name__ == __main__:
# 常规测试
print(UnitConverter.inch_to_cm(10)) # 25.4000
# 高精度测试
print(UnitConverter.inch_to_cm(0.1)) # 0.2540
# 字符串输入测试
print(UnitConverter.inch_to_cm(12.3456)) # 31.3578
逐行解析：
Decimal 导入：这是避坑的关键。float 在计算机中是二进制近似值，而 Decimal 是十进制精确值。
str(inches) 转换：如果用户传入 0.1（float），直接转 Decimal 会得到 0.10000000000000000555...，必须通过字符串中转来消除二进制误差。
quantize 方法：这是控制输出精度的核心。直接返回 25.4 还是 25.4000？这取决于业务。对于 API 来说，固定小数位有利于前端解析。
2. FastAPI 接口层：处理版本兼容
版本升级后，API 签名往往变化。我们使用 Pydantic 进行数据验证，确保输入合法性。
# backend/app/main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from typing import Optional
from app.core.converter import UnitConverter
app = FastAPI(title=High Precision Unit Converter API)
class ConversionRequest(BaseModel):
请求模型
支持多种输入格式，兼容旧版 API
value: Union[str, float, int] = Field(..., description=输入数值，建议传字符串以保留精度)
from_unit: str = Field(inch, description=源单位，目前仅支持 inch)
to_unit: str = Field(cm, description=目标单位，目前仅支持 cm)
class ConversionResponse(BaseModel):
响应模型
result: str
precision_note: str
@app.post(/convert, response_model=ConversionResponse)
def convert_units(request: ConversionRequest):
单位换算接口
try:
# 验证单位
if request.from_unit != inch or request.to_unit != cm:
raise HTTPException(status_code=400, detail=Unsupported unit pair)
# 调用核心逻辑
result = UnitConverter.inch_to_cm(request.value)
# 返回字符串，避免 JSON 序列化时浮点数精度丢失
return ConversionResponse(
result=str(result),
precision_note=Calculated using Decimal for high precision
)
except ValueError as e:
raise HTTPException(status_code=422, detail=str(e))
避坑要点：
返回 str 而非 float：这是最容易被忽略的坑。FastAPI 默认将 Decimal 序列化为 float，精度再次丢失。强制转换为字符串，让前端自行处理展示逻辑，是保证全链路精度的唯一稳妥方式。
Pydantic 验证：自动拦截非法输入，减少后端异常处理代码。
3. 前端实现：无缝对接与用户体验
前端负责接收用户输入，调用后端 API，并展示结果。
// frontend/script.js
async function convertUnit() {
const inputEl = document.getElementById('input-value');
const resultEl = document.getElementById('result');
const errorEl = document.getElementById('error');
const value = inputEl.value.trim();
// 前端基本校验
if (!value) {
showError('请输入数值');
return;
}
// 尝试解析为数字，但不用于计算，仅用于验证格式
if (isNaN(Number(value))) {
showError('请输入有效的数字');
return;
}
// 清空错误信息
errorEl.textContent = '';
resultEl.textContent = '...';
try {
// 关键点：发送字符串，而不是 Number
// 这样后端才能收到原始精度
const response = await fetch('/convert', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
value: value, // 字符串形式
from_unit: 'inch',
to_unit: 'cm'
})
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.detail || 'Conversion failed');
}
const data = await response.json();
resultEl.textContent = data.result;
} catch (err) {
showError(err.message);
}
}
function showError(msg) {
document.getElementById('error').textContent = msg;
document.getElementById('result').textContent = '';
}
// 绑定事件
document.getElementById('convert-btn').addEventListener('click', convertUnit);
document.getElementById('input-value').addEventListener('keypress', (e) = {
if (e.key === 'Enter') {
convertUnit();
}
});
前端避坑指南：
不要在前端做计算：前端 JS 的 Number 类型同样存在浮点数精度问题。将计算交给后端，前端只负责展示，这是职责分离的最佳实践。
字符串传输：无论用户输入多少位小数，前端都应以字符串形式发送给后端。
错误处理：捕获网络错误和后端业务错误，给用户明确的反馈，而不是白屏或报错堆栈。
运行与测试
1. 环境准备
安装后端依赖：
pip install fastapi uvicorn pydantic
启动后端服务：
uvicorn app.main:app --reload --port 8000
前端静态文件可以通过简单的 HTTP 服务器运行，或者直接部署到 Nginx。
2. 单元测试
编写测试用例，确保核心逻辑的正确性。
# backend/tests/test_converter.py
import pytest
from decimal import Decimal
from app.core.converter import UnitConverter
class TestUnitConverter:
def test_standard_conversion(self):
测试标准换算
assert UnitConverter.inch_to_cm(1) == Decimal('2.5400')
assert UnitConverter.inch_to_cm(10) == Decimal('25.4000')
def test_float_precision(self):
测试浮点数精度处理
# 0.1 * 2.54 在 float 中会有误差，但在 Decimal 中应精确
assert UnitConverter.inch_to_cm(0.1) == Decimal('0.2540')
assert UnitConverter.inch_to_cm(0.1) == Decimal('0.2540')
def test_large_number(self):
测试大数
assert UnitConverter.inch_to_cm(1000000) == Decimal('2540000.0000')
def test_invalid_input(self):
测试无效输入
with pytest.raises(ValueError):
UnitConverter.inch_to_cm(abc)
def test_negative_number(self):
测试负数
assert UnitConverter.inch_to_cm(-1) == Decimal('-2.5400')
运行测试：
pytest -v
3. 接口测试
使用 Postman 或 cURL 测试 API：
curl -X POST http://localhost:8000/convert \
-H Content-Type: application/json \
-d '{value: 12.3456, from_unit: inch, to_unit: cm}'
预期返回：
{
result: 31.3578,
precision_note: Calculated using Decimal for high precision
}
优化扩展与进阶技巧
1. 缓存机制
对于高频重复的换算请求，可以引入 Redis 缓存。
# 伪代码示例
import redis
r = redis.Redis(host='localhost', port=6379, db=0)
def get_cached_conversion(inch_value: str) - Optional[Decimal]:
key = fconv:inch:cm:{inch_value}
cached = r.get(key)
if cached:
return Decimal(cached)
return None
def set_cached_conversion(inch_value: str, result: Decimal):
key = fconv:inch:cm:{inch_value}
r.setex(key, 3600, str(result)) # 缓存1小时
注意：缓存键必须包含原始输入字符串，确保不同精度输入不被错误缓存。
2. 多单位支持扩展
当前只支持 inch 到 cm。要扩展其他单位，只需修改 UnitConverter 类：
class UnitConverter:
INCH_TO_CM = Decimal('2.54')
MILE_TO_KM = Decimal('1.60934')
@classmethod
def convert(cls, value: Decimal, from_unit: str, to_unit: str) - Decimal:
# 构建换算矩阵
factors = {
('inch', 'cm'): cls.INCH_TO_CM,
('mile', 'km'): cls.MILE_TO_KM,
# ... 其他单位
}
factor = factors.get((from_unit, to_unit))
if not factor:
raise ValueError(fUnsupported conversion: {from_unit} to {to_unit})
return (value * factor).quantize(Decimal('0.0001'))
3. 日志与监控
在生产环境中，记录每次换算的请求和结果，便于问题排查。
import logging
logger = logging.getLogger(__name__)
# 在 convert_units 函数中
logger.info(fConversion request: {request.value} {request.from_unit} - {request.to_unit})
# ... 计算 ...
logger.info(fConversion result: {result})
小结与避坑总结
通过这个实战项目，我们不仅实现了英寸换厘米的功能，更掌握了一套高精度数据处理的工程化方法。
关键避坑点回顾
永远不要用 float 做精密计算：使用 Decimal (Python) 或 BigDecimal (Java) 是行业标准。
API 传输使用字符串：避免 JSON 序列化过程中的精度丢失。
前后端职责分离：前端展示，后端计算。前端不要自作聪明地做数学运算。
统一数据格式：定义明确的 from_unit 和 to_unit 枚举，避免字符串拼写错误。
参考权威规范：遵循 RFC 规范中关于数据交换和精度的建议，让你的代码更具可信度和专业性。
版本升级带来的 API 变化并不可怕，可怕的是缺乏对底层原理的理解。当你理解了浮点数的本质，理解了 Decimal 的作用，理解了字符串传输的必要性，你就能从容应对任何版本变更。
这套代码可以直接复制到你的项目中，根据业务需求调整精度位数和单位类型。
还有什么不懂的？评论区留言挨个回 
长河君 · 2026/9/22 7:07:48 · 阅读 1.2k 3个高频Bug搞定英寸换厘米：全栈避坑指南
3个高频Bug搞定英寸换厘米：全栈避坑指南
版本升级后 API 全变了，你的单位换算工具还在用旧逻辑？别急，这篇避坑指南直接给你一套从 Python 到前端的完整方案，专治各种“算不准”和“报错懵”。
项目目标与背景
很多开发者觉得“英寸换厘米”是小儿科，不就是乘以 2.54 吗？但在实际工程里，这往往成为数据链路的“暗雷”。
为什么这么说？因为单位换算看似简单，实则牵涉到精度丢失、浮点数陷阱、前端展示异常以及后端接口兼容性四大痛点。特别是在涉及医疗、精密制造或跨境物流场景时，0.01 厘米的误差都可能导致严重的业务事故。
我们的目标不是写一行 inches * 2.54，而是构建一个高精度、可复用、跨端一致的单位换算服务。我们将基于 RFC 规范中关于数据交换的严谨性要求，设计一套从底层算法到前端交互的完整方案。
核心痛点拆解
浮点数精度地狱：JavaScript 和 Python 默认的浮点数运算存在精度偏差，直接计算可能导致 0.1 + 0.2 != 0.3 类似的诡异结果。
API 版本碎片化：老系统用 float，新系统用 Decimal，前端用 Number，后端用 BigDecimal，接口对接时数据格式不统一，报错频发。
缺乏统一标准：团队内部有人用 in，有人用 inch，有人用 IN，导致数据库字段混乱，查询困难。
目录结构设计
为了保持代码的可维护性，我们采用分层架构。项目结构如下：
unit-converter/
├── backend/
│ ├── app/
│ │ ├── __init__.py
│ │ ├── main.py # FastAPI 入口
│ │ ├── core/
│ │ │ ├── __init__.py
│ │ │ └── converter.py # 核心换算逻辑
│ │ └── schemas/
│ │ ├── __init__.py
│ │ └── unit.py # 数据模型定义
│ ├── requirements.txt
│ └── tests/
│ ├── __init__.py
│ └── test_converter.py
├── frontend/
│ ├── index.html
│ ├── style.css
│ └── script.js
└── README.md
设计思路：
Backend：使用 Python FastAPI，确保高性能和类型提示支持。
Frontend：纯原生 JS + HTML，无框架依赖，便于快速集成到任何现有系统。
Core Logic：独立模块，方便单元测试和复用。
核心代码实现
这是本篇的重头戏。我们将逐行讲解如何实现高精度换算，并解决常见的 API 变更问题。
1. 后端核心逻辑：拒绝浮点数陷阱
很多老代码直接写 return inches * 2.54，这在处理大数或高精度需求时会出错。我们引入 decimal 模块，这是 Python 处理金融和精密计算的标准库。
# backend/app/core/converter.py
from decimal import Decimal, InvalidOperation
from typing import Union
class UnitConverter:
高精度单位转换器
遵循 RFC 规范中关于数值精度的最佳实践
# 定义常量，避免魔法数字
INCH_TO_CM = Decimal('2.54')
@classmethod
def inch_to_cm(cls, inches: Union[str, int, float, Decimal]) - Decimal:
将英寸转换为厘米
:param inches: 输入的英寸值，支持字符串以保留原始精度
:return: 厘米值，类型为 Decimal
:raises ValueError: 当输入无法转换为数值时
try:
# 关键点1：统一转换为 Decimal
# 如果传入的是字符串，直接转换；如果是 float，先转字符串再转 Decimal 以避免二进制误差
if isinstance(inches, float):
inch_decimal = Decimal(str(inches))
else:
inch_decimal = Decimal(inches)
# 关键点2：执行乘法
result = inch_decimal * cls.INCH_TO_CM
# 关键点3：量化处理，保留合理的小数位数
# 这里我们保留 4 位小数，根据业务需求调整
quantized_result = result.quantize(Decimal('0.0001'))
return quantized_result
except InvalidOperation:
raise ValueError(fInvalid number format: {inches})
# 测试用例
if __name__ == __main__:
# 常规测试
print(UnitConverter.inch_to_cm(10)) # 25.4000
# 高精度测试
print(UnitConverter.inch_to_cm(0.1)) # 0.2540
# 字符串输入测试
print(UnitConverter.inch_to_cm(12.3456)) # 31.3578
逐行解析：
Decimal 导入：这是避坑的关键。float 在计算机中是二进制近似值，而 Decimal 是十进制精确值。
str(inches) 转换：如果用户传入 0.1（float），直接转 Decimal 会得到 0.10000000000000000555...，必须通过字符串中转来消除二进制误差。
quantize 方法：这是控制输出精度的核心。直接返回 25.4 还是 25.4000？这取决于业务。对于 API 来说，固定小数位有利于前端解析。
2. FastAPI 接口层：处理版本兼容
版本升级后，API 签名往往变化。我们使用 Pydantic 进行数据验证，确保输入合法性。
# backend/app/main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from typing import Optional
from app.core.converter import UnitConverter
app = FastAPI(title=High Precision Unit Converter API)
class ConversionRequest(BaseModel):
请求模型
支持多种输入格式，兼容旧版 API
value: Union[str, float, int] = Field(..., description=输入数值，建议传字符串以保留精度)
from_unit: str = Field(inch, description=源单位，目前仅支持 inch)
to_unit: str = Field(cm, description=目标单位，目前仅支持 cm)
class ConversionResponse(BaseModel):
响应模型
result: str
precision_note: str
@app.post(/convert, response_model=ConversionResponse)
def convert_units(request: ConversionRequest):
单位换算接口
try:
# 验证单位
if request.from_unit != inch or request.to_unit != cm:
raise HTTPException(status_code=400, detail=Unsupported unit pair)
# 调用核心逻辑
result = UnitConverter.inch_to_cm(request.value)
# 返回字符串，避免 JSON 序列化时浮点数精度丢失
return ConversionResponse(
result=str(result),
precision_note=Calculated using Decimal for high precision
)
except ValueError as e:
raise HTTPException(status_code=422, detail=str(e))
避坑要点：
返回 str 而非 float：这是最容易被忽略的坑。FastAPI 默认将 Decimal 序列化为 float，精度再次丢失。强制转换为字符串，让前端自行处理展示逻辑，是保证全链路精度的唯一稳妥方式。
Pydantic 验证：自动拦截非法输入，减少后端异常处理代码。
3. 前端实现：无缝对接与用户体验
前端负责接收用户输入，调用后端 API，并展示结果。
// frontend/script.js
async function convertUnit() {
const inputEl = document.getElementById('input-value');
const resultEl = document.getElementById('result');
const errorEl = document.getElementById('error');
const value = inputEl.value.trim();
// 前端基本校验
if (!value) {
showError('请输入数值');
return;
}
// 尝试解析为数字，但不用于计算，仅用于验证格式
if (isNaN(Number(value))) {
showError('请输入有效的数字');
return;
}
// 清空错误信息
errorEl.textContent = '';
resultEl.textContent = '...';
try {
// 关键点：发送字符串，而不是 Number
// 这样后端才能收到原始精度
const response = await fetch('/convert', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
value: value, // 字符串形式
from_unit: 'inch',
to_unit: 'cm'
})
});
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.detail || 'Conversion failed');
}
const data = await response.json();
resultEl.textContent = data.result;
} catch (err) {
showError(err.message);
}
}
function showError(msg) {
document.getElementById('error').textContent = msg;
document.getElementById('result').textContent = '';
}
// 绑定事件
document.getElementById('convert-btn').addEventListener('click', convertUnit);
document.getElementById('input-value').addEventListener('keypress', (e) = {
if (e.key === 'Enter') {
convertUnit();
}
});
前端避坑指南：
不要在前端做计算：前端 JS 的 Number 类型同样存在浮点数精度问题。将计算交给后端，前端只负责展示，这是职责分离的最佳实践。
字符串传输：无论用户输入多少位小数，前端都应以字符串形式发送给后端。
错误处理：捕获网络错误和后端业务错误，给用户明确的反馈，而不是白屏或报错堆栈。
运行与测试
1. 环境准备
安装后端依赖：
pip install fastapi uvicorn pydantic
启动后端服务：
uvicorn app.main:app --reload --port 8000
前端静态文件可以通过简单的 HTTP 服务器运行，或者直接部署到 Nginx。
2. 单元测试
编写测试用例，确保核心逻辑的正确性。
# backend/tests/test_converter.py
import pytest
from decimal import Decimal
from app.core.converter import UnitConverter
class TestUnitConverter:
def test_standard_conversion(self):
测试标准换算
assert UnitConverter.inch_to_cm(1) == Decimal('2.5400')
assert UnitConverter.inch_to_cm(10) == Decimal('25.4000')
def test_float_precision(self):
测试浮点数精度处理
# 0.1 * 2.54 在 float 中会有误差，但在 Decimal 中应精确
assert UnitConverter.inch_to_cm(0.1) == Decimal('0.2540')
assert UnitConverter.inch_to_cm(0.1) == Decimal('0.2540')
def test_large_number(self):
测试大数
assert UnitConverter.inch_to_cm(1000000) == Decimal('2540000.0000')
def test_invalid_input(self):
测试无效输入
with pytest.raises(ValueError):
UnitConverter.inch_to_cm(abc)
def test_negative_number(self):
测试负数
assert UnitConverter.inch_to_cm(-1) == Decimal('-2.5400')
运行测试：
pytest -v
3. 接口测试
使用 Postman 或 cURL 测试 API：
curl -X POST http://localhost:8000/convert \
-H Content-Type: application/json \
-d '{value: 12.3456, from_unit: inch, to_unit: cm}'
预期返回：
{
result: 31.3578,
precision_note: Calculated using Decimal for high precision
}
优化扩展与进阶技巧
1. 缓存机制
对于高频重复的换算请求，可以引入 Redis 缓存。
# 伪代码示例
import redis
r = redis.Redis(host='localhost', port=6379, db=0)
def get_cached_conversion(inch_value: str) - Optional[Decimal]:
key = fconv:inch:cm:{inch_value}
cached = r.get(key)
if cached:
return Decimal(cached)
return None
def set_cached_conversion(inch_value: str, result: Decimal):
key = fconv:inch:cm:{inch_value}
r.setex(key, 3600, str(result)) # 缓存1小时
注意：缓存键必须包含原始输入字符串，确保不同精度输入不被错误缓存。
2. 多单位支持扩展
当前只支持 inch 到 cm。要扩展其他单位，只需修改 UnitConverter 类：
class UnitConverter:
INCH_TO_CM = Decimal('2.54')
MILE_TO_KM = Decimal('1.60934')
@classmethod
def convert(cls, value: Decimal, from_unit: str, to_unit: str) - Decimal:
# 构建换算矩阵
factors = {
('inch', 'cm'): cls.INCH_TO_CM,
('mile', 'km'): cls.MILE_TO_KM,
# ... 其他单位
}
factor = factors.get((from_unit, to_unit))
if not factor:
raise ValueError(fUnsupported conversion: {from_unit} to {to_unit})
return (value * factor).quantize(Decimal('0.0001'))
3. 日志与监控
在生产环境中，记录每次换算的请求和结果，便于问题排查。
import logging
logger = logging.getLogger(__name__)
# 在 convert_units 函数中
logger.info(fConversion request: {request.value} {request.from_unit} - {request.to_unit})
# ... 计算 ...
logger.info(fConversion result: {result})
小结与避坑总结
通过这个实战项目，我们不仅实现了英寸换厘米的功能，更掌握了一套高精度数据处理的工程化方法。
关键避坑点回顾
永远不要用 float 做精密计算：使用 Decimal (Python) 或 BigDecimal (Java) 是行业标准。
API 传输使用字符串：避免 JSON 序列化过程中的精度丢失。
前后端职责分离：前端展示，后端计算。前端不要自作聪明地做数学运算。
统一数据格式：定义明确的 from_unit 和 to_unit 枚举，避免字符串拼写错误。
参考权威规范：遵循 RFC 规范中关于数据交换和精度的建议，让你的代码更具可信度和专业性。
版本升级带来的 API 变化并不可怕，可怕的是缺乏对底层原理的理解。当你理解了浮点数的本质，理解了 Decimal 的作用，理解了字符串传输的必要性，你就能从容应对任何版本变更。
这套代码可以直接复制到你的项目中，根据业务需求调整精度位数和单位类型。
还有什么不懂的？评论区留言挨个回