我报名参与金石方案1期应战——瓜分10万奖池，这是我的第4篇文章，点击查看活动详情
系列文章目录
Android打造专有hook，让不标准的代码摧残在萌芽之中
Android打造专有hook第二篇，走进标准榜首步
上篇文章，环境现已搭建，初始化程序现已完结，所需求的配置文件也均已创立，后边便是着手事务逻辑编写了，各位老铁，准备，开干！开干前，需求再次弥补一下，虽是Android端的标准查看，但开发语言是Js，所以啊，各位铁子，不了解的话，抽个时间，看一看Js相关的语法，这么说吧，简略，毕竟咱们都是掌握过高级编程语言的人，学起来，真的，没那么难，仍是那句话，得得确确没时间学的话，也问题不大，跟着我的脚步，一步步履行，加上相关注释的理解，我信任，搞出来归于自己公司的标准，也只是时间的问题，何况，大部分的场景，我也基本上都会完成，终究也会开源给咱们，咱们彻底可是运用我的，或许在我的基础之上更改即可。
现在的标准查看，我分为了全量文件查看和增量文件查看，基本上和Git提交保持一致，在实践的事务中，开发者能够动态修正配置文件参数gitIncrement，来切换是增量仍是全量，增量和全量有一些是共通的当地，接下来的代码中会陈述。
终究的一切代码开源地址如下：
github.com/AbnerMing88…
今日的主要概述内容如下：
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;
}
四、弥补阐明
在上述中代码中，包括了一切的全量代码逻辑，可是唯一缺少了增量代码查看的逻辑，考虑到增量代码的判别和全量有着巨大的差异，毕竟增量标准查看，只查看你所提交的那部分代码，也许是一行，也许是几行，相关的逻辑判别，仍是和全量有所区别的，所以啊，各位老铁，至于增量代码怎么完成标准查看，咱们放到下篇文章去陈述，好了，各位铁子，这篇就到这儿，欢迎感兴趣的老铁，持续关注，咱们下篇见。
