写在前面
每当提到正则表达式，身边很多朋友的反应是这样的：
“那玩意儿最好不要用，没法维护！”，
“太复杂，不常用，学不来” ....
不可否认，正则的表达形式，让人看起来的确有些难以理解，如果某天你接手维护一段代码，当你满怀好奇地打开代码文件，发现里面很多代码长成这个样子：
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个或多个
- 最终结果 = 多函数调用 && 头尾不包含除空格外的其它内容
有了以上的的思路，验证方案就已经呼之欲出了，贴出代码：
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);
}
后记
以上每一步验证的具体细节，我就没有在细述了，我相信还有其它的写法，而且不同的人可能还有不同的拆解方案，但我更想表达的是在面对复杂问题时，我们要学会利用降维的思想 ，自顶而下，把问题转化为许多细小的问题，
这些小的问题都是易于解决的，最终再将这些小问题组合起来，终窥其全貌！！！
