当前位置：网站首页>关于不等式取值转义的思路

关于不等式取值转义的思路

2022-06-26 18:39:00 【51CTO】

最近遇到一个需求，前端填写不等式，后端需要需要进行存储，并在使用时需要将不等式转义成区间的形式，下面分享下大体的解决思路，仅供参考。

一、和前端约定传递的数据格式

前端的页面展示是这样的

关于不等式取值转义的思路_版本号

和前端约定的传参格式为

       
       gt
       
       @1
       
       .0
       
       .0  
       
       //大于1.0.0
       
       ge
       
       @1
       
       .0
       
       .0  
       
       //大于等于1.0.0
       
       lt
       
       @1
       
       .0
       
       .0  
       
       //小于1.0.0
       
       le
       
       @1
       
       .0
       
       .0  
       
       //小于等于1.0.0
       
       eq
       
       @1
       
       .0
       
       .0  
       
       //等于1.0.0
       
       ne
       
       @1
       
       .0
       
       .0  
       
       //不等于1.0.0
      
1.
2.
3.
4.
5.
6.

利用 @ 符号对符号和版本号进行分隔，在后续入库时也可以根据这个符号进行切割，有多条规则可以传字符串数组，也可以传用逗号分隔的字符串

二、入库前校验

       
       //多条规则版本号最大值最小值校验
       
       versionRangeList :
       
       = 
       
       strings
       
       .
       
       Split(
       
       body
       
       .
       
       VersionRange, 
       
       ",")
       
       switch 
       
       len(
       
       versionRangeList) {
       
       case 
       
       1:
       
       version :
       
       = 
       
       strings
       
       .
       
       Split(
       
       versionRangeList[
       
       0], 
       
       "@")
       
       switch 
       
       version[
       
       0] {
       
       case 
       
       GT, 
       
       GE, 
       
       LT, 
       
       LE, 
       
       EQ, 
       
       NE:
       
       //正常规则
       
       default:
       
       return 
       
       tracerr
       
       .
       
       NewError(
       
       "规则不合法，传参异常：" 
       
       + 
       
       versionRangeList[
       
       0])
       
        }
       
       case 
       
       2:
       
       version1 :
       
       = 
       
       strings
       
       .
       
       Split(
       
       versionRangeList[
       
       0], 
       
       "@")
       
       version2 :
       
       = 
       
       strings
       
       .
       
       Split(
       
       versionRangeList[
       
       1], 
       
       "@")
       
       switch 
       
       version1[
       
       0] {
       
       case 
       
       GT, 
       
       GE:
       
       if 
       
       version1[
       
       1] 
       
       >= 
       
       version2[
       
       1] 
       
       || (
       
       version2[
       
       0] 
       
       != 
       
       LT 
       
       && 
       
       version2[
       
       0] 
       
       != 
       
       LE) {
       
       return 
       
       tracerr
       
       .
       
       NewError(
       
       "规则不合法，版本号最小值没有小于最大值")
       
            }
       
       case 
       
       LT, 
       
       LE:
       
       if 
       
       version1[
       
       1] 
       
       <= 
       
       version2[
       
       1] 
       
       || (
       
       version2[
       
       0] 
       
       != 
       
       GT 
       
       && 
       
       version2[
       
       0] 
       
       != 
       
       GE) {
       
       return 
       
       tracerr
       
       .
       
       NewError(
       
       "规则不合法，版本号最小值没有小于最大值")
       
            }
       
       default:
       
       return 
       
       tracerr
       
       .
       
       NewError(
       
       "规则不合法，多条规则只能选择：gt,ge,lt,le")
       
        }
       
       default:
       
       return 
       
       tracerr
       
       .
       
       NewError(
       
       "规则不合法，规则数量异常，规则数量为：" 
       
       + 
       
       strconv
       
       .
       
       Itoa(
       
       len(
       
       versionRangeList)))
       
    }
      
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.

三、转义成区间

因为在使用时需要将不等式转换为区间的形式传给其他模块，因此我选择创建一个map，建立不等式与区间格式的对应关系

       
       //不等式常量
       
       const (
       
       GT 
       
       = 
       
       "gt" 
       
       //大于
       
       GE 
       
       = 
       
       "ge" 
       
       //大于等于
       
       LT 
       
       = 
       
       "lt" 
       
       //小于
       
       LE 
       
       = 
       
       "le" 
       
       //小于等于
       
       EQ 
       
       = 
       
       "eq" 
       
       //等于
       
       NE 
       
       = 
       
       "ne" 
       
       //不等于
       
)
       
       func 
       
       RuleReversal(
       
       versionRange []
       
       string) (
       
       reversalResult 
       
       string) {
       
       //反转规则Map
       
       ruleReversalMap :
       
       = 
       
       map[
       
       string]
       
       string{
       
       GT: 
       
       "(,Ver]",
       
       GE: 
       
       "(,Ver)",
       
       LT: 
       
       "[Ver,)",
       
       LE: 
       
       "(Ver,)",
       
       EQ: 
       
       "(,Ver),(Ver,)",
       
       NE: 
       
       "[Ver]",
       
    }
       
       switch 
       
       len(
       
       versionRange) {
       
       case 
       
       1:
       
       version :
       
       = 
       
       strings
       
       .
       
       Split(
       
       versionRange[
       
       0], 
       
       "@")
       
       reversalResult 
       
       = 
       
       strings
       
       .
       
       ReplaceAll(
       
       ruleReversalMap[
       
       version[
       
       0]], 
       
       "Ver", 
       
       version[
       
       1])
       
       case 
       
       2:
       
       version1 :
       
       = 
       
       strings
       
       .
       
       Split(
       
       versionRange[
       
       0], 
       
       "@")
       
       version2 :
       
       = 
       
       strings
       
       .
       
       Split(
       
       versionRange[
       
       1], 
       
       "@")
       
       switch 
       
       version1[
       
       0] {
       
       case 
       
       GT, 
       
       GE:
       
       reversalResult 
       
       = 
       
       strings
       
       .
       
       ReplaceAll(
       
       ruleReversalMap[
       
       version1[
       
       0]], 
       
       "Ver", 
       
       version1[
       
       1]) 
       
       + 
       
       "," 
       
       + 
       
       strings
       
       .
       
       ReplaceAll(
       
       ruleReversalMap[
       
       version2[
       
       0]], 
       
       "Ver", 
       
       version2[
       
       1])
       
       case 
       
       LT, 
       
       LE:
       
       reversalResult 
       
       = 
       
       strings
       
       .
       
       ReplaceAll(
       
       ruleReversalMap[
       
       version1[
       
       0]], 
       
       "Ver", 
       
       version1[
       
       1]) 
       
       + 
       
       "," 
       
       + 
       
       strings
       
       .
       
       ReplaceAll(
       
       ruleReversalMap[
       
       version2[
       
       0]], 
       
       "Ver", 
       
       version2[
       
       1])
       
       default:
       
       tracerr
       
       .
       
       Print(
       
       errors
       
       .
       
       New(
       
       "规则不合法，版本不等式异常：" 
       
       + 
       
       version1[
       
       0]))
       
       return 
       
       ""
       
        }
       
       default:
       
       tracerr
       
       .
       
       Print(
       
       errors
       
       .
       
       New(
       
       "规则不合法，规则数量异常，规则数量为：" 
       
       + 
       
       strconv
       
       .
       
       Itoa(
       
       len(
       
       versionRange))))
       
       return 
       
       ""
       
    }
       
       return 
       
       reversalResult
       
}
      
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.