xy-tool-ui/package/y-design-form-rules/src/exec2.js

XiaoYi tool compenent library

const
    // 正负 2位小数
    positive_negative_decimal_two = '(\\-?\\d+(\\.[0-9]{1,2})?)',
    positive_decimal_two = '(\\d+(\\.[0-9]{1,2})?)',
    negative_decimal_two = '(-\\d+(\\.[0-9]{1,2})?)',
    // 正整数
    positive_integer = '\\d+',
    // 负整数
    negative_integer = '(\\-\\d+)',
    // 整数
    integer = '(\\-?\\d+)',
    // 因子
    factor = '(\\$\\d+)';

const number = `(${factor}|${positive_decimal_two}|总分)`;
// 错误正则
let error = [
    { reg: '[^0-9.+\\-*\\/()\\$总分]', msg: '请检查运算符号' },
    // (-)
    { reg: '\\([-+*.\\/]*\\)', msg: '小括号或运算符号使用错误' },
    // (1-) (1+)
    { reg: `\\(${number}[-+*.\\/]+\\)`, msg: '小括号或运算符号使用错误' },
    // (--1) (-+1)
    { reg: `\\([-+*.\\/]+\\)${number}`, msg: '小括号或运算符号使用错误' },

    // 11$1
    { reg: `${number}\\$${number}`, msg: '公式使用错误' },


    // 1(
    { reg: `${number}\\(`, msg: '缺少运算符号' },
    // )(
    { reg: '\\)\\(', msg: '缺少运算符号' },
    // )1
    { reg: `\\)${number}`, msg: '缺少运算符号' },

    // -+ 、 -+ 、 (---) 、 1-+1 、 1/--1 、 1++1 、 1++-1 、 1/+-*1 、 1+/-1 、 11-*1 、 1-*-1 、 1---1、1+/1
    { reg: '([\\*\\/\\+]{2,}[\\*\\/\\+\\-]*)|[\\*\\/\\+\\-]{3,}|(-[\\+\\*\\/]{1,})', msg: '运算符号使用错误' },
    // 01、0
    { reg: '[^0-9.]0\\d+', msg: '数字首位不允许出现0' },
    // 0
    { reg: '(?<=\\/)(?:0(?!\\.\\d+))', msg: '被除数不能为0' }
];
// 括号验证正则 支持负数 、(1)、(-1)、(-1.11)、(1.11)(1+1)(-1+1)
const brackets = `\\((${factor}|${positive_negative_decimal_two}|总分)([-+*\\/](${factor}|${positive_negative_decimal_two}|总分))*\\)|\\((${factor}|${positive_negative_decimal_two}|总分)\\)`;
// 正确正则
let success = [
    { reg: `^(${number}|${factor})((\\+|\\-|\\*|\\/)(${number}|${factor}))+$|^(${number}|${factor})$`, msg: '公式验证失败', remark: '整体验证' }
];

// 完整公式的验证 ((\-?\d+(\.[0-9]{1,2})?)|(\$\d+))((\+|\-|\*|\/)((\-?\d+(\.[0-9]{1,2})?)|(\$\d+)))+

export function exec(exec, notFactorList, error_regex, succes_regex) {
    if (!exec) {
        return true;
    }
    console.log('数字：', number, brackets, typeof error_regex);
    console.log('输入：', exec);
    // 格式化空格
    let ql = replaceAllBlank(exec);
    // 因子处理
    if (notFactorList) {
        let replace = ql.replace(new RegExp(`\\$(${notFactorList.join('|')})(?!\\d+)`, 'g'), '1');
        let match = replace.match(/\$\d+/);
        if (match) {
            return ('出现未知因子：' + match);
        }
    }
    let error_list = [];
    if (error_regex && typeof error_regex == 'object') {
        error_list = error_regex.concat(error);
    } else {
        error_list = error;
    }
    console.log('error_list:', error_list);
    // 验证数组 错误验证
    let result = error_list.find(it => ql.match(new RegExp(it.reg)));
    console.log(result);

    if (result) {
        return result.msg;
    }

    //  小括号验证逻辑
    let isNOtFoundBracketsBoolean = true;
    while (isNOtFoundBracketsBoolean) {
        if ((/\(.*\)/).test(ql)) {
            ql = ql.replace(new RegExp(brackets), '9');
        } else if ((/\(/).test(ql)) {
            return ('运算公式 ‘(’ 使用错误');
        } else if ((/\)/).test(ql)) {
            return ('运算公式 ‘)’ 使用错误');
        } else {
            isNOtFoundBracketsBoolean = false;
        }
    }
    // 处理其余负数
    ql = ql.replace(/^(?:\-)(?=\d+)|(?<=[-+*\/(])(?:\-)(?=\d+)/gm, '');
    console.log(ql);

    let success_list = [];
    // 正确的完整公式的验证
    if (succes_regex && typeof succes_regex == 'object') {
        success_list = succes_regex.concat(success);
    } else {
        success_list = success;
    }
    console.log('success_list:', success_list);
    result = success_list.filter(it => !ql.match(new RegExp(it.reg)));
    console.log(result);
    if (result[0]) {
        return result[0].msg;
    }
    return true;
}

// 去除空格
function replaceAllBlank(exec) {
    return exec.replace(/\s/gm, '');
}

// 验证对称左右括号数量验证
function verifyBrackets(formulaStr) {
    var ql_left = formulaStr.match(/\(/ig) || [];
    var ql_right = formulaStr.match(/\)/ig) || [];
    if (ql_left.length != ql_right.length) {
        if (ql_left > ql_right) {
            throw new Error(`${formulaStr}'运算公式'('使用错误`);
        }
        if (ql_left < ql_right) {
            throw new Error(`${formulaStr}'运算公式')'使用错误`);
        }
    }
}

// let number = '', error = [], brackets = '', success = []
// function init (numberType, otherList) {
//   let config = otherList || []
//
//   if (numberType == '正负2位小数') {
//     config.push(positive_negative_decimal_two)
//   } else if (numberType == '正2位小数') {
//     config.push(positive_decimal_two)
//   } else if (numberType == '负2位小数') {
//     config.push(negative_decimal_two)
//   } else if (numberType == '正整数') {
//     config.push(positive_integer)
//   } else if (numberType == '负整数') {
//     config.push(negative_integer)
//   } else if (numberType == '整数') {
//     config.push(integer)
//   }
//
//   number = `(${config.join('|')})`
// // 错误正则
//   error = [
//     // { reg: `[^0-9.+\\-*\\/()\\$]`, msg: '请检查运算符号' },
//     // 11$1
//     // { reg: `${number}\\$${number}`, msg: '未知因子' },
//     // 1(
//     { reg: `${number}\\(`, msg: '缺少运算符号' },
//     // )1
//     { reg: `\\)${number}`, msg: '缺少运算符号' },
//     // -+ 、 -+ 、 (---) 、 1-+1 、 1/--1 、 1++1 、 1++-1 、 1/+-*1 、 1+/-1 、 11-*1 、 1-*-1 、 1---1、1+/1
//     { reg: `([\\*\\/\\+]{2,}[\\*\\/\\+\\-]*)|[\\*\\/\\+\\-]{3,}|(-[\\+\\*\\/]{1,})`, msg: '运算符号使用错误' },
//     // 01、0
//     { reg: `[^0-9.]0\\d+`, msg: '数字首位不允许出现0' },
//     // 0
//     { reg: `(${number}\/0\\d*)|(\\)\/0\\d*)`, msg: '被除数不能为0' },
//   ]
// // 括号验证正则
//   brackets = `\\(${number}([-+*\\/]${number})*\\)`
// // 正确正则
//   success = [
//     { reg: `^(${number}|${factor})((\\+|\\-|\\*|\\/)(${number}|${factor}))+$`, msg: '公式验证失败', remark: '整体验证' }
//   ]
// }