可读代码编写炸鸡三 - 审美
在上一篇 可读代码炸鸡二(下篇) - 命名的歧义 的结尾处，提到了接下来的炸鸡会围绕 多行代码，多个函数 的代码范围来讨论代码可读性的优化。
由这个思路走的话，那么接下来的炸鸡大致会分成两个内容：
- 代码审美
- 代码注释
所以本篇炸鸡将讨论 代码审美 对于可读性的作用。
原则
- 一致布局，让读者很快习惯。
- 相似代码看起来要相似。
- 相关代码分组分块。
需要区分于设计
这只是代码外观组织上的优化，并非代码内部逻辑结构的重构优化。
但是审美上的要求在一定程度上会影响到代码内部逻辑结构。
为啥审美重要
喏，实践出真知。明显如下代码就是很差劲的代码编写。
class hamBurgerShop {
public:
// 敌无不斩，斩无不断
void Add(double d); // 增加一个东西
private: int count; /* 多少
*/ public:
double Average();
private: double minimum;
list<double>
past_items
;double maximum;
};
然后做一点审美层面的修改，你再看看，可读性瞬间提高。
// 汉堡店类 - 其实这个注释不用加。
class hamBurgerShop {
public:
void Add(double d);
double Average();
private:
list<double> past_items;
int count; // 多少个汉堡
double minimum;
double maximum;
};
代码中提到了一件事，也作为一个问题抛给大家。
为什么汉堡店类不需要注释？
这个问题会留到下一篇或者下下一篇炸鸡给出一些见解。
换行要一致且紧凑
首先我们设想一下这样的代码，生成两个 Fort 对象。但由于代码过长，可能会让你不断地使光标向右来查看完整代码(当然即使使用 vim 也得不断地按键)，不能让阅读者同屏阅读代码，增加阅读者负担。
local fort1 = Fort.new("k1", 2222, 300, 4000, true, true)
local fort2 = Fort.new("super kingdom fort", 22256, 300, 4400, true， false, ...) -- 更加地长
if xxx then
Log("xxx", shellNum)
end
还有《The Art of Readable Code》中提到的例子，同样是代码过长造成的阅读负担。
public class PerformanceTester {
public static final TcpConnectionSimulator wifi = new TcpConnectionSimulator(500,80, 200, 1);
public static final TcpConnectionSimulator t3_fiber = new TcpConnectionSimulator(500,80, 0, 0);
}
所以这时候换行就体现出作用了。
local fort1 = Fort.new("k1", 2222, 300, 4000, true, true)
local fort2 = Fort.new("super kingdom fort", 22256,
300, 4400, true， false, ...)
//一种换行
public class PerformanceTester {
public static final TcpConnectionSimulator wifi = new TcpConnectionSimulator(500,
80, 200, 1);
public static final TcpConnectionSimulator t3_fiber = new TcpConnectionSimulator(500,
80, 0, 0);
}
//又一种换行
public class PerformanceTester {
public static final TcpConnectionSimulator wifi
= new TcpConnectionSimulator(500,80, 200, 1);
public static final TcpConnectionSimulator t3_fiber
= new TcpConnectionSimulator(500,80, 0, 0);
}
这样便将代码长度控制在可视范围内。但是相同作用的两行代码，却不一定能体现相同的参数位置，这样也会对阅读者造成一定影响。所以我们可以将换行变得一致且紧凑。
local fort1 =
Fort.new(
"k1",
2222,
300,
4000,
true,
true)
local fort2 =
Fort.new(
"super kingdom fort",
22256,
300,
4400,
true
false,
...)
public class PerformanceTester {
public static final TcpConnectionSimulator wifi =
new TcpConnectionSimulator(
500, /* Kbps */
80, /* millisecs latency */
200, /* jitter */
1 /* packet loss % */);
public static final TcpConnectionSimulator t3_fiber =
new TcpConnectionSimulator(
45000, /* Kbps */
10, /* millisecs latency */
0, /* jitter */
0 /* packet loss % */);
public static final TcpConnectionSimulator cell =
new TcpConnectionSimulator(
100, /* Kbps */
400, /* millisecs latency */
250, /* jitter */
5 /* packet loss % */);
}
当然，这在一定程度上增加了代码行数，所以不要过度使用这样的规则。同时如果需要多次使用这样的方法，是否需要思考一下，你的代码内部是否需要优化？是不是代码内部成为了庞大的超级工厂？
你可以选择优化代码结构，抽出更多的函数，或者可能需要一定的设计模式的内容，感兴趣的朋友可以自行查阅相关书籍与资料。
回想一下开头的原则，相似的相似，一致的布局。
同时需要提一嘴的是:
这个注释存在的意义是为参数加入更多的信息，例如上述代码是为了告诉阅读者参数的单位值。若参数命名表达的信息足够完整，不用增加这样的注释。当然这个问题在后头的炸鸡中我会详细说明。
但是这个注释和换行过于重复。我们可以将说明信息放到顶部，具体的如下所示。将函数名和参数列出，同时还列出参数具体意思。
public class PerformanceTester {
// TcpConnectionSimulator(throughput, latency, jitter, packet_loss)
// [Kbps] [ms] [ms] [percent]
public static final TcpConnectionSimulator wifi =
new TcpConnectionSimulator(500, 80, 200, 1);
public static final TcpConnectionSimulator t3_fiber =
new TcpConnectionSimulator(45000, 10, 0, 0);
public static final TcpConnectionSimulator cell =
new TcpConnectionSimulator(100, 400, 250, 5);
}
用封装方法来清除不太好看的东西
什么叫做不太好看？
例如四处使用重复的代码。
function giveItem(itemId, amount, srcUserUid, destUserUid, needSync)
end
function Map:addNeedFood2user(uid)
local count = 0
for _, city in pairs(self._cities) do
if exp1 then count = count + 1 end
end
local needFood = self:baseFood() * 0.8 + count ^ 2 *0.12
call2User(uid, "addFood", needFood)
end
function Map:isNeedExpand()
local count = 0
for _, city in pairs(self._cities) do
if exp1 then count = count + 1 end
end
if count > 400 then
return true
else
return false
end
end
我们可以看到，这一个逻辑是都有用到的。
local count = 0
for _, city in pairs(self._cities) do
if exp1 then count = count + 1 end
end
所以我们将这个逻辑封装和抽象，方便阅读者理解，同时方便了复用。
function Map:fetchCityNum()
local count = 0
for _, city in pairs(self._cities) do
if exp1 then count = count + 1 end
end
return count
end
function Map:addNeedFood2user(uid)
local count = self:fetchCityNum()
local needFood = self:baseFood() * 0.8 + count ^ 2 *0.12
call2User(uid, "addFood", needFood)
end
function Map:isNeedExpand()
local count = self:fetchCityNum()
if count > 400 then
return true
else
return false
end
end
我们再举一个例子。
如果多个相同函数执行，但是由于参数长短问题，使得代码整体，有的换行，有的太短，参差不齐。
我直接使用《The Art of Readable Code》的示例：
DatabaseConnection database_connection;
string error;
assert(ExpandFullName(database_connection, "Doug Adams", &error)
== "Mr. Douglas Adams");
assert(error == "");
assert(ExpandFullName(database_connection, " Jake Brown ", &error)
== "Mr. Jacob Brown III");
assert(error == "");
assert(ExpandFullName(database_connection, "No Such Guy", &error) == "");
assert(error == "no match found");
assert(ExpandFullName(database_connection, "John", &error) == "");
assert(error == "more than one result");
所以可以多封装一层函数，将代码规整。
void CheckFullName(string partial_name,
string expected_full_name,
string expected_error) {
// database_connection is now a class member
string error;
string full_name = ExpandFullName(database_connection, partial_name, &error);
assert(error == expected_error);
assert(full_name == expected_full_name);
}
这样先前繁杂代码可以变成如下清爽的代码。
CheckFullName("Doug Adams", "Mr. Douglas Adams", "");
CheckFullName(" Jake Brown ", "Mr. Jake Brown III", "");
CheckFullName("No Such Guy", "", "no match found");
CheckFullName("John", "", "more than one result");
这样不仅去除了重复的代码，而且阅读代码的时候一目了然，增加新的一行代码只要如法炮制即可。
所以上述例子或多或少证明了如果编写者对于代码审美做了要求，那么在一定程度上会优化代码的组织。
善用列对齐
列对齐针对多个重复的函数的参数列表，可以起到代码规整的作用。如上文的多行 CheckFullName 函数，经过列对齐的修饰，会更加清楚：
CheckFullName("Doug Adams" , "Mr. Douglas Adams" , "");
CheckFullName(" Jake Brown ", "Mr. Jake Brown III" , "");
CheckFullName("No Such Guy" , "" , "no match found");
CheckFullName("John" , "" , "more than one result");
或者多列赋值的时候，也可以起到同样作用。
details = request.POST.get('details')
location = request.POST.get('location')
phone = request.POST.get('phone')
当然，一些复杂数据结构的赋值，也可以利用。
local t = {
{"timeout", 1, "shshshsh"},
{"timeout", 2, "hsh"},
{"ti", 3, "shshshsh"},
{"tries", 4, "shsh"},
...
}
用一个顺序来写代码
- 最重要的语句最上，然后依次根据重要性的递减来排列语句。
- 按照字母顺序来排列
- 如果代码中提到了 A, B, C 三种命名，如果在同一个范围内(例如函数)再次使用了它们，调用顺序也保持一致。
第三种个人觉得较为普遍。我来解释一下。
假如一个代码需要三个步骤执行:
function test()
...
...
firstStep:start()
secondStep:start()
thirdStep:start()
end
那么他们的相关变量的声明也根据这个顺序进行声明。
function test()
local firstStep = first:new()
local secondStep = second:new()
local thirdStep = third:new()
...
...
firstStep:start()
secondStep:start()
thirdStep:start()
end
分层或者分组思想
人更接受好的分组和层次，代码的过分堆砌，会使得阅读理解不太方便。例如下方列出的代码，看着难免有点费力：
class FrontendServer {
public:
FrontendServer();
void ViewProfile(HttpRequest* request);
void OpenDatabase(string location, string user);
void SaveProfile(HttpRequest* request);
string ExtractQueryParam(HttpRequest* request, string param);
void ReplyOK(HttpRequest* request, string html);
void FindFriends(HttpRequest* request);
void ReplyNotFound(HttpRequest* request, string error);
void CloseDatabase(string location);
~FrontendServer();
};
许多人编写程序都有一个模块化的习惯，封装的方式取决于多次出现或者说可复用的代码量。
代码量 | 小 | 中 | 大 |
|---|---|---|---|
封装方式 | 函数 | 类 | 模块 |
所以分层分组的思想，这其实就是将代码的编写逻辑分模块。是在代码量更小的情况下，不至于上升至封装为函数的时候，对代码逻辑的的一个模块化，让 A 块代码做的事情为一组，B 块代码做的事情为一组。
这个思想主要体现在多个变量声明，函数定义的时候，例如类的定义。利用注释和分段，将不同组或者说不同层次的声明分开。
class FrontendServer {
public:
FrontendServer();
~FrontendServer();
// Handlers
void ViewProfile(HttpRequest* request);
void SaveProfile(HttpRequest* request);
void FindFriends(HttpRequest* request);
// Request/Reply Utilities
string ExtractQueryParam(HttpRequest* request, string param);
void ReplyOK(HttpRequest* request, string html);
void ReplyNotFound(HttpRequest* request, string error);
// Database Helpers
void OpenDatabase(string location, string user);
void CloseDatabase(string location);
};
同样，利用注释和分段，对一段逻辑代码进行总结和分段。
一开始代码如下：
def make_a_hamburg():
vegetable = Vegetables()
meat = Meat()
bread = Bread()
kitchen = Kitchen()
kitchen.wash(vegetable)
kitchen.cook(bread)
kitchen.cook(meat)
return kitchen.get_a_hamburg()
修改的代码如下，找的例子的确有点好玩，但是就是讲的这个分层次和总结的意思。
def make_a_hamburg():
# 准备食材
vegetable = Vegetables()
meat = Meat()
bread = Bread()
# 找好厨房
kitchen = Kitchen()
# 开始制作
kitchen.wash(vegetable)
kitchen.cook(bread)
kitchen.cook(meat)
# 做好一个汉堡
return kitchen.get_a_hamburg()
当然，这个方法容易使得空行比较多。我主程就要求我们尽量不要有空行，保持紧凑。
我个人觉得，如果能够很好地将代码有层次性地分开，多加空行是可以的；但如果加空行并不能达到这个效果，那只是徒增阅读者麻烦。
所以最终还是就 是否可读性，使得阅读者理解更快理解 这一标准衡量。
个人风格和项目风格一致性
Consistent style is more important than the 「 right 」 style.
当然，每个项目有都有自己规定的一套风格，即使可能不太正确，但是尽量和这个风格保持一致。
保持项目风格一致，比坚持个人风格更重要，不然杂乱在一起，看的更难受。
小结
- 如果相似代码多次出现，就要考虑封装它们。
- 代码中变量的声明顺序可以按照首字母顺序，重要程度来排列。当然，还有自定义的顺序，如果是自定义，这就需要声明的变量的顺序和调用变量的顺序尽量保持一致，体现出自定义顺序的严谨。
- 善用注释和空行来将代码依据逻辑，功能作用等，进行分层，是一种更微型的模块化。
- 哦对了，列对齐可以规整多行赋值语句，还可以说明函数作用和参数信息。