怎样写一个能够校验复杂规则的正则表达式？“太复杂，不常用，学不来” .... 显然，这样的代码是无法维护的。但是我可以

#写在前面

每当提到正则表达式，身边很多朋友的反应是这样的： “那玩意儿最好不要用，没法维护！”， “太复杂，不常用，学不来” .... 不可否认，正则的表达形式，让人看起来的确有些难以理解，如果某天你接手维护一段代码，当你满怀好奇地打开代码文件，发现里面很多代码长成这个样子：

let funCallRegExp = /(^(\s+)?(((?!(class|function))([a-zA-Z_][a-zA-Z0-9_]*))(\(((\s+)?((?!(class|function))([a-zA-Z_][a-zA-Z0-9_]*))(\s+)?)(,((\s+)?((?!(class|function))([a-zA-Z_][a-zA-Z0-9_]*))(\s+)?))*\)))(\s+)?(,(\s+)?(((?!(class|function))([a-zA-Z_][a-zA-Z0-9_]*))(\(((\s+)?((?!(class|function))([a-zA-Z_][a-zA-Z0-9_]*))(\s+)?)(,((\s+)?((?!(class|function))([a-zA-Z_][a-zA-Z0-9_]*))(\s+)?))*\)))(\s+)?)*)$/gm;

显然，这样的代码是无法维护的。但是我可以从中揣测出来，它一定是做了一个比较复杂的验证。其实对于这种使用正则做复杂校验的情况，并不等同于洪水猛兽，也是有迹可循的，下面我就给出一种情况，并给出解决方案，希望可以抛砖引玉。 #问题来了现在有一种类似于函数调用的语法，这种调用大概是这样的:

sum(param1, param2), avg(score)

下面列出了接近30多个case来描述对这个语法的各种限制：

describe("validate", () => {
  it("不同方法的调用用逗号分隔,逗号两侧可用空格分隔，也可不分隔", () => {
    expect(validate("sum(param1),avg(score)")).toBe(true);
    expect(validate("sum(param1) ,avg(score)")).toBe(true);
    expect(validate("sum(param1) , avg(score)")).toBe(true);
    expect(validate("sum(param1)  avg(score)")).toBe(false);
    expect(validate("sum(param1)avg(score)")).toBe(false);
  });
  it("整个语句开头或末尾不能出现逗号或无关文字(空格除外)", () => {
    expect(validate(" sum(param1),avg(b)")).toBe(true);
    expect(validate(" sum(param1),avg(b) ")).toBe(true);
    expect(validate("sum(param1),avg(b) ")).toBe(true);
    expect(validate("a sum(test),avg(a)")).toBe(false);
    expect(validate(" sum(param1),avg(b)12")).toBe(false);
    expect(validate("sdf sum(param1),avg(b) sdf")).toBe(false);
  });
  it("函数名&参数:字母或者下划线打头,可由字母数字下划线组成", () => {
    expect(validate("sum(a)")).toBe(true);
    expect(validate("sum(a0)")).toBe(true);
    expect(validate("_sum(a0)")).toBe(true);
    expect(validate("_sum0(_a0)")).toBe(true);
    expect(validate("_sum0(_)")).toBe(true);
    expect(validate("_sum0(1)")).toBe(false);
    expect(validate("_sum0(1a)")).toBe(false);
    expect(validate("2aa(a)")).toBe(false);
  });
  it("函数名&参数:不能包含保留字 class || function", () => {
    expect(validate("afunctiona(a,b)")).toBe(true);
    expect(validate("functiona(a,b)")).toBe(true);
    expect(validate("class(a), a(a,b)")).toBe(false);
    expect(validate("function(a,b)")).toBe(false);
    expect(validate("function(a,b)")).toBe(false);
    expect(validate("sum(a,function)")).toBe(false);
    expect(validate("sum(class,b)")).toBe(false);

    expect(validate("class1(a,b)")).toBe(true);
    expect(validate("function1(a,b)")).toBe(true);
  });
  it("参数间可以存在空格", () => {
    expect(validate("sum(a ,b      ,c)")).toBe(true);
    expect(validate("sum(     a ,   b      ,c)")).toBe(true);
    expect(validate("sum(     a ,   b  ,c)   ,   avg(d,e ,   fff)")).toBe(true);
  });
  it("函数调用可以不传参数", () => {
    expect(validate("sum()")).toBe(true);
    expect(validate("sum( )")).toBe(true);
  });
});

#解决方案越是复杂的问题，越需要对这个问题进行拆解，将它转换为一系列简单的子问题，这些简单的子问题，我们可以很容易的使用正则给出解决方案，然后将这些方案逐一组合起来，也就形成了最终方案。

在这里，可以把我们需要验证的内容拆成一下的部分：

0 . 空格 = 可以出现0个或多个空格 1 . 参数 = 由字母或下划线开头,字母数字或下划线组成 2 . 无保留字参数 = 参数 && 不包含关键词 3 . 可包含空格参数 = 无保留字参数 && 参数头尾可以出现0个或多个空格
4 . 参数集 = 多个参数的组合，参数可以是 1 个或多个 5 . 参数块 = 参数集 + 左右括号，可以没有参数集，此时括号内为空，但可以出现0个或多个空格 eg . sum() or sum( ) 6 . 函数名 = 无保留字参数 7 . 函数调用 = 函数名+参数块 8 . 可包含空格的函数调用 = 函数调用 && 函数调用头尾可以出现0个或多个空格
9 . 多函数调用 = 多个函数调用的组合，函数调用可出现1个或多个 10. 最终结果 = 多函数调用 && 头尾不包含除空格外的其它内容

有了以上的的思路，验证方案就已经呼之欲出了，贴出代码：

function validate(inputStr) {
  // 0. 空格 = 可以出现0个或多个空格
  const spaceOrEmpty = ` *`; // 匹配多个空格或空
  // 1. 参数 = 由字母或下划线开头,字母数字或下划线组成
  const param = `[a-zA-Z_][a-zA-Z0-9_]*`;
  // 2. 无保留字参数 = 参数 && 不包含关键词
  const paramWithoutReservedWords = `(?!\\bclass\\b|\\bfunction\\b)(${param})`;
  // 3. 可包含空格参数 = 无保留字参数 && 参数头尾可以出现0个或多个空格
  const paramWithSpaceWithoutReservedWords = `${spaceOrEmpty}${paramWithoutReservedWords}${spaceOrEmpty}`;
  // 4. 参数集 = 多个参数的组合，参数可以是 1 个或多个
  const params = `(${paramWithSpaceWithoutReservedWords}(,${paramWithSpaceWithoutReservedWords})*)`;
  // 5. 参数块 = 参数集 + 左右括号 ，可以没有参数集，此时括号内为空，但可以出现0个或多个空格  eg .   sum()    or   sum(                 )
  const paramsBlock = `\\(${params}?${spaceOrEmpty}\\)`;
  // 6. 函数名 = 无保留字参数
  const funName = paramWithSpaceWithoutReservedWords;
  // 7. 函数调用 = 函数名+参数块
  const funCall = `${funName}${paramsBlock}`;
  // 8. 可包含空格的函数调用 = 函数调用 && 函数调用头尾可以出现0个或多个空格
  const funCallWithSpace = `${spaceOrEmpty}${funCall}${spaceOrEmpty}`;
  // 9. 多函数调用 = 多个函数调用的组合，函数调用可出现1个或多个
  const multipleFunCall = `${funCallWithSpace}(,${funCallWithSpace})*`;
  // 10.最终结果 = 多函数调用 && 头尾不包含除空格外的其它内容
  const finalFunCall = `^${multipleFunCall}$`;

  const reg = new RegExp(finalFunCall);
  return reg.test(inputStr);
}

#后记以上每一步验证的具体细节，我就没有在细述了，我相信还有其它的写法，而且不同的人可能还有不同的拆解方案，但我更想表达的是在面对复杂问题时，我们要学会利用降维的思想，自顶而下，把问题转化为许多细小的问题，这些小的问题都是易于解决的，最终再将这些小问题组合起来，终窥其全貌！！！

怎样写一个能够校验复杂规则的正则表达式 ？

怎样写一个能够校验复杂规则的正则表达式？