amountutil 1.0.0

package/AmountUtil.js

@@ -0,0 +1,669 @@
+class AmountUtil {
+    #amount = ''
+
+    constructor(amount) {
+        this.#amount = amount
+    }
+
+    #compare = (num1, num2) => {
+        num1 = num1 + ''
+        num2 = num2 + ''
+
+        if (Number(num1) === 0 && Number(num2) === 0) return 0
+
+        if (Number(num1) === 0) {
+            if (Number(num2) === 0) {
+                return 0
+            } else {
+                if (num2[0] === '-') {
+                    return 1
+                } else {
+                    return -1
+                }
+            }
+        } else if (Number(num2) === 0) {
+            if (Number(num1) === 0) {
+                return 0
+            } else {
+                if (num1[0] === '-') {
+                    return -1
+                } else {
+                    return 1
+                }
+            }
+        }
+
+        if (num1[0] === '-') {
+            if (num2[0] === '-') {
+                return this.#compare(num1.slice(1), num2.slice(1)) * -1
+            } else {
+                return -1
+            }
+        } else if (num2[0] === '-') {
+            return 1
+        }
+
+        if (!num1.includes('.')) {
+            num1 += '.0'
+        }
+        if (!num2.includes('.')) {
+            num2 += '.0'
+        }
+
+        const integer1 = num1.split('.')[0]
+        const integer2 = num2.split('.')[0]
+        let decimal1 = num1.split('.')[1]
+        let decimal2 = num2.split('.')[1]
+        let integerCompareResult = integer1.length > integer2.length ? 1 : integer1.length < integer2.length ? -1 : 0
+
+        if (integerCompareResult !== 0) {
+            return integerCompareResult
+        } else {
+            for (let i = 0; i < integer1.length; i++) {
+                if (integer1[i] > integer2[i]) {
+                    integerCompareResult = 1
+                    break
+                } else if (integer1[i] < integer2[i]) {
+                    integerCompareResult = -1
+                    break
+                }
+            }
+
+            if (integerCompareResult !== 0) {
+                return integerCompareResult
+            }
+
+            integerCompareResult = 0
+        }
+
+        if (integerCompareResult === 0) {
+            decimal1 = decimal1.replace(/0+$/, '')
+            decimal2 = decimal2.replace(/0+$/, '')
+
+            if (decimal1.trim().length === 0) {
+                decimal1 = '0'
+            }
+            if (decimal2.trim().length === 0) {
+                decimal2 = '0'
+            }
+
+            if (decimal1.length > decimal2.length) {
+                decimal2 += '0'.repeat(decimal1.length - decimal2.length)
+            } else if (decimal1.length < decimal2.length) {
+                decimal1 += '0'.repeat(decimal2.length - decimal1.length)
+            }
+
+            for (let i = 0; i < decimal1.length; i++) {
+                if (decimal1[i] > decimal2[i]) {
+                    return 1
+                } else if (decimal1[i] < decimal2[i]) {
+                    return -1
+                }
+            }
+
+            return 0
+        }
+    }
+
+    #round = (num, precision = 0) => {
+        num = num + ''
+        if (num.trim().length === 0 || precision < 0) {
+            return '0'
+        }
+
+        if (!num.includes('.')) {
+            num += '.0'
+        }
+
+        if (num[0] === '-') {
+            return '-' + this.#round(num.slice(1), precision)
+        }
+
+        let integerPart = num.split('.')[0]
+        let decimalPart = num.split('.')[1]
+
+        if (precision > decimalPart.length) {
+            decimalPart += '0'.repeat(precision - decimalPart.length)
+            return integerPart + '.' + decimalPart
+        } else if (precision === decimalPart.length) {
+            return integerPart + '.' + decimalPart
+        }
+
+        if (precision === 0) {
+            return this.#compare(decimalPart[0], '5') === 1 || this.#compare(decimalPart[0], '5') === 0 ? this.#plus(integerPart, '1').split('.')[0] : integerPart
+        } else {
+            if (this.#compare(decimalPart[precision], '5') === 1 || this.#compare(decimalPart[precision], '5') === 0) {
+                let m = ''
+                if (integerPart[0] === '-') {
+                    m = '-'
+                    integerPart = integerPart.slice(1)
+                }
+                let newNum = integerPart + '.' + decimalPart.slice(0, precision)
+                let addNum = '0.' + '0'.repeat(precision - 1) + '1'
+                let result = m + this.#plus(newNum, addNum)
+                if (result.split('.')[1]?.length < precision) {
+                    result += '0'.repeat(precision - result.split('.')[1].length)
+                }
+
+                if (!result.includes('.')) {
+                    result += '.' + '0'.repeat(precision)
+                }
+
+                return result
+            } else {
+                return integerPart + '.' + decimalPart.slice(0, precision)
+            }
+        }
+    }
+
+    #plus = (addend1, addend2) => {
+        addend1 = addend1 + ''
+        addend2 = addend2 + ''
+        if (addend1.trim().length === 0 || addend2.trim().length === 0) {
+            return '0'
+        }
+
+        if (this.#compare(addend1, '0') === 0 && this.#compare(addend2, '0') === 0) return '0'
+
+        if (addend2[0] === '-') {
+            if (addend1[0] === '-') {
+                return '-' + this.#plus(addend1.slice(1), addend2.slice(1))
+            } else {
+                let r = this.#minus(addend2.slice(1), addend1)
+
+                if (r[0] === '-') {
+                    return r.slice(1)
+                } else {
+                    return '-' + r
+                }
+            }
+        } else if (addend1[0] === '-') {
+            return this.#minus(addend2, addend1.slice(1))
+        }
+
+        if (!addend1.includes('.')) {
+            addend1 += '.0'
+        }
+        if (!addend2.includes('.')) {
+            addend2 += '.0'
+        }
+
+        let integer1 = addend1.split('.')[0]
+        let integer2 = addend2.split('.')[0]
+        let decimal1 = addend1.split('.')[1]
+        let decimal2 = addend2.split('.')[1]
+
+        if (decimal1.length > decimal2.length) {
+            decimal2 += '0'.repeat(decimal1.length - decimal2.length)
+        } else if (decimal1.length < decimal2.length) {
+            decimal1 += '0'.repeat(decimal2.length - decimal1.length)
+        }
+
+        if (integer1.length > integer2.length) {
+            integer2 = '0'.repeat(integer1.length - integer2.length) + integer2
+        } else if (integer1.length < integer2.length) {
+            integer1 = '0'.repeat(integer2.length - integer1.length) + integer1
+        }
+
+        let addDecimal1 = integer1 + '.' + decimal1
+        let addDecimal2 = integer2 + '.' + decimal2
+
+        let count = addDecimal1.length
+        let carry = 0;
+        let currentSum = 0;
+        let resultArray = [];
+
+        for (let i = count - 1; i >= 0; i--) {
+            if (addDecimal1[i] === '.') {
+                resultArray = [ '.', ...resultArray ]
+                continue
+            }
+            currentSum = Number(addDecimal1[i]) + Number(addDecimal2[i]) + carry
+            carry = Math.floor(currentSum / 10)
+            resultArray = [ (currentSum % 10).toString(), ...resultArray ]
+        }
+
+        if (carry !== 0) resultArray = [ carry.toString(), ...resultArray ]
+
+        let result = resultArray.join('').replace(/0+$/, '')
+
+        return result[result.length - 1] === '.' ? result.slice(0, -1) : result
+    }
+
+    #minus = (minuend, subtrahend) => {
+        minuend = minuend + ''
+        subtrahend = subtrahend + ''
+        if (minuend.trim().length === 0 || subtrahend.trim().length === 0) {
+            return '0'
+        }
+
+        if (this.#compare(minuend, '0') === 0 && this.#compare(subtrahend, '0') === 0) return '0'
+
+        if (subtrahend[0] === '-') {
+            if (minuend[0] === '-') {
+                return this.#minus(subtrahend.slice(1), minuend.slice(1))
+            } else {
+                return this.#plus(minuend, subtrahend.slice(1))
+            }
+        } else if (minuend[0] === '-') {
+            return '-' + this.#plus(minuend.slice(1), subtrahend)
+        }
+
+        if (this.#compare(minuend, subtrahend) === 0) {
+            return '0'
+        } else if (this.#compare(minuend, subtrahend) === -1) {
+            return '-' + this.#minus(subtrahend, minuend)
+        }
+
+        if (!minuend.includes('.')) {
+            minuend += '.0'
+        }
+        if (!subtrahend.includes('.')) {
+            subtrahend += '.0'
+        }
+
+        let integerMinuend = minuend.split('.')[0]
+        let integerSubtrahend = subtrahend.split('.')[0]
+        let decimalMinuend = minuend.split('.')[1]
+        let decimalSubtrahend = subtrahend.split('.')[1]
+
+        if (integerMinuend.length > integerSubtrahend.length) {
+            integerSubtrahend = '0'.repeat(integerMinuend.length - integerSubtrahend.length) + integerSubtrahend
+        } else if (integerMinuend.length < integerSubtrahend.length) {
+            integerMinuend = '0'.repeat(integerSubtrahend.length - integerMinuend.length) + integerMinuend
+        }
+
+        if (decimalMinuend.length > decimalSubtrahend.length) {
+            decimalSubtrahend += '0'.repeat(decimalMinuend.length - decimalSubtrahend.length)
+        } else if (decimalMinuend.length < decimalSubtrahend.length) {
+            decimalMinuend += '0'.repeat(decimalSubtrahend.length - decimalMinuend.length)
+        }
+
+        let num1 = integerMinuend + '.' + decimalMinuend
+        let num2 = integerSubtrahend + '.' + decimalSubtrahend
+
+        let borrow = 0
+        let alreadyBorrowed = false
+        let curBit;
+        let resultArray = [];
+
+        for (let i = num1.length - 1; i >= 0; i--) {
+            if (num1[i] === '.') {
+                resultArray = [ '.', ...resultArray ]
+                continue
+            }
+            curBit = Number(num1[i]) - Number(num2[i]) - borrow
+            if (curBit < 0) {
+                if (!alreadyBorrowed) {
+                    alreadyBorrowed = true
+                }
+                curBit += 10
+                borrow = 1
+            } else {
+                alreadyBorrowed = false
+                borrow = 0
+            }
+            resultArray = [ curBit.toString(), ...resultArray ]
+        }
+
+        let result = resultArray.join('').replace(/0+$/, '').replace(/^0+/, '')
+
+        if (result[0] === '.') {
+            result = '0' + result
+        }
+
+        if (result[result.length - 1] === '.') {
+            result = result.slice(0, -1)
+        }
+
+        return result
+    }
+
+    #multiply = (num1, num2) => {
+        num1 = num1 + ''
+        num2 = num2 + ''
+
+        if (num1.trim().length === 0 || num2.trim().length === 0) {
+            return '0'
+        }
+
+        if (this.#compare(num1, '0') === 0 || this.#compare(num2, '0') === 0) return '0'
+        
+        if (num1[0] === '-') {
+            if (num2[0] !== '-') {
+                return '-' + this.#multiply(num1.slice(1), num2)
+            } else {
+                return this.#multiply(num1.slice(1), num2.slice(1))
+            }
+        } else if (num2[0] === '-') {
+            return '-' + this.#multiply(num1, num2.slice(1))
+        }
+
+        let decimal1 = num1.match(/\.(\d+)/)
+        let decimal2 = num2.match(/\.(\d+)/)
+        let decimalLength = 0
+        if (decimal1 && decimal2) {
+            decimalLength = decimal1[1].length + decimal2[1].length
+        } else if (decimal1) {
+            decimalLength = decimal1[1].length
+        } else if (decimal2) {
+            decimalLength = decimal2[1].length
+        }
+
+        num1 = num1.replace('.', '')
+        num2 = num2.replace('.', '')
+
+        let result = '0'
+        for (let i = num2.length - 1; i >= 0; i--) {
+            let curBit = Number(num2[i])
+            let curResult = ''
+            let carry = 0
+            for (let j = num1.length - 1; j >= 0; j--) {
+                let product = curBit * Number(num1[j]) + carry
+                carry = Math.floor(product / 10)
+                curResult = (product % 10).toString() + curResult
+            }
+            if (carry !== 0) curResult = carry.toString() + curResult
+            curResult += '0'.repeat(num2.length - 1 - i)
+            result = this.#plus(result, curResult)
+        }
+
+        if (decimalLength > 0) {
+            result = result.slice(0, -decimalLength) + '.' + result.slice(-decimalLength)
+        }
+
+        result = result.replace(/^0+/, '')
+        if (result.length === 0 || result[0] === '.') {
+            result = '0' + result
+        }
+
+        return result
+    }
+
+    #divide = (dividend, divisor, precision = 19, calculatedRound = false) => {
+        dividend = dividend + ''
+        divisor = divisor + ''
+
+        if (dividend.trim().length === 0 || divisor.trim().length === 0) {
+            return '0'
+        }
+
+        if (this.#compare(divisor, '0') === 0) {
+            throw new Error('dividend can not be 0')
+        }
+
+        if (this.#compare(dividend, '0') === 0) {
+            return '0'
+        }
+
+        let isNegative = false
+        if (dividend[0] === '-') {
+            if (divisor[0] !== '-') {
+                isNegative = true
+                dividend = dividend.slice(1)
+            } else {
+                isNegative = false
+                dividend = dividend.slice(1)
+                divisor = divisor.slice(1)
+            }
+        } else if (divisor[0] === '-') {
+            isNegative = true
+            divisor = divisor.slice(1)
+        }
+        
+        let decimalIndex = divisor.match(/\.(\d+)/)
+        if (decimalIndex) {
+            dividend = this.#multiply(dividend, '1' + '0'.repeat(decimalIndex[1].length))
+            divisor = divisor.replace('.', '')
+        }
+
+        if (!dividend.includes('.')) dividend += '.0'
+
+        let result = ''
+        let curDividend = ''
+        let totalLength = dividend.match(/\d+/)[0].length + precision + 1
+        for (let i = 0; i <= totalLength; i++) {
+            if (dividend[i] === '.') {
+                result += '.'
+                continue
+            }
+
+            if (dividend[i] === undefined) {
+                curDividend += '0'
+            } else {
+                curDividend += dividend[i]
+            }
+            
+            if (this.#compare(curDividend, divisor) === 1 || this.#compare(curDividend, divisor) === 0) {
+                let n = '1'
+                while (this.#compare(this.#multiply(divisor, n.toString()), curDividend) === -1) {
+                    n = this.#plus(n, '1')
+                }
+
+                if (this.#compare(curDividend, divisor) === 0) {
+                    result += n
+                    curDividend = '0'
+                } else {
+                    result += this.#minus(n, '1')
+                    curDividend = this.#minus(curDividend, this.#multiply(divisor, this.#minus(n, '1')))
+                }
+            } else {
+                result += '0'
+            }
+        }
+
+        result = result.replace(/^0+/, '')
+        result = result.replace(/0+$/, '')
+        
+        if (result.length === 0 || result === '.' || result === '0.' || result === '.0') result = '0'
+        
+        if (result[0] === '.' && result !== '0') result = '0' + result
+        if (result[result.length - 1] === '.' && result !== '0') result += '0'
+
+        if (calculatedRound) {
+            result = this.#round(result, precision)
+        } else {
+            let decimalLength = result.match(/\.(\d+)/)[1].length
+            if (this.#compare(decimalLength, precision) === 1) {
+                result = this.#round(result, precision)
+            }
+        }
+
+        if (isNegative && result !== '0') {
+            result = '-' + result
+        }
+
+        return result
+    }
+
+    #thousandSeparator = (amount) => {
+        if (amount[0] === '-') {
+            return '-' + this.#thousandSeparator(amount.slice(1))
+        }
+
+        if (amount.includes('.')) {
+            let integerPart = amount.split('.')[0]
+            let decimalPart = amount.split('.')[1]
+            decimalPart = decimalPart.split('').reverse().join('')
+            decimalPart = decimalPart.replace(/\B(?=(\d{3})+(?!\d))/g, ',')
+            decimalPart = decimalPart.split('').reverse().join('')
+            return integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ',') + '.' + decimalPart
+        } else {
+            return amount.replace(/\B(?=(\d{3})+(?!\d))/g, ',')
+        }
+    }
+
+    #translateAmount = (amount) => {
+        let isNegative = false;
+        if (amount.length !== 0 && amount[0] === "-") {
+            isNegative = true;
+            amount = amount.slice(1);
+        }
+
+        amount = amount.replace(/^0+/, "")
+
+        if (amount === "") return "零元整"
+        if (amount[0] === '.') amount = '0' + amount
+        if (amount[amount.length - 1] === '.') amount += '0'
+
+        let amountList = (amount + "").split("\.");
+        let integer = amountList[0];
+        let decimal = amountList.length > 1 ? amountList[1] : "";
+
+        let groups = integer.match(/\d{1,4}(?=(\d{4})*$)/g) || []
+
+        let list = [];
+        for (let am of groups) {
+            let de = am + "";
+
+            de = de.replace(/^0+/, "");
+
+            let s = this.#convertChinese(de)
+            if ((de + "").length < am.length) {
+                s = "零" + s;
+            }
+            list = [...list, s];
+        }
+        amountList = list;
+        let integerPart = this.#integerPartToChinese(amountList);
+
+        let decimalPart = !(decimal.length === 0) ? this.#decimalPartToChinese(decimal) : "";
+
+        let chineseAmount = integerPart + decimalPart;
+
+        let remainder = (Number(amount) % 1) + ""
+        if ("0" === remainder) {
+            chineseAmount += "整";
+        }
+
+        if (decimalPart.indexOf("角") !== -1 && decimalPart.indexOf("分") === -1) {
+            chineseAmount += "整";
+        }
+
+        return (isNegative ? "负" : "") + chineseAmount;
+    }
+
+    #integerPartToChinese = (integerPart) => {
+        let needZero = false;
+        let units = [ "亿", "万", "元" ];
+        if (integerPart.length > 3) return "";
+        for (let i = 0; i < integerPart.length; i++) {
+            if ("零" === integerPart[i]) {
+                needZero = true;
+                continue;
+            }
+
+            if (needZero && integerPart[i][0] !== "零") {
+                integerPart[i] = "零" + integerPart[i];
+            }
+            let index = units.length - integerPart.length + i;
+            integerPart[i] = integerPart[i] + units[index];
+        }
+
+        let list = integerPart;
+
+        list = list.filter(s => s !== "零");
+
+        let s = list[list.length - 1];
+        if (s[s.length - 1] !== "元") {
+            list.push("元");
+        }
+
+        return list.join("");
+    }
+
+    #convertChinese = (amount) => {
+        let chinese = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];
+        let unit = ["仟", "佰", "拾", ""];
+        let amountStr = amount + "";
+        let chineseAmount = "";
+        let isZero = false;
+        for (let i = 0; i < amountStr.length; i++) {
+            if (amountStr[i] - '0' == 0) {
+                isZero = true;
+                continue;
+            }
+            let index = unit.length - (amountStr.length - i);
+            if (isZero) {
+                chineseAmount += "零";
+                isZero = false;
+            }
+            chineseAmount += chinese[amountStr[i] - '0'] + unit[index];
+        }
+
+        return chineseAmount;
+    }
+
+    #decimalPartToChinese = (decimalPart) => {
+        let chinese = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];
+        let unit = ["角", "分"];
+        let chineseDecimal = "";
+        let isZero = false;
+        for (let i = 0; i < decimalPart.length; i++) {
+            if (decimalPart[i] - '0' == 0) {
+                isZero = true;
+                continue;
+            }
+
+            let s = chinese[decimalPart[i] - '0'] + unit[i];
+            if (isZero) {
+                chineseDecimal += "零";
+            }
+            chineseDecimal += s;
+        }
+
+        return chineseDecimal;
+    }
+
+    set = (num) => {
+        this.#amount = num
+    }
+
+    get = () => {
+        return this.#amount
+    }
+
+    compare = (num) => {
+        return this.#compare(this.#amount, num)
+    }
+
+    toFixed = (precision) => {
+        return this.#round(this.#amount, precision)
+    }
+
+    add = (num) => {
+        this.#amount = this.#plus(this.#amount, num)
+        return this
+    }
+
+    subtract = (num) => {
+        this.#amount = this.#minus(this.#amount, num)
+        return this
+    }
+
+    multiply = (num) => {
+        this.#amount = this.#multiply(this.#amount, num)
+        return this
+    }
+
+    divide = (num, precision = 19, calculatedRound = false) => {
+        this.#amount = this.#divide(this.#amount, num, precision, calculatedRound)
+        return this
+    }
+
+    translateAmount = () => {
+        return this.#translateAmount(this.#amount)
+    }
+
+    toLocaleString = () => {
+        return this.#thousandSeparator(this.#amount)
+    }
+
+    toString = () => {
+        return this.#amount
+    }
+}
+
+module.exports = AmountUtil
+
+

package/README.md

@@ -0,0 +1,39 @@
+# AmountUtil
+ 
+The util that can help you to manage about amount,we have introduced a very powerful Chinese amount translation feature.
+ 
+## Installation
+ 
+```bash
+npm install amountutil
+```
+
+## Usage
+
+```javascript
+const AmountUtil = require('amountutil');
+
+// 转换为中文金额
+let amount = new AmountUtil(123456.78);
+const chineseAmount = amount.translateAmount();
+console.log(chineseAmount); // 输出："壹拾贰万叁仟肆佰伍拾陆元柒角捌分"
+
+// 大数加减乘除
+let amount1 = new AmountUtil(123456.78);
+let sum = amount1.add(98765.43);
+console.log(sum.toString()); // 输出：222222.21
+
+let diff = amount1.subtract(98765.43);
+console.log(diff.toString()); // 输出：123456.78
+
+let product = amount1.multiply(2);
+console.log(product.toString()); // 输出：246913.56
+
+let quotient = amount1.divide(2, precision = 2);
+console.log(quotient.toString()); // 输出：123456.78
+
+// 比较、保留小数位数、千分符
+console.log(amount1.compare(98765.43)); // 输出：1
+console.log(amount1.toFixed(1)); // 输出：123456.8
+console.log(amount1.toLocaleString()); // 输出：123,456.78
+```

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "amountutil",
+  "version": "1.0.0",
+  "description": "The util that can help you to manage about amount,we have introduced a very powerful Chinese amount translation feature.",
+  "main": "AmountUtil.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "金额转换中文",
+    "金额转换",
+    "中文金额",
+    "金额",
+    "金额工具"
+  ],
+  "author": "ZhuYngve",
+  "license": "ISC"
+}