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相关命令，这个命令是：

gitdiffHEAD--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) {
//执行增量文件检查//获取当前项目根路径letpath=require('path');
letdirname=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 catchgitCheckType=0

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

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

letpath=require('path');
letdirname=path.join(__dirname);
letarray=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，执行 * */functioncheckFile(files, cb) {
letpath=require('path');
letdirname=path.join(__dirname);
letarray=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);
        } elseif (value.indexOf("string") !==-1&& (
mCommitType.indexOf("0") !==-1||mCommitType.indexOf("1") !==-1        )) {
//string文件name命名规范检查checkClassOrString(dirname+"/"+value, value, 1);
        } elseif ((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);
        } elseif ((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);
}

增量检查代码类型判断

/** * 增量文件检查 * */functioncheckDiffFile(cb, stdout, dirname) {
//通过切割换行，拿到文件列表letarray=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);
        } elseif (value.indexOf("kt") !==-1||value.indexOf("java") !==-1) {
//Kotlin或者Java，规范检查letlastPosition=value.lastIndexOf("/");
letclassName=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不符合，不符合就要终止执行，给出提示varisCheck=false;

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

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

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

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

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

/** * 检查类文件或者String文件 * type:0,kotlin文件或者java文件,1,string文件name命名规范检查 * */functioncheckClassOrString(path, value, type) {
letmoduleName=getModuleName(value);//模块名字letdata=fs.readFileSync(path, 'utf-8');// 拿到文件内容if (type===0) {
//java和kotlin文件//首先检查命名，然后在类注释，方法，变量等letlastPosition=value.lastIndexOf("/");
letclassName=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);
    } elseif (type===1) {
// stringif (moduleName.indexOf("app") ===-1&&moduleName.indexOf("libBase") ===-1) {
letstringArr=data.split("name=\"");
stringArr.forEach(function (item, position) {
if (item.indexOf("encoding") ===-1) {
leti=item.indexOf("\"");
letendString=item.substring(0, i);
if (endString!==""&&!endString.startsWith(moduleName)) {
//开头不是isCheck=true;
log("【"+value+"中，name为"+endString+"】,命名不规范", 0);
                    }
                }
            });
        }
    }
}

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

类命名是否规范

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

/** * 检查类的名字是否规范 * */functioncheckClassName(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这个三个参数，我的判断就是是否包含了这三个参数，没包含就提示不规范，当然了，大家可以按照自己公司的标准去执行即可。

/** * 类注释检查是否规范 * */functioncheckClassNotes(className, data) {
if (data.indexOf("{") !==-1) {
letdd=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就更不规则了，目前我的判断代码如下，基本上可以实现，问题不大，哈哈~

/** * 检查方法注释是否规范 * */functioncheckMethodNotes(className, data) {
vareachOk=0;
vareachNo=0;
varcaseNode= [];//不符合的方法if (className.indexOf("kt")) {
//kotlinletkotlin=data.split("fun");
kotlin.forEach(function (item, position) {
letendItem=item.trim();
letoverride=endItem.substring(endItem.length-20, endItem.length);
//判断是否包含if (position!==kotlin.length-1) {
if (override.indexOf("override") ===-1) {
letendM=kotlin[position+1];
//有注释的也要另行添加letkE=endItem.lastIndexOf("}");
letendK=endItem.substring(kE, endItem.length);
if (endK.indexOf("//") !==-1||endK.indexOf("*/") !==-1) {
//带有注释eachOk++;
                    } else {
//没有注释//不符合的方法lettr=endM;
if (tr!=null) {
letpositionCase=tr.indexOf("(");
letendCase=tr.substring(0, positionCase);
//去掉构造函数if (endCase.length<30&&className.indexOf(endCase) ===-1) {
eachNo++;
caseNode.push(endCase);
                            }
                        }
                    }
                }
            }
        });
    } else {
//java//遍历方法letjava=data.split(") {");
java.forEach(function (item, position) {
if (item.indexOf("public") !==-1||item.indexOf("protected") !==-1||item.indexOf("private") !==-1) {
//判断是否包含}if (item.indexOf("}") !==-1) {
letlastDesc=item.lastIndexOf("}");
letendDesc=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) {
//添加方法letlastK=item.lastIndexOf("(");
letlasetContent=item.substring(0, lastK);
letendContent=lasetContent.split(" ");//取最后一个letjavaMethod=endContent[endContent.length-1];
if (className.indexOf(javaMethod) ===-1) {
//不符合的方法eachNo++;
caseNode.push(javaMethod);
                                }
                            }
                        }
                    }
                } else {
letlastPrivate=item.lastIndexOf("private");
letlastPublic=item.lastIndexOf("public");
letlastProtected=item.lastIndexOf("protected");
varendLast=lastPrivate;
if (lastPublic>endLast) {
endLast=lastPublic;
                    }
if (lastProtected>endLast) {
endLast=lastPublic;//获取最后一个                    }
letendString=item.substring(endLast-50, endLast);
if (endString.indexOf("Override") ===-1) {
if (endString.indexOf("//") !==-1||endString.indexOf("*/") !==-1) {
//包含eachOk++;
                        } else {
//添加方法letlastK=item.lastIndexOf("(");
letlasetContent=item.substring(0, lastK);
letendContent=lasetContent.split(" ");//取最后一个letjavaMethod=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);
    }
}

方法命名是否规范

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

/** * 检查方法命名是否规范 * */functioncheckMethodName(className, data) {
//遍历方法vareachOk=0;
vareachNo=0;
varcaseNode= [];//不符合的方法//遍历所有的方法，判断是kt还是javaif (className.indexOf("kt") !==0) {
//kotlinletkotlin=data.split("fun");
kotlin.forEach(function (item, position) {
if (position!==0) {
//判断开头是大写还是小写lettr=item.trim();
letindexCase=tr.substring(0, 1);
letpositionCase=tr.indexOf("(");
letendCase=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//遍历方法letjava=data.split(") {");
java.forEach(function (item, position) {
if (item.indexOf("public") !==-1||item.indexOf("protected") !==-1||item.indexOf("private") !==-1) {
//获取最后一个括号letlastK=item.lastIndexOf("(");
letlasetContent=item.substring(0, lastK);
letendContent=lasetContent.split(" ");//取最后一个letendMethod=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呢，相对就比较局限，只能以大众的常见格式进行获取，然后再进行分割，具体的，大家直接看相关代码。

/** * 检查变量命名是否规范 * */functioncheckVariableName(className, data) {
vareachOk=0;
vareachNo=0;
varcaseNode= [];//不符合的方法//遍历所有的方法，判断是kt还是javaif (className.indexOf("kt") !==-1) {
//以等号分割letspD=data.split("=");
spD.forEach(function (item, position) {
//然后判断val 和 varletlastVal=item.lastIndexOf("val");
letlastVar=item.lastIndexOf("var");
varendLast=lastVal;
if (lastVar>lastVal) {
endLast=lastVar;
            }
letlastContent=item.substring(endLast, item.length);
if (lastContent.indexOf("val") !==-1||lastContent.indexOf("var") !==-1) {
if (lastContent.indexOf("fun") ===-1) {
letendK=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!=="") {
//这里进行判断大小写constp=/^[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//判断letspF=data.split(";");
spF.forEach(function (item, position) {
letlastPrivate=item.lastIndexOf("private");
letlastPublic=item.lastIndexOf("public");
letlastProtected=item.lastIndexOf("protected");
varendLast=lastPrivate;
if (lastPublic>endLast) {
endLast=lastPublic;
            }
if (lastProtected>endLast) {
endLast=lastPublic;//获取最后一个            }
letlastContent=item.substring(endLast, item.length);
if (lastContent.indexOf("public") !==-1||lastContent.indexOf("protected") !==-1||lastContent.indexOf("private") !==-1) {
//是否包含等号if (lastContent.indexOf("=") !==-1) {
leta=lastContent.trim().split("=");
letb=a[0].trim().split(" ");
letendC=b[b.length-1];
if (endC.indexOf("R") ===-1&&endC.indexOf("!") ===-1&&endC.indexOf(")") ===-1&&endC.indexOf("(") ===-1&&endC.indexOf("{") ===-1&&endC.indexOf("}") ===-1) {
//判断变量是否符合要求constp=/^[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 {
//普通的成员变量letendItem=lastContent.trim().split(" ");
letendContent=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!=="") {
constp=/^[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 是否添加 * */functioncheckTry(className, data) {
//遍历所有的方法，判断是kt还是javavarkj;
if (className.indexOf("kt") !==-1) {
//kotlinkj=data.split("fun");
    } elseif (className.indexOf("java") !==-1) {
//javakj=data.split("void");
    } else {
kj= [];
    }
//遍历方法vareachOk=0;
vareachNo=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) {
letstringArr=data.split("name=\"");
stringArr.forEach(function (item, position) {
if (item.indexOf("encoding") ===-1) {
leti=item.indexOf("\"");
letendString=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资源命名是否规范 * */functioncheckImageOrLayout(value) {
//图片和layout  直接判断命名letmoduleName=getModuleName(value);
//过滤app和libBaseif (moduleName.indexOf("app") ===-1&&moduleName.indexOf("libBase") ===-1) {
letlastPosition=value.lastIndexOf("/");
letxmlName=value.substring(lastPosition, value.length);
if (!xmlName.startsWith(moduleName)) {
isCheck=true;
log("【"+xmlName+"】,命名不规范", 0);
        }
    }
}

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

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

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

/** * 获取模块的名字 * */functiongetModuleName(value) {
letimagePosition=value.indexOf("/");
varmoduleName=value.substring(0, imagePosition);//模块名字//去除moduleif (moduleName.indexOf("module_") !==-1) {
//包含moduleName=moduleName.replace("module_", "");
    }
returnmoduleName;
}

四、补充说明

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

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

一、获取Git提交文件列表

二、判断提交文件类型

1、类文件

2、图片文件

3、layout资源文件

4、string文件Name

全量检查代码类型判断

增量检查代码类型判断

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

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

类命名是否规范

检查类注释是否规范

方法注释是否规范

方法命名是否规范

变量命名是否规范

try catch 是否添加

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

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

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

四、补充说明

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

一、获取Git提交文件列表

二、判断提交文件类型

1、类文件

2、图片文件

3、layout资源文件

4、string文件Name

全量检查代码类型判断

增量检查代码类型判断

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

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

类命名是否规范

检查类注释是否规范

方法注释是否规范

方法命名是否规范

变量命名是否规范

try catch 是否添加

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

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

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

四、补充说明

热门文章

最新文章

相关课程

相关电子书

相关实验场景