重构读书笔记——重新组织函数

Extract Method 提炼方法

---

动机

• Extract Method 是最常用的重构手法之一。
• 函数过长或者需要注释才能理解代码的用途。
• 增加代码的清晰度和重用度。

做法

1. 创造一个新函数，更具函数的意图来命名。（以它“做什么”来命名，而不是“怎样做”）

即使你想要提炼的代码非常简单，例如只是一条消息或一个函数调用，只要新函数的名称能够以更好地方式昭示代码意图，你也应该提炼它，但如果你想不出一个更有意义的名称，就别动。

1. 将提炼的代码从源函数复制到目标函数中。
2. 检查是否引用了“作用域限于源函数”的变量。（包括局部变量和源函数参数）
3. 检测是否有“仅用于被提炼代码段”的临时变量，若有，则在目标函数中声明临时变量。
4. 检查提炼代码段，检测局部变量的值被修改，如果有，则尝试将其改为一个查询（再提炼一个函数？），赋值给相关变量。
5. 将提炼代码中需要读取的局部变量当做参数传给目标函数。
6. 编译、替换。（删除移入到提炼函数内的局部变量在源函数中的声明）

Inline Method (内联函数)

---

一个函数的本体与名称同样清楚易懂，在函数调用点插入函数本体，然后移除该函数。

重构前

int GetRating()     
{
    return (MoreThanFiveLateDeliveries()) ? 2 : 1;
} 

bool MoreThanFiveLateDeliveries()
{
    return _numberOfLateDeliveries > 5;
}

重构后

int GetRating()
{
    return (_numberOfLateDeliveries > 5)? 2 : 1;
}

动机

• 函数过于简单，内部代码与函数名一样清晰。
• 组织多个不合理的函数时，可以先将函数内联到一个函数中，然后再使用提炼函数等方法进行重构。

做法

1. 检查函数，确定不具多态性。

如果子类继承了这个函数，就不要将此函数内联，因为子类无法覆写一个根本不存在的函数。

2. 找出函数所有调用点。
3. 将调用点替换为本体。
4. 编译，测试。
5. 删除函数定义。

Inline Temp (内联临时变量)

---

一个临时变量，只被赋值一次，并且妨碍了其他重构手法。
将所有对该变量的引用动作，替换为对它赋值的那个表达式自身。

重构前

double basePrice = anOrder.basePrice();
return (basePrice > 100);

重构后

return (anOrder.basePrice() > 100);

动机

• 多半是使用在别的重构手法中。如Replace Temp with Query 或者Inline Temp等.

做法

1. 检查赋值语句，确保等号右边表达式没有副作用。
2. 确保变量只被赋值一次，可以用不可修改关键字来修饰（如java中的final），再编译，看是否有报错。
3. 找到所有临时变量引用点，替换为表达式。
4. 编译，测试，删除原临时变量的声明和赋值。

个人感觉这种方法，如果不是特殊需求，不是很有重构的必要，不能为了重构而重构。

Replace Temp with Query(以查询取代临时变量)

---

程序以一个临时变量保存某一表达式的运算结果。
将这个表达式提炼到一个独立函数中。将这个临时变量的所有引用点替换为对新函数的调用。此后，新函数就可被其他函数调用

重构前

double basePrice = _quantity * _itemPrice;
if(basePrice > 1000)
    return basePrice * 0.95;
else
    return basePrice * 0.98;

重构后

if(BasePrice() > 1000)
    return BasePrice() * 0.95;
else 
    return BasePrice() * 0.98;
...
double BasePrice()
{
    return _quantity * _itemPrice;
}

动机

• 临时变量只能在所属函数内使用，可能会驱使你写出更长的函数，因为只有这样才能访问到需要的临时变量（比如多个函数都需要使用时）。写成一个查询，则同一个尅中的所有函数都可获取这份信息。
• 经常用在Extrct Method 中。
• 如果一个变量被赋值多次，可能先需要使用Split Temporary Variable或者 Separate Query from Modifier处理

做法

1. 找出只被赋值一次的临时变量。

如果变量赋值超过一次，考虑使用Split Temporary Variable分割成多个变量。

1. 将临时变量声明为不可变类型。（确保变量只被赋值一次）
2. 将变量右侧的表达式提炼到一个单独函数中。确保无副作用，不改变对象内容。
3. 编译，测试。
4. 对该变量使用Inline Temp。

频繁的函数调用可能会有一点点性能问题，但是清晰的逻辑更容易维护代码，找到更好的优化方案。如果性能开销确实很大，则可使用变得方法。

Introduce Explaining Variable(引入解释性变量)

---

将一个复杂的表达式（或其中一部分）的结果放进一个临时变量，以此变量名来解释表达式的用途

重构前

if((platform.ToUpperCase().IndexOf("Mac") > -1 
&& (browser.ToUpperCase().IndexOf("IE") > -1)
&& WasInitlized()
&& Resize > 0)
{
    //do something
}

重构后

bool isMacOs = platform.ToUpperCase().IndexOf("Mac") > -1 ;
bool isIEBrowser = browser.ToUpperCase().IndexOf("IE") > -1);
bool wasResized = resize > 0;
if(isMacOs && isIEBrowser 
&& WasInitialized() && wasResized)
{
    //do something
}

动机

• 表达式复杂难以阅读，可以使用该方法分解，便于管理。
• 较长的算法中，可以使用该方法解释步骤的意义。
• 可以使用Extract Method 来替换。

做法

1. 声明临时变量，将复杂表达式中一部分动作赋值给临时变量。
2. 用临时变量替换表达式中“运算结果”的部分。
3. 编译，测试。
4. 重复上述操作，处理表达式其他部分。

Extract Method在很多时候比该方法更容易实现，在Extract Method比较麻烦的时候再考虑该方法。

Split Temporary Variable(分解临时变量)

---

程序中某个临时变量被赋值超过一次，并且它既不是循环变量，也不是用于收集计算结果。
针对每次赋值，创造一个独立、对应的临时变量。

重构前

double temp = 2 * (_height * _width);
Print(temp);
temp = _height * _width;
Print(temp);

重构后

double perimeter = 2 * (_height * _width);
Print(perimeter);
double area = _height * _width;
Print(area);

动机

• 除“循环变量”和“结果收集变量”，同一变量被赋值多次，会使变量承担多个责任，有可能引起代码阅读者糊涂。

做法

1. 在待分解的临时变量的声明及其第一次被赋值处，修改器名称。
2. 新临时变量声明为不可变类型。
3. 在第二次赋值之前，使用新名称替换之前的引用点。
4. 编译测试。
5. 重复上述操作。

Remove Assignments to Parameters(移除对参数的赋值)

---

代码对一个参数进行赋值。
以一个临时变量取代该函数的位置

重构前

int Discount(int inputVal, int quantity, int yearToDate)
{
    if(inputVal > 50) inputVal -= 2;
    //do something
}

重构后

int Discount(int inputVal, int quantity, int yearToDate)
{
    int result = inputVal;
    if(inputVal > 50) result -= 2;
    //do something
}

动机

• 可能会降低代码清晰度。
• 复杂的参数对象，可能会导致对原参数的引用。
• 输出参数除外。（如 C#中 out 修饰的参数）

做法

1. 建立一个临时变量，把待处理的参数赋值给它。
2. 以“对参数的赋值”为界，将其后参数的引用点替换为临时变量。
3. 修改赋值语句。
4. 编译、测试。

注意值传递和引用传递

Replace Method With Method Object(以函数对象取代函数)

---

你有一个大型函数，对局部变量的使用使你无法使用Extend Method
将这个函数放进一个单独对象中，局部变量就成了对象内的字段，可以在同一对象中，将这个大型函数分解成多个小函数。

动机

• 函数过长，局部变量过多，Extract Method 比较困难。

做法

1. 建立一个新类，根据函数的用途，为类命名。
2. 建立一个函数原先对象的字段，将这个字段称为源字段（声明为不可变）。对原函数的临时变量和参数创建字段，并保存。
3. 建立一个构造函数，接收源对象和参数。
4. 建立一个Compute()函数。
5. 将原函数复制到Compute函数中，使用对象中的字段，替换原函数中的临时变量。
6. 编译。
7. 使用其他重构方法，精简函数。

Substitute Algorithm(替换算法)

---

动机

• 有更简洁、更高效、更清晰的算法。
• 需要就算法不足以支持某些功能。

做法

1. 算法过于复杂，可拆分成小算法，再处理。
2. 测试，与原算法结果对比。