【js 计算精准度】js 计算精准度问题 方法封装

【js 计算精准度】js 计算精准度问题 讲解 方法封装 分享

文章推荐阅读 juejin.cn/post/720217…

1. 加法的处理：
   • add 中存在 浮点数的情况下 需要计算出最长的浮点数数量 相乘 再除
   • 例：(0.1 * 小数位长度) + (0.2 * 小数位长度) / 最长的小数位 = 最终值

if (type === 'add') {
    // divideQuantity 最长的浮点数数量
    numberOfDecimalPoints.length > divideQuantity.length && (divideQuantity = numberOfDecimalPoints);
    value += number * parseInt(Number(1 + numberOfDecimalPoints));
}

2. 乘法的处理：
   • multiplication 当前值 * 小数位长度 保存两个字小数位的长度相加待后期相除
   • 例：(0.1 * 小数位长度) * (0.2 * 小数位长度) / 两个值小数位的长度 = 最终值

if (type === 'multiplication') {
    if (value === 0) {
        value = number * parseInt(Number(1 + numberOfDecimalPoints));
    } else {
        value *= number * parseInt(Number(1 + numberOfDecimalPoints));
    }
}

3. 减法的处理：
   • subtraction 当前值 * 小数位长度 保存小数位的长度相加待后期相除
   • 例：(0.1 * 小数位长度) - (0.2 * 小数位长度) / 两个值小数位的长度 = 最终值

if (type === 'subtraction') {
    divideQuantity = numberOfDecimalPoints;
    if (value === 0) {
	value = number * parseInt(Number(1 + numberOfDecimalPoints));
    } else {
	value -= number * parseInt(Number(1 + numberOfDecimalPoints));
    }
}

4. 除法的处理：
   • division 目前除法 可直接处理 暂无什么问题
     代码总结 方法封装

• 使用 calculate([0.1,2],'add');
  

/**
 * @params numberArr --- Array [ number , number ]
 * @params type      --- multiplication || add || subtraction || division
 */
 export function calculate(numberArr, type) {
	let value = 0;
	let intValue = 0;
	let divideQuantity = '';
	let subtractTheMultipliedValue = '';
	if (!(numberArr instanceof Array)) {
		console.error(`${numberArr} is not a Array`);
		return new Error(`${numberArr} is not a Array`);
	}
	if (numberArr.length < 2) {
		console.error(`${numberArr} length cannot be less than 2 `);
		return new Error(`${numberArr} length cannot be less than 2`);
	}
	const isError = numberArr.filter((number) => (number + '').split('.')[1] && (number + '').split('.')[1].length > 2);
	if (isError.length > 0) {
		console.error('. The length after the number cannot be greater than 2');
		return new Error('. The length after the number cannot be greater than 2');
	}
	// 处理减法的
	numberArr.forEach((number) => {
		number = parseFloat(number);
		if ((number + '').split('.')[1]) {
			(number + '').split('.')[1].length > subtractTheMultipliedValue.length ? (subtractTheMultipliedValue += '0') : '';
		}
	});
	numberArr.forEach((number) => {
		let decimalPointValue = (number + '').split('.')[1];
		let numberOfDecimalPoints = '';
		// 1. 存在浮点数的情况
		if (decimalPointValue) {
			decimalPointValue.split('').forEach(() => {
				numberOfDecimalPoints += '0';
				// multiplication 需要计算出浮点数的数量
				type === 'multiplication' && (divideQuantity += '0');
			});
			if (type === 'multiplication') {
				if (value === 0) {
					value = number * parseInt(Number(1 + numberOfDecimalPoints));
				} else {
					value *= number * parseInt(Number(1 + numberOfDecimalPoints));
				}
			}
			if (type === 'division') {
				if (value === 0) {
					value = number * parseInt(Number(1 + numberOfDecimalPoints));
				} else {
					value /= number * parseInt(Number(1 + numberOfDecimalPoints));
				}
			}
			if (type === 'add') {
				// add 需要计算出最长的浮点数数量
				numberOfDecimalPoints.length > divideQuantity.length && (divideQuantity = numberOfDecimalPoints);
				value += number * parseInt(Number(1 + numberOfDecimalPoints));
			}
			if (type === 'subtraction') {
				divideQuantity = numberOfDecimalPoints;
				if (value === 0) {
					value = number * parseInt(Number(1 + numberOfDecimalPoints));
				} else {
					value -= number * parseInt(Number(1 + numberOfDecimalPoints));
				}
			}
		} else {
			if (type === 'division') {
				intValue === 0 ? (intValue = number) : (intValue /= number);
			}
			if (type === 'multiplication') {
				intValue === 0 ? (intValue = number) : (intValue *= number);
			}
			if (type === 'add') {
				intValue += number;
			}
			if (type === 'subtraction') {
				if (intValue === 0) {
					intValue = number * parseInt(Number(1 + subtractTheMultipliedValue));
				} else {
					intValue -= number * parseInt(Number(1 + subtractTheMultipliedValue));
				}
			}
		}
	});
	if (intValue === 0) {
		return value / parseInt(Number(1 + divideQuantity));
	} else {
		if (type === 'multiplication') {
			if (value === 0) {
				return intValue;
			} else {
				return (intValue * value) / parseInt(Number(1 + divideQuantity));
			}
		}
		if (type === 'add') {
			return intValue + value / parseInt(Number(1 + divideQuantity));
		}
		if (type === 'subtraction') {
			if (value === 0) {
				return intValue / parseInt(Number(1 + subtractTheMultipliedValue));
			} else {
				return (intValue - value) / parseInt(Number(1 + subtractTheMultipliedValue));
			}
		}
	}
}