既有设计，永远有改进空间

代码会随时间流逝而烂掉，写的再好的程序代码，若是发布了就一直保持原样，照样会风化、破碎乃至分崩离析。这是客观规律，避免这种命运的唯一出路是持续重构。

但前提是深入地理解架构、理解业务、理解需求，不能为了重构而重构。重构是有成本的，读《重构》是为了能在开始的时候就不写或者少写那些味道很坏的代码，减少因设计失误而导致徒劳无益地反复重构。

重构的基本功

1. 识别坏味道
2. 测试先行
3. 行为保持的变更动作

如何做到“行为保持的变更动作”，一种是在原本函数上大刀阔斧的修改，一种是新建新的函数，做完想要的调整之后，再整体替换原本的函数。显然后者的做法更加可控、出错时测试失败的范围更小。

旧的不变，新的创建，一步切换，旧的再见。

最近遇到坏味道的代码

在查碰撞的一个bug时，策划使用了一个很少用的配置参数，这个参数在代码中是由基类去处理的，具体的处理方式是对外部传入的源数据通过这个参数去计算新的数据。

// 这里的offset是策划配置的参数
DstData ExcuteData(SrcData a, int offset);

基类和子类都有这个函数，子类覆写了ExcuteData，会先调用父类的ExcuteData再来处理子类的逻辑。

DstData ExcuteData(SrcData a, int offset) {
    Base.ExcuteData(a, offset);
    // 这里就假设SrcData也是int
    m_dstData = a + offset;
    return m_dstData;
}

遇到的问题：策划配置了这个字段不生效

我首先排查了代码中有没有处理这个字段，发现父类处理了，就理所当然的以为处理逻辑有问题，往这个方向死磕。

但最后绕了一圈发现是，子类的实现方式有问题，虽然调用了父类的ExcuteData，但是处理子类的逻辑时，又拿源数据去计算，导致父类的处理结果被丢弃了。

改进方向：感觉应该加一个OnExcuteData，子类去实现这个新加的函数，然后父类传递处理过的数据给OnExcuteData。

重构，第一个示例

具体例子可看对应章节ebook/refactoring2.pdf

下面主要总结重构的工作方式

何时该重构：需求的变化使重构变得重要。

如果一段代码能正常工作，并且不会再被修改，那么完全可以不去重构它。能改进之当然很好，但若没人需要去理解它，它就不会真正妨碍什么。如果确实有人需要理解它的工作原理，并且觉得理解起来很费劲，那你就需要改进一下代码了。

明确重构的目的：
比如常见的是当前代码新增需求的难度太大了，那重构完的代码应该是：

• 新增需求只关心我新增的逻辑，以及能很好地调用已有逻辑
• 新增需求是简易的，能从配置去新增就配置，不能就新增子类或实现方法

示例初始代码的问题：

• 结构不清晰，一个函数做了所有事情
• 新增特性(需求)，找不到可修改点

如果直接在源程序新增一个功能，已经到了必须复制一份这个函数的地步，这会导致：后续如果要修改这个程序，必须旧函数和新函数两个地方都修改，造成了重复代码。

重构的第一步：构建测试体系，避免引入未知新bug

测试清单可以检验每次修改是否影响了程序的已有功能，最好是有自我检验功能，比如脚本自动跑测试，减少调试成本。

每次改动最好都跑一次测试，避免累积大量的改动后才发现崩了，这时候就需要投入大量时间定位问题。

版本控制，如果改动通过测试，可以提交修改到版本控制。好处是代码可追溯，了解自己每步在做的工作；以及代码可回滚，防止某次改动改崩了。

重构手段：

• 提炼函数：拆解大函数，单一职责，需要小心变量的作用域。
• 拆分循环：一个循环里面不应该处理过多的事情，可以拆成几个独立的循环。这里与性能的平衡，一方面自己清楚这个循环的时间复杂度，大多数情况下拆成两个并不会有太大的影响，另一方面现代编译器会有一些优化。
• 拆分阶段：如果函数已经拆到已经做一件事，一般是不需要再细拆。但如果有需求是对这个函数进行变种，比如这个函数有计算数据再格式化数据，而需求是需要有两种不同的格式化，这就要考虑再对这个函数进一步拆解。
• 有意义的变量和函数命名：提升代码的可读性，通过名字就知道变量和函数在做什么事。
• 减少生命周期长的变量（作用域大）：每次通过计算得出的变量，就没必要拥有较长的生命周期，减少重构负担。但这里也要注意是否影响性能，可读性与性能之间的平衡要把握好，但一般可读性先行，后续性能调优（如果一开始就判断对性能不会有太大影响）。
• 减少多余的注释：代码比较清晰的情况下，一些注释显得没必要。
• 保持数据不可变：对传进来的参数，尽量不要去修改里面的内容。像lua传入的table，如果过多函数都在修改这个table，追踪问题难度将是地狱级，如果实在要修改参数的内容，性能允许的情况可以考虑返回参数的副本。
• 以多态取代条件表达式：前面提到重构完新增需求应该是简易的，不需要去关心已有代码。多态是一个很好的手段，新增需求时只需要实现对应的子类，不要在原有的条件表达式去新增，可以配合工厂函数去实现。

补充一点对性能的讨论：游戏里对性能会苛刻点，如果是帧循环里处理的函数，可读性要稍微给性能让步。

结语

三个较为重要的节点：

1. 将原函数分解成一组嵌套的函数
2. 应用拆分阶段分离计算逻辑与输出格式化逻辑
3. 以及为计算器引入多态性来处理计算逻辑

好代码的检验标准就是人们是否能轻而易举地修改它

有人需要修改代码时，他们应能轻易找到修改点，应该能快速做出更改，而不易引入其他错误。

代码

重构前

{
  "hamlet": { "name": "Hamlet", "type": "tragedy" },
  "as-like": { "name": "As You Like It", "type": "comedy" },
  "othello": { "name": "Othello", "type": "tragedy" }
}

[
  {
    "customer": "BigCo",
    "performances": [
      {
        "playID": "hamlet",
        "audience": 55
      },
      {
        "playID": "as-like",
        "audience": 35
      },
      {
        "playID": "othello",
        "audience": 40
      }
    ]
  }
]

function statement (invoice, plays) {
  let totalAmount = 0;
  let volumeCredits = 0;
  let result = `Statement for ${invoice.customer}\n`;
  const format = new Intl.NumberFormat("en-US",
                        { style: "currency", currency: "USD",
                          minimumFractionDigits: 2 }).format;
  for (let perf of invoice.performances) {
    const play = plays[perf.playID];
    let thisAmount = 0;

    switch (play.type) {
    case "tragedy":
      thisAmount = 40000;
      if (perf.audience > 30) {
        thisAmount += 1000 * (perf.audience - 30);
      }
      break;
    case "comedy":
      thisAmount = 30000;
      if (perf.audience > 20) {
        thisAmount += 10000 + 500 * (perf.audience - 20);
      }
      thisAmount += 300 * perf.audience;
      break;
    default:
        throw new Error(`unknown type: ${play.type}`);
    }

    // add volume credits
    volumeCredits += Math.max(perf.audience - 30, 0);
    // add extra credit for every ten comedy attendees
    if ("comedy" === play.type) volumeCredits += Math.floor(perf.audience / 5);

    // print line for this order
    result += ` ${play.name}: ${format(thisAmount/100)} (${perf.audience} seats)\n`;
    totalAmount += thisAmount;
  }
  result += `Amount owed is ${format(totalAmount/100)}\n`;
  result += `You earned ${volumeCredits} credits\n`;
  return result;
}

重构后

import createStatementData from "./createStatementData.js";
function statement(invoice, plays) {
  return renderPlainText(createStatementData(invoice, plays));
}
function renderPlainText(data, plays) {
  let result = `Statement for ${data.customer}\n`;
  for (let perf of data.performances) {
    result += ` ${perf.play.name}: ${usd(perf.amount)} (${
      perf.audience
    } seats)\n`;
  }
  result += `Amount owed is ${usd(data.totalAmount)}\n`;
  result += `You earned ${data.totalVolumeCredits} credits\n`;
  return result;
}
function htmlStatement(invoice, plays) {
  return renderHtml(createStatementData(invoice, plays));
}
function renderHtml(data) {
  let result = `<h1>Statement for ${data.customer}</h1>\n`;
  result += "<table>\n";
  result +=
    "<tr><th>play</th><th>seats</th><th>cost</th></tr>";
  for (let perf of data.performances) {
    result += ` <tr><td>${perf.play.name}</td><td>${perf.audience}</td>`;
    result += `<td>${usd(perf.amount)}</td></tr>\n`;
  }
  result += "</table>\n";
  result += `<p>Amount owed is <em>${usd(
    data.totalAmount
  )}</em></p>\n`;
  result += `<p>You earned <em>${data.totalVolumeCredits}</em> credits</p>\n`;
  return result;
}
function usd(aNumber) {
  return new Intl.NumberFormat("en-US", {
    style: "currency",
    currency: "USD",
    minimumFractionDigits: 2,
  }).format(aNumber / 100);
}

export default function createStatementData(invoice, plays) {
  const result = {};
  result.customer = invoice.customer;
  result.performances = invoice.performances.map(enrichPerformance);
  result.totalAmount = totalAmount(result);
  result.totalVolumeCredits = totalVolumeCredits(result);
  return result;

  function enrichPerformance(aPerformance) {
    const calculator = createPerformanceCalculator(aPerformance, playFor(aPerformance));
    const result = Object.assign({}, aPerformance);
    result.play = calculator.play;
    result.amount = calculator.amount;
    result.volumeCredits = calculator.volumeCredits;
    return result;
  }
  function playFor(aPerformance) {
    return plays[aPerformance.playID]
  }
  function totalAmount(data) {
    return data.performances
      .reduce((total, p) => total + p.amount, 0);
  }
  function totalVolumeCredits(data) {
    return data.performances
      .reduce((total, p) => total + p.volumeCredits, 0);
  }
}
function createPerformanceCalculator(aPerformance, aPlay) {
    switch(aPlay.type) {
    case "tragedy": return new TragedyCalculator(aPerformance, aPlay);
    case "comedy" : return new ComedyCalculator(aPerformance, aPlay);
    default:
        throw new Error(`unknown type: ${aPlay.type}`);
    }
}
class PerformanceCalculator {
  constructor(aPerformance, aPlay) {
    this.performance = aPerformance;
    this.play = aPlay;
  }
  get amount() {
    throw new Error('subclass responsibility');
  }
  get volumeCredits() {
    return Math.max(this.performance.audience - 30, 0);
  }
}
class TragedyCalculator extends PerformanceCalculator {
  get amount() {
    let result = 40000;
    if (this.performance.audience > 30) {
      result += 1000 * (this.performance.audience - 30);
    }
    return result;
  }
}
class ComedyCalculator extends PerformanceCalculator {
  get amount() {
    let result = 30000;
    if (this.performance.audience > 20) {
      result += 10000 + 500 * (this.performance.audience - 20);
    }
    result += 300 * this.performance.audience;
    return result;
  }
  get volumeCredits() {
    return super.volumeCredits + Math.floor(this.performance.audience / 5);
  }
}