重构的时机和方法

目    录
第Ⅰ部分
通过重构电脑游戏来学习
第1章 重构 3
1.1  什么是重构 4
1.2  技能：重构什么 5
1.2.1  代码异味示例 5
1.2.2  规则示例 6
1.3  文化：什么时候重构 6
1.3.1  在遗留系统中重构 7
1.3.2  什么时候不应该重构 8
1.4  工具：如何(安全地)重构 8
1.5  入门所需的工具 9
1.5.1  编程语言：TypeScript 9
1.5.2  编辑器：Visual Studio Code 9
1.5.3  版本控制：Git 10
1.6  总体示例：一款2D益智游戏 10
1.7  关于实际软件的说明 12
1.8  本章小结 12
第2章 重构的内部原理 13
2.1  提高可读性和可维护性 13
2.1.1  使代码更好 13
2.1.2  维护代码而不改变代码作用 15
2.2  获得速度、灵活性和稳定性 16
2.2.1  优先选择组合而非继承 16
2.2.2  通过添加而非修改来更改代码 17
2.3  重构与你的日常工作 18
2.4  在软件上下文中定义“域” 18
2.5  本章小结 19
第3章 拆分长函数 21
3.1  建立第一条规则：为什么是5行 22
3.2  引入重构模式来分解函数 24
3.3  分解函数以平衡抽象 32
3.3.1  规则：EITHER CALL OR PASS 32
3.3.2  应用规则 33
3.4  好的函数名称的属性 33
3.5  分解任务太多的函数 36
3.5.1  规则：IF ONLY AT THE START 36
3.5.2  应用规则 37
3.6  本章小结 39
第4章 让类型代码发挥作用 41
4.1  重构一个简单的if语句 41
4.1.1  规则：NEVER USE IF WITH ELSE 42
4.1.2  应用规则 43
4.1.3  重构模式：REPLACE TYPE CODE WITH CLASSES 45
4.1.4  将代码推入类 48
4.1.5  重构模式：PUSH CODE 
INTO CLASSES 51
4.1.6  内联一个多余的方法 55
4.1.7  重构模式：INLINE METHOD 55
4.2  重构一个大的if语句 57
4.2.1  去除泛化 61
4.2.2  重构模式：SPECIALIZE METHOD 63
4.2.3  唯一允许的switch 65
4.2.4  规则：NEVER USE SWITCH 66
4.2.5  消除if 67
4.3  解决代码重复问题 69
4.3.1  不能用抽象类代替接口吗 71
4.3.2  规则：ONLY INHERIT FROM INTERFACES 71
4.3.3  所有这些代码重复是怎么回事 72
4.4  重构一对复杂的if语句 73
4.5  删除无用代码 76
4.6  本章小结 77
第5章 将类似的代码融合在一起 79
5.1  统一相似的类 80
5.2  统一简单条件 93
5.3  统一复杂条件 96
5.3.1  对条件使用算术规则 97
5.3.2  规则：USE PURE CONDITIONS 98
5.3.3  应用条件算术 100
5.4  跨类统一代码 101
5.4.1  引入UML类图描绘类关系 106
5.4.2  重构模式：INTRODUCE STRATEGY PATTERN 108
5.4.3  规则：NO INTERFACE WITH ONLY ONE IMPLEMENTATION 114
5.4.4  重构模式：EXTRACT INTERFACE FROM 
IMPLEMENTATION 115
5.5  统一类似函数 118
5.6  统一类似代码 121
5.7  本章小结 125
第6章 保护数据 127
6.1  无getter封装 127
6.1.1  规则：DO NOT USE GETTERS OR SETTERS 127
6.1.2  应用规则 129
6.1.3  重构模式：ELIMINATE GETTER OR SETTER 131
6.1.4  消除最后的getter 133
6.2  封装简单数据 136
6.2.1  规则：NEVER HAVE COMMON AFFIXES 136
6.2.2  应用规则 138
6.2.3  重构模式：ENCAPSULATE DATA 143
6.3  封装复杂数据 145
6.4  消除序列不变量 152
6.5  以另一种方式消除枚举 155
6.5.1  通过私有构造函数进行枚举 155
6.5.2  将数字重新映射到类 157
6.6  本章小结 159
第Ⅱ部分 学以致用
第7章 与编译器协作 163
7.1  了解编译器 163
7.1.1  缺点：停机问题限制了编译时知识 164
7.1.2  优点：可达性确保方法返回 164
7.1.3  优点：明确赋值防止访问未初始化的变量 165
7.1.4  优点：访问控制有助于封装数据 166
7.1.5  优点：类型检查证明属性 166
7.1.6  缺点：取消引用null会使应用程序崩溃 167
7.1.7  缺点：算术错误导致溢出或崩溃 167
7.1.8  缺点：越界错误使应用程序崩溃 168
7.1.9  缺点：无限循环使应用程序停滞 168
7.1.10  缺点：死锁和竞争条件导致意外行为 169
7.2  使用编译器 170
7.2.1  使编译器运行 171
7.2.2  不要对抗编译器 173
7.3  信任编译器 178
7.3.1  教编译器不变量 178
7.3.2  注意警告 180
7.4  完全信任编译器 180
7.5  本章小结 181
第8章 远离注释 183
8.1  删除过时的注释 184
8.2  删除注释掉的代码 185
8.3  删除不重要的注释 186
8.4  将注释转换为方法名称 186
8.5  保留记录不变量的注释 187
8.6  本章小结 188
第9章 喜欢删除代码 189
9.1  删除代码可能是下一个前沿 190
9.2  删除代码以消除偶然复杂性 190
9.2.1  缺乏经验导致的技术无知 191
9.2.2  时间压力造成的技术浪费 192
9.2.3  环境造成的技术债务 192
9.2.4  增长带来的技术拖累 192
9.3  根据亲密程度对代码进行分类 193
9.4  删除遗留系统中的代码 194
9.4.1  使用绞杀者模式进行了解 194
9.4.2  使用绞杀者模式改进代码 196
9.5  从冻结项目中删除代码 196
9.5.1  将期望的结果设为默认 197
9.5.2  通过“探针并稳定”模式最大
限度减少浪费 197
9.6  在版本控制中删除分支 198
9.7  删除代码文档 199
9.8  删除测试代码 200
9.8.1  删除乐观测试 200
9.8.2  删除悲观测试 200
9.8.3  修复或删除不稳定测试 201
9.8.4  重构代码以消除复杂的测试 201
9.8.5  专门化测试以加快速度 201
9.9  删除配置代码 202
9.10  删除代码以消除库 203
9.11  从工作功能中删除代码 205
9.12  本章小结 206
第10章  永远不要害怕添加代码 207
10.1  接受不确定性：进入危险 207
10.2  使用探针实验克服对构建错误事物的恐惧 208
10.3  以固定比例克服对浪费或风险的恐惧 209
10.4  通过逐步改进克服对不完美的恐惧 210
10.5  复制和粘贴效果如何改变速度 211
10.6  通过可扩展性进行添加修改 211
10.7  通过添加修改可实现向后兼容 212
10.8  通过功能切换进行添加修改 213
10.9  通过抽象分支进行添加修改 216
10.10  本章小结 218
第11章  遵循代码中的结构 221
11.1  根据范围和来源分类结构 221
11.2  代码反映行为的3种
方式 222
11.2.1  在控制流中表达行为 223
11.2.2  在数据结构中表达行为 224
11.2.3  在数据中表达行为 227
11.3  添加代码以暴露结构 229
11.4  观察而不是预测且使用经验技术 229
11.5  在不理解代码的情况下获得安全性 230
11.5.1  通过测试获得安全性 230
11.5.2  通过掌握获得安全性 230
11.5.3  通过工具辅助获得安全性 230
11.5.4  通过正式验证获得安全性 231
11.5.5  通过容错获得安全性 231
11.6  识别未利用的结构 231
11.6.1  通过提取和封装来利用空白 231
11.6.2  通过统一来利用重复 233
11.6.3  通过封装来利用共同词缀 235
11.6.4  通过动态调度来利用运行时类型 236
11.7  本章小结 237
第12章  避免优化和通用性 239
12.1  力求简单 240
12.2  何时以及如何通用 241
12.2.1  最小化构建以避免通用性 242
12.2.2  统一稳定性相似的事物 242
12.2.3  消除不必要的通用性 242
12.3  何时以及如何优化 243
12.3.1  优化前重构 243
12.3.2  根据约束理论进行优化 245
12.3.3  使用指标指导优化 247
12.3.4  选择好的算法和数据结构 248
12.3.5  使用缓存 249
12.3.6  隔离优化代码 250
12.4  本章小结 251
第13章  让坏代码看起来很糟糕 253
13.1  用坏代码表明过程问题 253
13.2  分成原始代码和遗留代码 254
13.3  定义坏代码的方法 255
13.3.1  本书中的规则：简单而具体 255
13.3.2  代码异味：完整而抽象 256
13.3.3  圈复杂度：算法(客观) 256
13.3.4  认知复杂度：算法(主观) 257
13.4  用于安全破坏代码的规则 257
13.5  安全破坏代码的方法 258
13.5.1  使用枚举 258
13.5.2  使用整数和字符串作为类型代码 259
13.5.3  在代码中放入魔术数字 259
13.5.4  在代码中添加注释 260
13.5.5  在代码中添加空白 261
13.5.6  根据命名对事物进行分组 261
13.5.7  为名称添加上下文 262
13.5.8  创建长方法 262
13.5.9  给方法多个形参 263
13.5.10  使用getter和setter 264
13.6  本章小结 265
第14章  收尾工作 267
14.1  回顾本书的旅程 267
14.1.1  第I部分：动机和具体化 267
14.1.2  第Ⅱ部分：拓宽视野 268
14.2  探索基本原则 268
14.2.1  寻找更小的步骤 268
14.2.2  寻找底层结构 269
14.2.3  使用规则进行协作 269
14.2.4  团队优先于个人 269
14.2.5  简单性优先于正确性 270
14.2.6  使用对象或高阶函数 270
14.3  后续方向 271
14.3.1  微架构路线 271
14.3.2  宏架构路线 272
14.3.3  软件质量路线 272
14.4  本章小结 272
附录  为第Ⅰ部分安装工具 275