加减乘除_math.pow(10, scale)

import Vue from 'vue';
export default {
    /**
    * num 取小数位
    *
    * @param num
    * @param scale 取几位小数
    * @param mode 1: 向上取整 2: 向下取整  默认四舍五入
    */

    round: function (num, scale, mode) {
        if(isNaN(num) || num == null) {
            num = 0;
        }
        if(isNaN(scale) || scale == null) {
            scale = 0;
        }
        var baseNum = Math.pow(10, scale);
        switch (mode) {
            case 1:
                return this.div(Math.ceil(this.mul(num, baseNum)), baseNum);
            case 2:
                return this.div(Math.floor(this.mul(num, baseNum)), baseNum);
            default:
                return this.div(Math.round(this.mul(num, baseNum)), baseNum);
        }

    },

    /**
     * 加法运算, 避免数据相加小数点后产生多位数和计算精度损失.
     *
     * @param num1  加数
     * @param num1  加数
     */

    add: function (num1, num2) {
        if(isNaN(num1) || num1 == null) {
            num1 = 0;
        }
        if(isNaN(num2) || num2 == null) {
            num2 = 0;
        }
        var baseNum, baseNum1, baseNum2;
        try {
            baseNum1 = num1.toString().split(".")[1].length;
        } catch (e) {
            baseNum1 = 0;
        }
        try {
            baseNum2 = num2.toString().split(".")[1].length;
        } catch (e) {
            baseNum2 = 0;
        }
        baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
        return this.div((parseFloat(this.mul(num1, baseNum)) + parseFloat(this.mul(num2, baseNum))), baseNum);
    },

    /**
     * 减法运算, 避免数据相减小数点后产生多位数和计算精度损失.
     *
     * @param num1  被减数
     * @param num2  减数
     */

    sub: function (num1, num2) {
        if(isNaN(num1) || num1 == null) {
            num1 = 0;
        }
        if(isNaN(num2) || num2 == null) {
            num2 = 0;
        }
        var baseNum, baseNum1, baseNum2;
        var precision;
        try {
            baseNum1 = num1.toString().split(".")[1].length;
        } catch (e) {
            baseNum1 = 0;
        }
        try {
            baseNum2 = num2.toString().split(".")[1].length;
        } catch (e) {
            baseNum2 = 0;
        }
        baseNum = Math.pow(10, Math.max(baseNum1, baseNum2));
        precision = (baseNum1 >= baseNum2) ? baseNum1 : baseNum2;
        return this.toolNumber(parseFloat(this.div((parseFloat(this.mul(num1, baseNum)) - parseFloat(this.mul(num2, baseNum))), baseNum)).toFixed(precision));
    },

    /**
     * 乘法运算, 避免数据相乘小数点后产生多位数和计算精度损失.
     *
     * @param num1  被乘数
     * @param num2  乘数
     */

    mul: function (num1, num2) {
        if(isNaN(num1) || num1 == null) {
            num1 = 0;
        }
        if(isNaN(num2) || num2 == null) {
            num2 = 0;
        }
        var baseNum = 0;
        try {
            baseNum += num1.toString().split(".")[1].length;
        } catch (e) {
        }
        try {
            baseNum += num2.toString().split(".")[1].length;
        } catch (e) {
        }
        return this.toolNumber(Number(num1.toString().replace(".", "")) * Number(num2.toString().replace(".", "")) / Math.pow(10, baseNum));
    },

    /**
     * 除法运算, 避免数据相除小数点后产生多位数和计算精度损失.
     *
     * @param num1  被除数
     * @param num2  除数
     */

    div: function (num1, num2) {
        if(isNaN(num1) || num1 == null) {
            num1 = 0;
        }
        if(isNaN(num2) || num2 == null) {
            return;
        }
        var baseNum1 = 0, baseNum2 = 0;
        var baseNum3, baseNum4;
        try {
            baseNum1 = num1.toString().split(".")[1].length;
        } catch (e) {
            baseNum1 = 0;
        }
        try {
            baseNum2 = num2.toString().split(".")[1].length;
        } catch (e) {
            baseNum2 = 0;
        }
        baseNum3 = Number(num1.toString().replace(".", ""));
        baseNum4 = Number(num2.toString().replace(".", ""));
        return this.toolNumber((baseNum3 / baseNum4) * Math.pow(10, baseNum2 - baseNum1));
    },

    /**
     * 把科学计数法 转成字符串
     * 例: -1e-8 = -0.000000001
     *
     * @param num_str
     */

    toolNumber: function (num_str) {
        if(isNaN(num_str) || num_str == null) {
            num_str = 0;
        }
        num_str = Number(num_str);
        var m = num_str.toExponential().Match(/\d(?:\.(\d*))?e([+-]\d+)/);
        return num_str.toFixed(Math.max(0, (m[1] || '').length - m[2]));
    },

    /**
     * 校验数字 ( 小数点后n位 )
     *
     * @param val
     * @param n
     * @returns {string}
     */

    clearNum: function (val, n) {
        if(isNaN(n) || n == null) {
            n = 0;
        }
        if(isNaN(val) || val == null) {
            val = 0;
        }
        val = val.toString();
        var index = val.indexOf(".");
        if(index === 0) {
            val = '0.';
        }
        val = val.replace(/[`\d.]/g, "");   // 清除"数字"和"."以外的字符
        val = val.replace(/\.{2,}/g, ".");   // 只保留第一个.  清除多余的
        val = val.replace(".", "$#$").replace(/\./g, "").replace("$#$", ".");

        var reg = new RegExp('`(\\-)*(\\d+)\\.(\\d{'+ n +'}).*$');
        val = val.replace(reg, '$1$2.$3');    //只能输入n个小数
        if(index < 0 && val !== "") {
            val = parseFloat(val);
        }
        // 整数位最多10位
        var valArr = val.toString().split(".");
        var num = valArr[0].substring(0, 10);
        if(valArr.length > 1) {
            num += '.' + valArr[1];
        }
        val = num;
        return val;
    },

    /**
     * 离开input 规整value防止1. 2. 这样的数
     *
     * @param val
     */

    blurNum: function (val) {
        if(isNaN(val) || val == null) {
            val = 0;
        }
        val = val.toString();
        var index = val.indexOf(".");
        if(index > 0 && index === val.length - 1) {
            val = parseFloat(val);
        }
        return val;
    },

    formatSeconds: function (value) {
        if(isNaN(value) || value == null) {
            value = 0;
        }
        var secondTime = parseInt(value);  //秒
        var minuteTime = 0;   //分
        var hourTime = 0;   //小时
        if(secondTime > 60) {  // 如果秒数大于60, 将秒数转换成整数
            // 获取分钟, 除以60取整数, 得到整数分钟
            minuteTime = parseInt(secondTime / 60);
            // 获取秒数, 秒数取余, 得到整数秒数
            secondTime = parseInt(secondTime % 60);
            // 如果分钟大于60, 将分钟转换成小时
            if(minuteTime > 60) {
                // 获取小时, 获取分钟除以60, 得到整数小时
                hourTime = parseInt(minuteTime / 60);
                // 获取小时后取余的分, 获取分钟除以60取余的分
                minuteTime = parseInt(minuteTime % 60);
            }
        }
        var result = " " + parseInt(secondTime) + " " + "秒";
        if(minuteTime > 0) {
            result = " " + parseInt(minuteTime) + " " + "分" + result;
        }
        if(hourTime > 0) {
            result = " " + parseInt(hourTime) + " " + "小时" + result;
        }
        return result;
    },
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249

用法

import numUtil from '@/components/utils/numUtil';
1

// 离焦事件
blurNum(){
	// 规整value 防止 1. 2. 这样的数
	this.amount = numUtil.blurNum(this.amount);
}
1
2
3
4
5