我报名参加金石计划1期挑战——瓜分10万奖池，这是我的第4篇文章，点击查看活动详情
系列文章目录
Android打造专有hook，让不规范的代码扼杀在萌芽之中
上篇文章，环境已经搭建，初始化程序已经完成，所需要的配置文件也均已创建，后面就是着手业务逻辑编写了，各位老铁，准备，开干！开干前，需要再次补充一下，虽是Android端的规范检查，但开发语言是Js，所以啊，各位铁子，不了解的话，抽个时间，看一看Js相关的语法，这么说吧，简单，毕竟我们都是掌握过高级编程语言的人，学起来，真的，没那么难，还是那句话，得得确确没时间学的话，也问题不大，跟着我的脚步，一步步执行，加上相关注释的理解，我相信，搞出来属于自己公司的规范，也只是时间的问题，况且，大部分的场景，我也基本上都会实现，最后也会开源给大家，大家完全可是使用我的，或者在我的基础之上更改即可。
目前的规范检查，我分为了全量文件检查和增量文件检查，基本上和Git提交保持一致，在实际的业务中，开发者可以动态修改配置文件参数gitIncrement，来切换是增量还是全量，增量和全量有一些是共通的地方，接下来的代码中会陈述。
最终的所有代码开源地址如下：
今天的主要概述内容如下：
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;
}
四、补充说明
在上述中代码中，包含了所有的全量代码逻辑，但是唯独缺少了增量代码检查的逻辑，考虑到增量代码的判断和全量有着巨大的差异，毕竟增量规范检查，只检查你所提交的那部分代码，也许是一行，也许是几行，相关的逻辑判断，还是和全量有所区别的，所以啊，各位老铁，至于增量代码如何实现规范检查，我们放到下篇文章去陈述，好了，各位铁子，这篇就到这里，欢迎感兴趣的老铁，持续关注，我们下篇见。
