bytev-charts-beta1.0
Version:
测试版-1.0,版本号为小版本; 基于echarts和JavaScript及ES6封装的一个可以直接调用的图表组件库，内置主题设计，简单快捷，且支持用户自定义配置； npm 安装方式: npm install bytev-charts 若启动提示还需额外install插件,则运行 npm install @babel/runtime-corejs2 即可;
322 lines (271 loc) • 10.3 kB
JavaScript
import _classCallCheck from "@babel/runtime-corejs2/helpers/classCallCheck";
import _createClass from "@babel/runtime-corejs2/helpers/createClass";
import _parseInt from "@babel/runtime-corejs2/core-js/parse-int";
import _Object$assign from "@babel/runtime-corejs2/core-js/object/assign";
import _parseFloat from "@babel/runtime-corejs2/core-js/parse-float";
import "core-js/modules/es.regexp.exec.js";
import "core-js/modules/es.string.replace.js";
import "core-js/modules/es.date.to-string.js";
import "core-js/modules/es.object.to-string.js";
import "core-js/modules/es.regexp.to-string.js";
import "core-js/modules/es.array.concat.js";
import "core-js/modules/es.array.slice.js";
import "core-js/modules/es.number.to-fixed.js";
import "core-js/modules/es.array.join.js";
import "core-js/modules/es.string.split.js";
import "core-js/modules/es.array.last-index-of.js";
import "core-js/modules/es.array.for-each.js";
import "core-js/modules/web.dom-collections.for-each.js";
import "core-js/modules/es.number.constructor.js";
var Util = /*#__PURE__*/function () {
function Util() {// Util.addMathProperty()
_classCallCheck(this, Util);
}
_createClass(Util, null, [{
key: "guid",
value: function guid() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = Math.random() * 16 | 0,
v = c == 'x' ? r : r & 0x3 | 0x8;
return v.toString(16);
});
} //十六进制颜色值转换为rgba
}, {
key: "colorRgba",
value: function colorRgba(sHex) {
// 十六进制颜色值的正则表达式
var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{4}|[0-9a-fA-f]{6}|[0-9a-fA-f]{8})$/;
/* 16进制颜色转为RGB格式 */
var sColor = sHex.toLowerCase();
var alpha = 1;
if (sColor && reg.test(sColor)) {
if (sColor.length === 4 || sColor.length === 5) {
var sColorNew = '#';
for (var i = 1; i < sColor.length; i += 1) {
sColorNew += sColor.slice(i, i + 1).concat(sColor.slice(i, i + 1));
}
sColor = sColorNew;
} // 如果有透明度再执行
if (sColor.length === 9) {
alpha = (_parseInt('0x' + sColor.slice(7, 9)) / 255).toFixed(2);
} // 处理六位的颜色值
var sColorChange = [];
for (var _i = 1; _i < 7; _i += 2) {
sColorChange.push(_parseInt('0x' + sColor.slice(_i, _i + 2)));
}
return 'rgba(' + sColorChange.join(',') + ',' + alpha + ')';
} else {
return sColor;
}
} //十六进制颜色值转换为rgba数组
}, {
key: "colorRgbaArr",
value: function colorRgbaArr(sHex) {
return this.colorRgba(sHex).replace(/rgba/g, '').replace(/rgb/g, '').replace('(', '').replace(')', '').split(',');
} //获取后缀名
}, {
key: "getSuffix",
value: function getSuffix(filename) {
if (filename) {
var index = filename.lastIndexOf(".");
if (index != -1) {
return filename.substring(index + 1);
}
}
}
/*
* 为Math添加方法
* JS中计算出现无限小数位问题，浮点数计算精度的问题，四则运算封装
* */
}, {
key: "addMathProperty",
value: function addMathProperty() {
_Object$assign(Math, {
/*
* 加法 - 解决JS中计算出现无限小数位问题，浮点数计算精度的问题
* 方法中主要的部分是乘数和最后return的算法，如果不用封装的话，可以自己写一个比较大的数字，比如100000000，先把两个加数分别乘以这个数，这样也可以计算正确，除非你知道你的数字范围，否则不建议这样做。
* */
add: function add(num1, num2) {
/*
if (parseFloat(num1).toString() == "NaN" || parseFloat(num2).toString() == "NaN") return false;
let r1 = 0, r2 = 0;
try {
r1 = num1.toString().split(".")[1].length;
} catch (e) {
}
try {
r2 = num2.toString().split(".")[1].length;
} catch (e) {
}
let n = Math.pow(10, Math.max(r1, r2));
return (num1 * n + num2 * n) / n;
*/
var arr = [num1 || 0, num2 || 0];
var fieldArr = [];
var m;
for (var i = 0; i < arr.length; i++) {
var field = void 0;
try {
field = arr[i].toString().split('.')[1].length;
} catch (e) {
field = 0;
}
fieldArr.push(field);
}
m = Math.pow(10, Math.max.apply(Math, fieldArr));
var add = 0;
arr.forEach(function (item) {
add = add + item * m;
});
var sum = Math.round(add) / m;
return sum;
},
/*
* 减法 - 解决JS中计算出现无限小数位问题，浮点数计算精度的问题
* 减法运算的原理和加法一样，都是先乘以较大的数字，不多介绍！
* */
sub: function sub(num1, num2) {
if (_parseFloat(num1).toString() == "NaN" || _parseFloat(num2).toString() == "NaN") return;
var r1 = 0,
r2 = 0;
try {
r1 = num1.toString().split(".")[1].length;
} catch (e) {}
try {
r2 = num2.toString().split(".")[1].length;
} catch (e) {}
var m = Math.pow(10, Math.max(r1, r2));
return (num1 * m - num2 * m) / m;
},
/*
* 乘法 - 解决JS中计算出现无限小数位问题，浮点数计算精度的问题
* 乘法的计算主要是将数字转换为整数相乘再除以10的N次幂
* */
mul: function mul(num1, num2) {
if (_parseFloat(num1).toString() == "NaN" || _parseFloat(num2).toString() == "NaN") return;
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);
},
/*
* 除法 - 解决JS中计算出现无限小数位问题，浮点数计算精度的问题
* 乘法的计算主要是将数字转换为整数相乘再除以10的N次幂
* */
div: function div(num1, num2) {
if (_parseFloat(num1).toString() == "NaN" || _parseFloat(num2).toString() == "NaN") return;
var t1 = 0,
t2 = 0,
r1,
r2;
try {
t1 = num1.toString().split(".")[1].length;
} catch (e) {}
try {
t2 = num2.toString().split(".")[1].length;
} catch (e) {}
r1 = Number(num1.toString().replace(".", ""));
r2 = Number(num2.toString().replace(".", ""));
return r1 / r2 * Math.pow(10, t2 - t1);
}
});
}
/**
* 将数字取整为指定10的倍数，并支持向上或者向下取整, 且支持是否返回原包含的小数位
* @param {Number} num 需要取整的值
* @param {Number} prec 需要用0占位的数量(默认除第一位外其余全部使用0占位)
* @param {Boolean} ceil 是否向上取整
* @param {Boolean} float 是否包含原小数位
*
// formatInt(2345, 2, true) -> 2400
// formatInt(2345, 2. false) -> 2300
// formatInt(2345, 3, true) -> 3000
// formatInt(2345, 3, false) -> 2000
*/
// static formatInt (num, prec = 2, ceil = false, float = false) {
}, {
key: "number2TenMultiples",
value: function number2TenMultiples(num) {
var prec = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var ceil = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
var _float = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
if (!prec) {
prec = String(_parseInt(num)).length - 1;
}
var fot = String(num).split('.');
fot = fot[1] != undefined ? fot[1] : '';
var len = String(_parseInt(num)).length;
if (len <= prec) {
return num;
}
var mult = Math.pow(10, prec);
if (ceil) {
return Number(Math.ceil(num / mult) * mult + f());
} else {
return Number(Math.floor(num / mult) * mult + f());
}
function f() {
if (_float) {
var s = '.';
for (var i = 0; i < fot.length; i++) {
s += '0';
}
return s;
}
return '';
}
}
/*
* 对象深度合并，将后面的对象深度合并至前面的对象中
* */
// static deepAssign(target, source, source2, source3, source4, source5){
// if(!source){
// console.log("The function deepAssign need at least 1 source")
// return target
// }
// let arr = [source5, source4, source3, source2, source, target]
// xx()
// return target
// function xx(){
// if(arr.length>1){
// assign(arr[0], arr[1])
// arr.
// xx()
// }
// }
//
// function assign(a, b){
// for(let k in b){
// if(a[k] instanceof Object){
// assign(a[k], b[k])
// }else{
// Object.assign(a, b)
// }
// }
// }
// }
/*
* 对象深度合并，将后面的对象深度合并至前面的对象中
* */
}, {
key: "deepAssign",
value: function deepAssign(target, source) {
return deepObjectMerge(target, source);
function deepObjectMerge(FirstOBJ, SecondOBJ) {
// 深度合并对象
for (var key in SecondOBJ) {
FirstOBJ[key] = FirstOBJ[key] && FirstOBJ[key].toString() === "[object Object]" ? deepObjectMerge(FirstOBJ[key], SecondOBJ[key]) : FirstOBJ[key] = SecondOBJ[key];
}
return FirstOBJ;
}
}
}]);
return Util;
}();
export { Util as default };