/**
|
* 计算多个数值的和
|
*
|
* @param val 数值型参数，可变长参数列表
|
* @returns 返回所有参数的和，如果参数列表为空或参数类型非数值型，则返回null
|
*/
|
function SUM(...val) {
|
try {
|
let num = null;
|
if (val && val.length > 0) {
|
val.forEach((item) => {
|
num += item;
|
});
|
}
|
return num;
|
} catch (error) {}
|
}
|
/**
|
* 计算传入参数中的最大值
|
*
|
* @param ...val 可变参数列表，用于计算最大值的数值或可转换为数值的类型
|
* @returns 返回最大值，如果参数列表为空或为null/undefined/''，则返回null
|
*/
|
function MAX(...val) {
|
try {
|
let max = null;
|
if (val && val.length > 0) {
|
val = val.filter((item) => item != null && item !== "");
|
if (val.length > 0) {
|
max = Math.max(...val);
|
} else {
|
max = null;
|
}
|
}
|
return max;
|
} catch (error) {}
|
}
|
/**
|
* 计算传入参数中的最小值
|
*
|
* @param val 可变参数，用于计算最小值的数值数组
|
* @returns 返回传入参数中的最小值，如果传入参数为空或所有值均为null或空字符串，则返回null
|
*/
|
function MIN(...val) {
|
try {
|
let min = null;
|
if (val && val.length > 0) {
|
val = val.filter((item) => item != null && item !== "");
|
if (val.length > 0) {
|
min = Math.min(...val);
|
}
|
}
|
return min;
|
} catch (error) {}
|
}
|
/**
|
* 计算给定数值的平均值
|
*
|
* @param val 数值列表，可包含任意个参数
|
* @returns 返回平均值，如果数值列表为空或包含非数值项，则返回null
|
*/
|
function AVERAGE(...val) {
|
try {
|
let num = null;
|
let arr = [];
|
if (val && val.length > 0) {
|
arr = val.filter((item) => item != null && item !== "");
|
arr.forEach((item) => {
|
num += item;
|
});
|
if (arr.length > 0) {
|
return num / arr.length;
|
} else {
|
return null;
|
}
|
} else {
|
return null;
|
}
|
} catch (error) {}
|
}
|
/**
|
* 计算一个数的绝对值
|
*
|
* @param val 任意数值
|
* @returns 返回该数值的绝对值
|
*/
|
function ABS(val) {
|
try {
|
return Math.abs(val);
|
} catch (error) {}
|
}
|
/**
|
* 计算一组数字的中位数
|
*
|
* @param val 任意个参数，需要计算中位数的数字
|
* @returns 如果参数中有有效的数字，则返回计算出的中位数；否则返回null
|
*/
|
function MEDIAN(...val) {
|
try {
|
let arr = [];
|
if (val && val.length > 0) {
|
arr = val.filter((item) => item != null && item !== "");
|
const sortedArr = arr.sort((a, b) => a - b);
|
// 计算中位数
|
const half = Math.floor(sortedArr.length / 2);
|
if (arr.length > 0) {
|
// 如果数组长度是奇数，直接取中间的元素
|
if (sortedArr.length % 2 === 1) {
|
return sortedArr[half];
|
} else {
|
// 如果数组长度是偶数，取中间两个元素的平均值
|
return (sortedArr[half - 1] + sortedArr[half]) / 2;
|
}
|
} else {
|
return null;
|
}
|
} else {
|
return null;
|
}
|
} catch (error) {}
|
}
|
|
/**
|
* 计算幂
|
*
|
* @param str 字符串形式的幂表达式，例如"2^3"
|
* @returns 返回计算后的幂值，如果表达式无效则返回null
|
*/
|
function CalculatePower(str) {
|
try {
|
if (str && str.includes("^")) {
|
let arr = str.split("^");
|
if (arr && arr.length > 1) {
|
return Math.pow(arr[0], arr[1]);
|
} else {
|
return null;
|
}
|
}
|
} catch (error) {}
|
}
|
|
/**
|
* 根据坐标获取列名
|
* @param {Object} cellId
|
*/
|
function getColumnNameFromId(cellId) {
|
try {
|
if (!Array.isArray(cellId)) {
|
cellId = cellId.split("-");
|
}
|
var i = cellId[0];
|
var letter = "";
|
if (i > 701) {
|
letter += String.fromCharCode(64 + parseInt(i / 676));
|
letter += String.fromCharCode(64 + parseInt((i % 676) / 26));
|
} else if (i > 25) {
|
letter += String.fromCharCode(64 + parseInt(i / 26));
|
}
|
letter += String.fromCharCode(65 + (i % 26));
|
return letter + (parseInt(cellId[1]) + 1);
|
} catch (e) {
|
console.log("error", cellId);
|
}
|
}
|
/**
|
* 根据列名获取坐标
|
* @param {Object} id
|
* @param {Object} arr
|
*/
|
function getIdFromColumnName(id, arr) {
|
try {
|
// Get the letters
|
var t = /^[a-zA-Z]+/.exec(id);
|
if (t) {
|
// Base 26 calculation
|
var code = 0;
|
for (var i = 0; i < t[0].length; i++) {
|
code +=
|
parseInt(t[0].charCodeAt(i) - 64) * Math.pow(26, t[0].length - 1 - i);
|
}
|
code--;
|
// Make sure jexcel starts on zero
|
if (code < 0) {
|
code = 0;
|
}
|
|
// Number
|
var number = parseInt(/[0-9]+$/.exec(id));
|
if (number > 0) {
|
number--;
|
}
|
|
if (arr == true) {
|
id = [code, number];
|
} else {
|
// id = code + '-' + number;
|
id = {
|
c: code,
|
r: number,
|
};
|
}
|
}
|
return id;
|
} catch (e) {
|
console.log("error", id);
|
}
|
}
|
|
/**
|
* 更改参数
|
*
|
* @param f 参数列表
|
* @returns 返回一个包含坐标信息的数组
|
*/
|
function changeParameter(f) {
|
try {
|
let arr = getABCList(f);
|
let arr2 = [];
|
arr.forEach((item) => {
|
if (item.includes(":")) {
|
let r0 = getIdFromColumnName(item.split(":")[0]).r;
|
let c0 = getIdFromColumnName(item.split(":")[0]).c;
|
let r1 = getIdFromColumnName(item.split(":")[1]).r;
|
let c1 = getIdFromColumnName(item.split(":")[1]).c;
|
for (let i = Number(r0); i <= Number(r1); i++) {
|
for (let u = Number(c0); u <= Number(c1); u++) {
|
arr2.push({
|
r: i,
|
c: u,
|
});
|
}
|
}
|
} else {
|
arr2.push(getIdFromColumnName(item));
|
}
|
});
|
return arr2;
|
} catch (error) {}
|
}
|
/**
|
* 获取包含 ABC 字符的列表
|
*
|
* @param f 字符串，包含需要解析的公式或表达式
|
* @returns 包含 ABC 字符的数组列表
|
*/
|
function getABCList(f) {
|
try {
|
let regex = /[=\+\-\*\%\(\)\/\^\s]/g;
|
let fouList = ["SUM", "MAX", "MIN", "AVERAGE", "ABS"];
|
f = f
|
.replace(regex, ",")
|
.replace(new RegExp('"&', "g"), "")
|
.replace(new RegExp('&"', "g"), "");
|
fouList.forEach((item) => {
|
f = f.replace(new RegExp(item, "g"), "");
|
});
|
let arr = f.split(",").filter((item) => {
|
return (
|
item && /[a-zA-Z]/.test(item) && item != "undefined" && item != "null"
|
);
|
});
|
return arr;
|
} catch (error) {}
|
}
|
/**
|
* 获取所有单元格
|
*
|
* @param f 表格数据或相关参数
|
* @returns 返回一个对象，其键为单元格的唯一标识符（由列和行ID拼接而成），值为null
|
*/
|
function getAllCell(f) {
|
try {
|
let arr = changeParameter(f);
|
let arr0 = {};
|
arr.forEach((item) => {
|
arr0[getColumnNameFromId(`${item.c}` + "-" + `${item.r}`)] = null;
|
});
|
return arr0;
|
} catch (error) {}
|
}
|
|
/**
|
* 计算函数
|
*
|
* @param f 字符串类型，表示待计算的公式
|
* @param comValue 对象类型，表示要替换的单元格值，键为单元格名称，值为替换后的值
|
* @returns 返回计算后的结果，如果计算失败则返回0
|
*/
|
function compute(f, comValue) {
|
try {
|
let str = f;
|
// 获取单元格对应值
|
let arr = getAllCell(f);
|
for (var a in comValue) {
|
if (
|
comValue[a] !== "undefined" &&
|
comValue[a] !== "null" &&
|
comValue[a] !== undefined
|
) {
|
if (typeof comValue[a] == "string" && comValue[a].includes("^")) {
|
// 计算幂次
|
arr[a] = CalculatePower(comValue[a]);
|
} else if (
|
typeof comValue[a] == "string" &&
|
comValue[a].includes("/")
|
) {
|
arr[a] = comValue[a];
|
} else {
|
arr[a] = comValue[a];
|
}
|
}
|
}
|
// 解析公式参数，特别是带：的
|
let arr0 = getABCList(f);
|
let obj = {};
|
arr0.forEach((item) => {
|
if (item.includes(":")) {
|
let arr1 = [];
|
let r0 = getIdFromColumnName(item.split(":")[0]).r;
|
let c0 = getIdFromColumnName(item.split(":")[0]).c;
|
let r1 = getIdFromColumnName(item.split(":")[1]).r;
|
let c1 = getIdFromColumnName(item.split(":")[1]).c;
|
for (let i = Number(r0); i <= Number(r1); i++) {
|
for (let u = Number(c0); u <= Number(c1); u++) {
|
arr1.push({
|
r: i,
|
c: u,
|
});
|
}
|
}
|
let arr2 = [];
|
arr1.forEach((m) => {
|
arr2.push(getColumnNameFromId(`${m.c}` + "-" + `${m.r}`));
|
});
|
obj[item.split(":").join("-")] = arr2.join(",");
|
} else {
|
obj[item] = item;
|
}
|
});
|
str = str.replace(new RegExp(":", "g"), "");
|
// 替换参数
|
for (var a in obj) {
|
str = str.replace(new RegExp(a, "g"), obj[a]);
|
}
|
// 计算
|
for (var a in arr) {
|
str = str.replace(new RegExp(a, "g"), arr[a]);
|
}
|
return eval(str);
|
} catch (error) {}
|
}
|
|
export default {
|
compute,
|
changeParameter,
|
};
|
