Android打造专有Hook第三篇，实战全量代码规范检查

上篇文章，环境已经搭建，初始化程序已经完成，所需要的配置文件也均已创建，后面就是着手业务逻辑编写了，各位老铁，准备，开干！开干前，需要再次补充一下，虽是Android端的规范检查，但开发语言是Js，所以啊，各位铁子，不了解的话，抽个时间，看一看Js相关的语法，这么说吧，简单，毕竟我们都是掌握过高级编程语言的人，学起来，真的，没那么难，还是那句话，得得确确没时间学的话，也问题不大，跟着我的脚步，一步步执行，加上相关注释的理解，我相信，搞出来属于自己公司的规范，也只是时间的问题，况且，大部分的场景，我也基本上都会实现，最后也会开源给大家，大家完全可是使用我的，或者在我的基础之上更改即可。

目前的规范检查，我分为了全量文件检查和增量文件检查，基本上和Git提交保持一致，在实际的业务中，开发者可以动态修改配置文件参数gitIncrement，来切换是增量还是全量，增量和全量有一些是共通的地方，接下来的代码中会陈述。

最终的所有代码开源地址如下：

https://github.com/AbnerMing888/AndroidGitHook

今天的主要概述内容如下：

1、获取Git提交文件列表

2、判断提交文件类型

3、各中规范类型规范检测

4、补充说明

一、获取Git提交文件列表

在上篇中，我们定义了四个变量，临时存储了获取配置文件中的参数，下面我们就可以根据这些参数，来进行逻辑的处理。

首先根据mCommitOpen变量，判断开关是否打开，如果为true，证明需要进行Git规范检查，否则就是不需要，直接绿色通道，正常执行即可。在mCommitOpen为true之后，紧接着需要判断mCommitIncrement变量，判断是增量规范检查还是全量文件检查。

无论是增量检查还是全量检查，针对文件的名字，图片的名字等，都是要获取提交的文件列表的，而获取提交的文件列表，需要执行Git相关命令，这个命令是：

git diff HEAD --name-only --diff-filter=ACMR

通过执行上述的命令，我们就可以拿到本次提交修改过的文件，进而就可以针对这些文件进行遍历检查了，代码如下，由于增量和全量检查，所输出的日志信息不一样，以及所判断的逻辑也是不一样的，需要进行分别处理。

 //根据配置文件进行逻辑判断
        //如果mCommitOpen为true，意味着git开关打开，需要执行检查
        if (mCommitOpen.indexOf("true") !== -1) {
            //mCommitIncrement是否为true，true：增量检查（仅仅适用于命令行操作），false：整个文件的检索
            if (mCommitIncrement.indexOf("true") !== -1) {
                console.log("");
                log('增量检查中，铁子，开始了哦~', 1);
            } else {
                //进行整个文件的检查，全量检查
                console.log("\n");
                log('铁子，我要开始检查你的代码了！', 1);
            }
            // 通过node子进程执行git命令，查看提交的文件列表
            exec('git diff HEAD --name-only --diff-filter=ACMR', function (error, stdout, stderr) {
                if (stdout) {
                    //先检查文件名字是否符合规范
                    log("这次你commit文件列表如下：\n", 1);
                    console.log(stdout + "\n");
                    if (mCommitIncrement.indexOf("true") !== -1) {
                        //执行增量文件检查
                        //获取当前项目根路径
                        let path = require('path');
                        let dirname = path.join(__dirname);
                        checkDiffFile(cb, stdout, dirname);
                    } else {
                        //整个文件开始逐一排查
                        checkFile(stdout, cb);
                    }
                    return;
                }
                //没有文件，直接放行
                log("铁子，你的代码暂时没得问题，放行！\n", 1);
                cb(0);
            });
        } else {
            //如果mCommitOpen为false，意味着不检查，直接绿色通道，通过
            cb(0);
        }

二、判断提交文件类型

在第一步中，我们通过Git命令拿到了所更改的文件，在上面的代码中，根据全量还是增量，分别定义了不同的方法，checkFile和checkDiffFile，在这两个方法里就是针对所有的更改文件进行规范的检查，大家重点关注这两个方法即可，log方法第二章中有过讲述，就是用来输出日志信息的，就是一个简单的打印。

目前配置文件中，列出了9种类型的判断，上篇文章说过，我们再来看下配置文件定义的参数gitCheckType，这个是自己定义的，需要暴露给使用者的，所以啊，老铁，根据自己公司的规范标准来。

#git检测类型，0：全部，1：string文件Name，2：图片命名，3：layout，4：类命名，
#5：类注释，6：方法注释，7：方法命名，8：变量命名，9：try catch
gitCheckType=0

以上的9种类型，通过拆分，我们可以发现，4到9，都是通过类文件进行判断的，而1到3是根据文件名字进行判断的，在实际的规范检查中，我们就可以按条件进行判断。

在第一项中，我们通过命令已经拿到了文件的列表，而且还定义了两个方法，增量和全量，但是，我们拿到的文件列表是一个字符串，如果要获得每一个文件，那么我们就需要进行切割，由于文件都是一行一个，我们就可以以“\n”的方式进行分割，当然了，对于最后一个换行符号我们是要进行去掉的。

   let path = require('path');
    let dirname = path.join(__dirname);
    let array = files.split('\n');//通过切割换行，拿到文件列表
    array.pop();// 去掉最后一个换行符号
    log('【针对以上提交文件检查结果如下：】\n', 1);
    array.forEach(function (value) {
      //value 就是每一个文件
    });

拿到Git所提交的每一个文件，其实我们已经完成了一大步了，起码说，规范的前提所需要的条件，均已具备，后面就是针对这些提交的文件，进行逐个的规范检查了，9种类型，我们已经划分，下面针对9种类型如何做判断做一个简单的概述。

1、类文件

类文件暂时只包含java和Kotlin文件，如果大家想要拓展其他的文件类型，比如Flutter的项目等，大家可以自己定义，毕竟程序是自己搞的，想搞成什么，如何搞，还不是自己说的算，是吧，老铁！OK，针对这样的文件，我用的方法比较简单，你提交的kotlin文件，肯定以”kt“结尾，同样，提交的java文件，也肯定以”java“结尾，直接判断当前的文件名字是否包含”kt“或者”java“这不就搞定了，哈哈，老铁们，是不是特简单，类文件判断之后，就可以针对类文件，进行一系列的规范检查编写，如，类命名，类注释，方法命名，方法注释，变量等等，后面我们会一一阐述。

2、图片文件

和类文件一样的道理，还是用文件的结尾进行判断，一个图片有哪几种格式，肯定是固定的，比如png，jpg，gif，webp等等，只需要判断是否包含这些结尾的文件格式即可。

3、layout资源文件

layout需要注意，不仅要以最后的结尾xml来判断，还要判断当前的目录是不是在layout目录下，比较drawable下也有很多的xml资源，这个需要大家注意一下。

4、string文件Name

没什么好说的，直接判断文件名字是否包含”string“即可。

如果大家想要拓展，这里简单补充一下，关于文件命名是否规范，我的判断宗旨是，提交上来的文件，是否包含某一个特性，比如上述所说的类文件和图片文件，以及xml文件等等，都可以按照这样的逻辑进行判断，大家可以看下面的代码。

全量检查代码类型判断

/**
 * 整个文件进行检查,也就是全量文件检查
 * files：当前commit的文件列表
 * cb:进程，1，终止，0，执行
 * */
function checkFile(files, cb) {
    let path = require('path');
    let dirname = path.join(__dirname);
    let array = files.split('\n');//通过切割换行，拿到文件列表
    array.pop();// 去掉最后一个换行符号
    log('【针对以上提交文件检查结果如下：】\n', 1);
    array.forEach(function (value) {
        //判断文件是什么类型
        if (value.indexOf("kt") !== -1 || value.indexOf("java") !== -1) {
            //kotlin文件或者java文件
            checkClassOrString(dirname + "/" + value, value, 0);
        } else if (value.indexOf("string") !== -1 && (
            mCommitType.indexOf("0") !== -1 ||
            mCommitType.indexOf("1") !== -1
        )) {
            //string文件name命名规范检查
            checkClassOrString(dirname + "/" + value, value, 1);
        } else if ((value.indexOf("png") !== -1
                || value.indexOf("jpg") !== -1
                || value.indexOf("gif") !== -1
                || value.indexOf("webp") !== -1) &&
            (mCommitType.indexOf("0") !== -1 ||
                mCommitType.indexOf("2") !== -1)) {
            //图片文件命名规范检查
            checkImageOrLayout(value);
        } else if ((value.indexOf("layout") !== -1 &&
            value.indexOf("xml") !== -1) && (
            mCommitType.indexOf("0") !== -1 ||
            mCommitType.indexOf("3") !== -1
        )
        ) {
            //layout 检查资源命名规范检查
            checkImageOrLayout(value);
        }

    });

    setTimeout(function () {
        console.log("\n");
        if (isCheck) {
            cb(1);
        } else {
            log("所有文件均检查完毕，暂未发现问题，真棒！！！\n", 2);
            cb(0);
        }
    }, 1500);
       
}

增量检查代码类型判断

/**
 * 增量文件检查
 * */
function checkDiffFile(cb, stdout, dirname) {
    //通过切割换行，拿到文件列表
    let array = stdout.split('\n');
    // 去掉最后一个换行符号
    array.pop();
    log('【针对以上提交文件检查结果如下：】\n', 1);
    //遍历文件，检查相关规范是否符合
    array.forEach(function (value) {
        if (((value.indexOf("png") !== -1
                || value.indexOf("jpg") !== -1
                || value.indexOf("gif") !== -1
                || value.indexOf("webp") !== -1) ||
            (value.indexOf("layout") !== -1 &&
                value.indexOf("xml") !== -1)) && (
            mCommitType.indexOf("0") !== -1 ||
            mCommitType.indexOf("2") !== -1 ||
            mCommitType.indexOf("3") !== -1
        )) {
            //图片或者layout 规范检查
            checkImageOrLayout(value);
        } else if (value.indexOf("kt") !== -1 || value.indexOf("java") !== -1) {
            //Kotlin或者Java，规范检查
            let lastPosition = value.lastIndexOf("/");
            let className = value.substring(lastPosition + 1, value.length);
          	//检查类的名字是否规范
            checkClassName(className, value);
        }
    });
    //生成增量文件，并使用命令，写入增量代码
    fs.writeFile(dirname + "/androidCommit.diff", "", function (err) {
        if (err) {
            log('增量检查中断', 0);
            return;
        }
        exec('git diff >> androidCommit.diff', function (error, stdout, stderr) {
            //增量代码写入后，进行读取diff文件
            checkDiff(cb, dirname);
        });
    });

    setTimeout(function () {
        console.log("\n");
        if (isCheck) {
            cb(1);
        } else {
            log("增量检查完毕，暂未发现问题，真棒！！！\n", 2);
            cb(0);
        }
    }, 1500);
}

无论增量还是全量，上面的代码在程序结束的时候，都做了一个延时操作，此延时的目的在于等待上述检查的程序执行，因为检查各个规范是耗时的，为了避免还未检查完毕就结束，所以做了一个延时操作，不过大家在实际的开发中，可以采用逐个检查，也就是同步检查，一个检查完毕再执行另一个，直至检查结束，再进行进程判断也可以的，人云亦云，看大家实际的操作了。

对了，还有一个isCheck变量，它是定义的一个全局变量，我们是要根据这个变量来决定最终的执行程序。

//这个比较重要的，要用这个变量定义最终的执行程序  false符合，通过，不提示，true不符合，不符合就要终止执行，给出提示
var isCheck = false;

三、各中规范类型规范检测

各位老铁，需要注意是的，无论检查什么规范，前提一定得有自己的一套规范标准，我们所有的程序编写都是根据这套标准而来的，而不是凭空的捏造，我相信大家公司基本上都有，我们要做的就是，把公司的标准做成程序的检查。

根据上述的9中类型，无论增量还是全量，都进行了文件类型的判断，下面，我们针对不同的类型进行一一的拆解。

1、kotlin文件或者java文件相关规范检查

针对类文件的检查，上述已经说过，包含了，类命名，方法命名，类注释，方法注释，变量命名等，我们看下面的代码，由于类文件和String的Name检查公用了一个方法，这里用了一个type做了区分，为了保证程序的执行顺序，我这里简单的一一做了延时操作，当然了，大家如果有更好的方式，可以自行修改。

/**
 * 检查类文件或者String文件
 * type:0,kotlin文件或者java文件,1,string文件name命名规范检查
 * */
function checkClassOrString(path, value, type) {
    let moduleName = getModuleName(value);//模块名字
    let data = fs.readFileSync(path, 'utf-8');// 拿到文件内容
    if (type === 0) {
        //java和kotlin文件
        //首先检查命名，然后在类注释，方法，变量等
        let lastPosition = value.lastIndexOf("/");
        let className = value.substring(lastPosition + 1, value.length);
        //首先检查类命名是否规范
        checkClassName(className, value);
        setTimeout(function () {
            //检查类注释是否规范
            if (mCommitType.indexOf("0") !== -1 || mCommitType.indexOf("5") !== -1) {
                checkClassNotes(className, data);
            }
        }, 200);
        setTimeout(function () {
            //检查方法注释是否规范
            if (mCommitType.indexOf("0") !== -1 || mCommitType.indexOf("6") !== -1) {
                checkMethodNotes(className, data);
            }
        }, 400);
        setTimeout(function () {
            //检查方法命名是否规范
            if (mCommitType.indexOf("0") !== -1 || mCommitType.indexOf("7") !== -1) {
                checkMethodName(className, data);
            }
        }, 600);
        setTimeout(function () {
            //检查变量命名是否规范
            if (mCommitType.indexOf("0") !== -1 || mCommitType.indexOf("8") !== -1) {
                checkVariableName(className, data);
            }

        }, 800);
        setTimeout(function () {
            //检查try catch 是否添加
            if (mCommitType.indexOf("0") !== -1 || mCommitType.indexOf("9") !== -1) {
                checkTry(className, data);
            }

        }, 1000);
    } else if (type === 1) {
        // string
        if (moduleName.indexOf("app") === -1 && moduleName.indexOf("libBase") === -1) {
            let stringArr = data.split("name=\"");
            stringArr.forEach(function (item, position) {
                if (item.indexOf("encoding") === -1) {
                    let i = item.indexOf("\"");
                    let endString = item.substring(0, i);
                    if (endString !== "" && !endString.startsWith(moduleName)) {
                        //开头不是
                        isCheck = true;
                        log("【" + value + "中，name为" + endString + "】,命名不规范", 0);
                    }
                }

            });
        }
    }
}

针对上述代码，我把关于类的相关规范都定义了不同的方法，简单检查罗列一下，分享如下，还是那句话，这些所谓的规范检查，你必须有一套属于自己的规范标准。

类命名是否规范

类命令，无非就是，检查下是否是大驼峰命名规则，我这里简单的以首字母是否是大写，还有是否有下划线进行判断了，大家可以自行更改。

/**
 * 检查类的名字是否规范
 * */
function checkClassName(className, value) {
    if (mCommitType.indexOf("0") !== -1
        || mCommitType.indexOf("4") !== -1) {
        if (!checkCase(className.substring(0, 1)) ||
            className.indexOf("_") !== -1) {
            //不符合
            isCheck = true;
            log("【" + value + "】,类命名不规范", 0);
        }
    }
}

检查类注释是否规范

类注释，我们公司定义的是必须包含，author，date，desc这个三个参数，我的判断就是是否包含了这三个参数，没包含就提示不规范，当然了，大家可以按照自己公司的标准去执行即可。

/**
 * 类注释检查是否规范
 * */
function checkClassNotes(className, data) {
    if (data.indexOf("{") !== -1) {
        let dd = data.split("{")[0];
        if (dd.indexOf("author") === -1
            || dd.indexOf("date") === -1
            || dd.indexOf("desc") === -1) {
            //不符合
            isCheck = true;
            log("【" + className + "】,类注释不规范", 0);
        }
    }
}

方法注释是否规范

方法注释，这个稍微逻辑复杂些，第一，首先，得找到方法，第二，判断是否有”//“，”*/“，相关注释标准，第三，一些重写的方法就没必要添加注释了，还有就是，java和Kotlin的方法定义还不太一样，kotlin是”fun“来定义，Java就更不规则了，目前我的判断代码如下，基本上可以实现，问题不大，哈哈~

/**
 * 检查方法注释是否规范
 * */
function checkMethodNotes(className, data) {
    var eachOk = 0;
    var eachNo = 0;
    var caseNode = [];//不符合的方法
    if (className.indexOf("kt")) {
        //kotlin
        let kotlin = data.split("fun");
        kotlin.forEach(function (item, position) {
            let endItem = item.trim();
            let override = endItem.substring(endItem.length - 20, endItem.length);
            //判断是否包含
            if (position !== kotlin.length - 1) {
                if (override.indexOf("override") === -1) {
                    let endM = kotlin[position + 1];
                    //有注释的也要另行添加
                    let kE = endItem.lastIndexOf("}");
                    let endK = endItem.substring(kE, endItem.length);
                    if (endK.indexOf("//") !== -1 || endK.indexOf("*/") !== -1) {
                        //带有注释
                        eachOk++;
                    } else {
                        //没有注释
                        //不符合的方法
                        let tr = endM;
                        if (tr != null) {
                            let positionCase = tr.indexOf("(");
                            let endCase = tr.substring(0, positionCase);
                            //去掉构造函数
                            if (endCase.length < 30 && className.indexOf(endCase) === -1) {
                                eachNo++;
                                caseNode.push(endCase);
                            }
                        }
                    }
                }

            }
        });

    } else {
        //java
        //遍历方法
        let java = data.split(") {");
        java.forEach(function (item, position) {
            if (item.indexOf("public") !== -1
                || item.indexOf("protected") !== -1
                || item.indexOf("private") !== -1) {

                //判断是否包含}
                if (item.indexOf("}") !== -1) {
                    let lastDesc = item.lastIndexOf("}");
                    let endDesc = item.substring(lastDesc, item.length);
                    if (endDesc.indexOf("Override") === -1) {
                        if (endDesc.indexOf("//") !== -1 || endDesc.indexOf("/*") !== -1) {
                            //包含
                            eachOk++;
                        } else {
                            if (item.indexOf("while") === -1
                                && item.indexOf("if") === -1
                                && item.indexOf("for") === -1) {

                                //添加方法
                                let lastK = item.lastIndexOf("(");
                                let lasetContent = item.substring(0, lastK);
                                let endContent = lasetContent.split(" ");//取最后一个

                                let javaMethod = endContent[endContent.length - 1];
                                if (className.indexOf(javaMethod) === -1) {
                                    //不符合的方法
                                    eachNo++;
                                    caseNode.push(javaMethod);
                                }

                            }

                        }


                    }
                } else {

                    let lastPrivate = item.lastIndexOf("private");
                    let lastPublic = item.lastIndexOf("public");
                    let lastProtected = item.lastIndexOf("protected");
                    var endLast = lastPrivate;
                    if (lastPublic > endLast) {
                        endLast = lastPublic;
                    }
                    if (lastProtected > endLast) {
                        endLast = lastPublic;//获取最后一个
                    }

                    let endString = item.substring(endLast - 50, endLast);
                    if (endString.indexOf("Override") === -1) {
                        if (endString.indexOf("//") !== -1 || endString.indexOf("*/") !== -1) {
                            //包含
                            eachOk++;
                        } else {
                            //添加方法
                            let lastK = item.lastIndexOf("(");
                            let lasetContent = item.substring(0, lastK);
                            let endContent = lasetContent.split(" ");//取最后一个
                            let javaMethod = endContent[endContent.length - 1];
                            if (className.indexOf(javaMethod) === -1) {
                                //不符合的方法
                                eachNo++;
                                caseNode.push(javaMethod);
                            }
                        }

                    }

                }

            }
        });

    }

    if (eachNo !== 0) {
        isCheck = true;
        log("\n【" + className + "】,未添加注释的方法如下：\n", 1);
        log(caseNode, 0);
    }
}

方法命名是否规范

这个相对于方法注释，就简单了许多了，无非就是获取方法名字，然后这对方法名字判断是否符合公司定义的规范即可，没啥好说的，看代码即可。

/**
 * 检查方法命名是否规范
 * */
function checkMethodName(className, data) {
//遍历方法
    var eachOk = 0;
    var eachNo = 0;
    var caseNode = [];//不符合的方法

    //遍历所有的方法，判断是kt还是java
    if (className.indexOf("kt") !== 0) {
        //kotlin
        let kotlin = data.split("fun");
        kotlin.forEach(function (item, position) {
            if (position !== 0) {
                //判断开头是大写还是小写
                let tr = item.trim();
                let indexCase = tr.substring(0, 1);
                let positionCase = tr.indexOf("(");
                let endCase = tr.substring(0, positionCase);
                if (endCase.indexOf("<") === -1
                    && endCase !== "" && className.indexOf(endCase) === -1) {
                    if ((checkCase(indexCase)
                        || endCase.indexOf("_") !== -1)) {
                        //不符合
                        eachNo++;
                        //添加方法
                        caseNode.push(endCase);
                    } else {
                        //符合
                        eachOk++;
                    }
                }
            }

        });

    } else {
        //java
        //遍历方法
        let java = data.split(") {");
        java.forEach(function (item, position) {
            if (item.indexOf("public") !== -1
                || item.indexOf("protected") !== -1
                || item.indexOf("private") !== -1) {

                //获取最后一个括号
                let lastK = item.lastIndexOf("(");
                let lasetContent = item.substring(0, lastK);
                let endContent = lasetContent.split(" ");//取最后一个
                let endMethod = endContent[endContent.length - 1];

                if (endMethod.indexOf("<") === -1
                    && endMethod !== "" &&
                    className.indexOf(endMethod) === -1
                    && endMethod.indexOf("(") === -1) {
                    if (checkCase(endMethod.substring(0, 1)) || endMethod.indexOf("_") !== -1) {
                        //不符合
                        eachNo++;
                        //添加方法
                        caseNode.push(endMethod);
                    } else {
                        //符合
                        eachOk++;
                    }
                }

            }

        });
    }

    if (eachNo !== 0) {
        //不符合
        isCheck = true;
        log("\n【" + className + "】,方法命名不规范的如下：\n", 1);
        log(caseNode, 0);
    }
}

变量命名是否规范

变量的命名相对比较负责，因为Kotlin和Java所定义的变量格式是不一样的，还有就是得忽略一些常量的命名，Kotlin我是以val或者var来进行截取分割，拿到变量名，Java呢，相对就比较局限，只能以大众的常见格式进行获取，然后再进行分割，具体的，大家直接看相关代码。

/**
 * 检查变量命名是否规范
 * */
function checkVariableName(className, data) {
    var eachOk = 0;
    var eachNo = 0;
    var caseNode = [];//不符合的方法

    //遍历所有的方法，判断是kt还是java
    if (className.indexOf("kt") !== -1) {
        //以等号分割
        let spD = data.split("=");
        spD.forEach(function (item, position) {
            //然后判断val 和 var
            let lastVal = item.lastIndexOf("val");
            let lastVar = item.lastIndexOf("var");
            var endLast = lastVal;
            if (lastVar > lastVal) {
                endLast = lastVar;
            }
            let lastContent = item.substring(endLast, item.length);

            if (lastContent.indexOf("val") !== -1
                || lastContent.indexOf("var") !== -1) {
                if (lastContent.indexOf("fun") === -1) {
                    let endK = lastContent.split(" ")[1];
                    //判断变量是否符合要求
                    if (endK.indexOf("R") === -1
                        && endK.indexOf("!") === -1
                        && endK.indexOf(")") === -1
                        && endK.indexOf("{") === -1
                        && endK.indexOf("}") === -1) {
                        if (endK.indexOf("<") === -1 && endK !== "") {
                            //这里进行判断大小写
                            const p = /^[A-Z_]*$/g;
                            if (p.test(endK)) {
                                //符合
                                eachOk++;
                            } else {
                                if ((checkCase(endK.substring(0, 1))
                                    || endK.indexOf("_") !== -1)) {
                                    //不符合
                                    eachNo++;
                                    //添加方法
                                    caseNode.push(endK);
                                } else {
                                    //符合
                                    eachOk++;
                                }
                            }


                        }

                    }

                }
            }

        });

    } else {
        //java
        //判断

        let spF = data.split(";");
        spF.forEach(function (item, position) {
            let lastPrivate = item.lastIndexOf("private");
            let lastPublic = item.lastIndexOf("public");
            let lastProtected = item.lastIndexOf("protected");
            var endLast = lastPrivate;
            if (lastPublic > endLast) {
                endLast = lastPublic;
            }
            if (lastProtected > endLast) {
                endLast = lastPublic;//获取最后一个
            }

            let lastContent = item.substring(endLast, item.length);

            if (lastContent.indexOf("public") !== -1
                || lastContent.indexOf("protected") !== -1
                || lastContent.indexOf("private") !== -1) {

                //是否包含等号
                if (lastContent.indexOf("=") !== -1) {
                    let a = lastContent.trim().split("=");
                    let b = a[0].trim().split(" ");
                    let endC = b[b.length - 1];

                    if (endC.indexOf("R") === -1
                        && endC.indexOf("!") === -1
                        && endC.indexOf(")") === -1
                        && endC.indexOf("(") === -1
                        && endC.indexOf("{") === -1
                        && endC.indexOf("}") === -1) {
                        //判断变量是否符合要求
                        const p = /^[A-Z_]*$/g;
                        if (p.test(endC)) {
                            eachOk++;
                        } else {
                            if (endC.indexOf("<") === -1 && endC !== "") {
                                if ((checkCase(endC.substring(0, 1))
                                    || endC.indexOf("_") !== -1)) {
                                    //不符合
                                    eachNo++;
                                    //添加方法
                                    caseNode.push(endC);
                                } else {
                                    //符合
                                    eachOk++;
                                }
                            }
                        }

                    }


                } else {
                    //普通的成员变量
                    let endItem = lastContent.trim().split(" ");
                    let endContent = endItem[endItem.length - 1];//最后的内容

                    if (endContent.indexOf("R") === -1
                        && endContent.indexOf("!") === -1
                        && endContent.indexOf(")") === -1
                        && endContent.indexOf("(") === -1
                        && endContent.indexOf("{") === -1
                        && endContent.indexOf("}") === -1) {
                        //判断变量是否符合要求
                        if (endContent.indexOf("<") === -1 && endContent !== "") {
                            const p = /^[A-Z_]*$/g;
                            if (p.test(endContent)) {
                                eachOk++;
                            } else {
                                if ((checkCase(endContent.substring(0, 1))
                                    || endContent.indexOf("_") !== -1)) {
                                    //不符合
                                    eachNo++;
                                    //添加方法
                                    caseNode.push(endContent);
                                } else {
                                    //符合
                                    eachOk++;

                                }
                            }

                        }
                    }


                }
            }


        });

    }

    if (eachNo !== 0) {
        //不符合
        isCheck = true;
        log("\n【" + className + "】,变量命名不规范的如下：\n", 1);
        log(caseNode, 0);
    }
}

try catch 是否添加

try catch是我们公司自己定义的一项标准，就是在业务函数中，需要增加try catch，以防止由于空，类型不一等情况造成的崩溃，具体的判断就是，在获取到方法后，判断方法里是否包含try catch即可。

/**
 * try  catch 是否添加
 * */
function checkTry(className, data) {
    //遍历所有的方法，判断是kt还是java
    var kj;
    if (className.indexOf("kt") !== -1) {
        //kotlin
        kj = data.split("fun");
    } else if (className.indexOf("java") !== -1) {
        //java
        kj = data.split("void");
    } else {
        kj = [];
    }
    //遍历方法
    var eachOk = 0;
    var eachNo = 0;
    kj.forEach(function (item, position) {
        if (position !== 0) {
            if (item.indexOf("try") !== -1 && item.indexOf("catch") !== -1) {
                //符合的方法
                eachOk++;
            } else {
                //不符合的方法
                eachNo++;
            }
        }
    });

    if (eachNo !== 0) {
        //不符合
        isCheck = true;
        log("【" + className + "】,检测到有未添加try catch的方法", 0);
    }
}

2、string文件name命名规范检查

string相对来说还是比较简单的，首先拿到string文件，然后获取文件里面的内容，接着进行关键字分割，拿到所有的name的Key，针对Key做规范检查即可，当然了，在组件化的开发中，有一些组件是不需要检查的，我们进行过滤即可，下面的代码是和类文件检查公用的，在Kotlin文件或Java文件相关检查中有。

if (moduleName.indexOf("app") === -1 && moduleName.indexOf("libBase") === -1) {
            let stringArr = data.split("name=\"");
            stringArr.forEach(function (item, position) {
                if (item.indexOf("encoding") === -1) {
                    let i = item.indexOf("\"");
                    let endString = item.substring(0, i);
                    if (endString !== "" && !endString.startsWith(moduleName)) {
                        //开头不是
                        isCheck = true;
                        log("【" + value + "中，name为" + endString + "】,命名不规范", 0);
                    }
                }

            });
        }

3、图片文件命名规范检查

这里再重述一下啊各位老铁，所有的规范，前提必须得有自己的一套规范标准啊，不然，我们的程序就没有参照依据了，关于图片的规范，根据实际的规范标准，我举一个例子，下面是我们公司的规范：

图片命名规则：组件名称_（背景用bg，图片用ic，按钮用btn，分隔线用divider）_**
例如：
①、community模块下
community_ic_publish
②、common模块下
common_bg_publish
common_ic_publish

根据上述的标准，我所开发的检查如下，当然了，还是那句话，程序是活的，大家可以根据自己公司的规范标准去执行即可。

/**
 * 检查图片或者layout资源命名是否规范
 * */
function checkImageOrLayout(value) {
    //图片和layout  直接判断命名
    let moduleName = getModuleName(value);
    //过滤app和libBase
    if (moduleName.indexOf("app") === -1 && moduleName.indexOf("libBase") === -1) {
        let lastPosition = value.lastIndexOf("/");
        let xmlName = value.substring(lastPosition, value.length);
        if (!xmlName.startsWith(moduleName)) {
            isCheck = true;
            log("【" + xmlName + "】,命名不规范", 0);
        }
    }
}

4、layout 检查资源命名规范检查

layout的资源命名规范检查，和上述的图片检查基本是一致的，可以进行复用。需要注意的是，组件化开发的项目，可能对于app组件以及中间层组件，组件名是可以不带的，当然了，看大家实际的业务需求，不带就进行过滤即可。

获取模块的名字，也就是当前提交的文件是属于哪个组件，这种检查方式适用于组件化开发的项目，这里我进行了一个简单的判断，主要是我们公司有的组件名字带了一个module，我这里给删除了。

/**
 * 获取模块的名字
 * */
function getModuleName(value) {
    let imagePosition = value.indexOf("/");
    var moduleName = value.substring(0, imagePosition);//模块名字
    //去除module
    if (moduleName.indexOf("module_") !== -1) {
        //包含
        moduleName = moduleName.replace("module_", "");
    }
    return moduleName;
}

四、补充说明

在上述中代码中，包含了所有的全量代码逻辑，但是唯独缺少了增量代码检查的逻辑，考虑到增量代码的判断和全量有着巨大的差异，毕竟增量规范检查，只检查你所提交的那部分代码，也许是一行，也许是几行，相关的逻辑判断，还是和全量有所区别的，所以啊，各位老铁，至于增量代码如何实现规范检查，我们放到下篇文章去陈述，好了，各位铁子，这篇就到这里，欢迎感兴趣的老铁，持续关注，我们下篇见。