從重複到重用

作者 | 技師

來源 | 阿裡技術公衆号

溫馨提示：本文較長，同學們可收藏後再看 :)

一前言

開發技術的發展，從第一次提出“函數/子程式”，實作代碼級重用；到面向對象的“類”，重用資料結構與算法；再到“動态連結庫”、“控件”等重用子產品；到如今流行的雲計算、微服務可重用整個系統。技術發展雖然日新月異，但本質都是重用，隻是粒度不同。是以寫代碼的動機都應是把重複的工作變成可重用的方案，其中重複的工作包括業務上重複的場景、技術上重複的代碼等。合格的系統可以簡化當下重複的工作；優秀的系統還能預見未來重複的工作。

本文不談架構、不談架構，就談寫代碼的那些事兒！後文始終圍繞一個問題的解決方案，不斷發現其中“重複”的代碼，并提煉出“可重用”的抽象，持續“重構”。希望通過這個過程和大家分享一些發現重複代碼和提煉可重用抽象的方法。

二問題

作為貫穿全文的主線，這有一個任務需要開發一個程式來完成：有一份存有職員資訊（姓名、年齡、工資）的檔案“work.txt”，内容如下：

William 35 25000
Kishore 41 35000
Wallace 37 30000
Bruce 39 29999

要求從檔案（work.txt）中讀取員工薪酬，并輸出到螢幕上。
為所有工資小于三萬的員工漲 3000 元。
在螢幕上輸出薪資調整後的結果。
把調整後的結果儲存到原始檔案。

即運作的結果是螢幕上要有八行輸出，“work.txt”的内容将變成：

William 35 28000
Kishore 41 35000
Wallace 37 30000
Bruce 39 32999

三測試

在明确了需求之後，第一步要做的是寫測試代碼，而不是寫功能代碼。《重構》一書中對重構的定義是：“在不改變代碼外在行為的前提下，對代碼做出修改，以改程序式的内部結構。”其中明确指出“代碼外在行為”是不改變的！在不斷疊代重構時，“保證每次重構的行為不變”也是一項重複的工作，是以測試先行不僅能盡早地校驗對需求了解的正确性、還能避免重複測試。本文通過一段 Shell 腳本完成以下工作：

初始化work.txt檔案。
檢查标準輸出的内容與期望的結果是否一緻。
檢查修改後work.txt檔案的内容是否與期望一緻。
清理現場。

将上述代碼儲存成check.sh，待測試的源檔案名作為參數。如果程式通過，會顯示“PASS”，否則會輸出不同的行以及“FAIL”。

四可維護代碼

第一版：It works

每位熟練的程式員都能快速地給出自己的實作。本文示例代碼使用ANSI C99編寫，Mac下用gcc能正常編譯運作，其他環境未測試。選擇C語言是因為主流程式設計語言都或多或少借鑒它的文法，同時它的文法特性也足夠用于示範。

問題很簡單，簡單到把所有代碼都塞到 main 函數裡也不覺得長：

#include < stdio.h>

int main(void) {
  struct {    char name[8];
    int age;
    int salary;
  } e[4];
  FILE *istream, *ostream;
  int i;

  istream = fopen("work.txt", "r");
  for (i = 0; i < 4; i++) {
    fscanf(istream, "%s%d%d", e[i].name, &e[i].age, &e[i].salary);
    printf("%s %d %d\n", e[i].name, e[i].age, e[i].salary);
    if (e[i].salary < 30000) {
      e[i].salary += 3000;
    }
  }
  fclose(istream);

  ostream = fopen("work.txt", "w");
  for (i = 0; i < 4; i++) {
    printf("%s %d %d\n", e[i].name, e[i].age, e[i].salary);
    fprintf(ostream, "%s %d %d\n", e[i].name, e[i].age, e[i].salary);
  }
  fclose(ostream);

  return 0;
}

其中第一個循環從work.txt中讀取4行資料，并把資訊輸出到螢幕（需求#1）；同時為薪資小于三萬的職員增加三千元（需求#2）；第二個循環周遊所有資料，把調整後的結果輸出螢幕（需求#3），并儲存結果到 work.txt（需求#4）。

試試将上述代碼儲存成1.c并執行 ./check.sh 1.c，螢幕上會輸出“PASS”，即通過測試。

第二版：清晰的代碼，重構的基礎

第一版代碼解決了問題，讓原來重複的調薪工作變成簡便的、可反複使用的程式。如果它是C語言課堂作業的答案，看起來還不錯——至少縮進一緻，也沒混用空格和制表符；但從軟體工程的角度來講，它簡直糟糕透了，因為沒有清晰的表達意圖：

魔法常量 4 重複出現，後續負責維護的程式員無法判斷它們是碰巧相等還是有其他原因必需相等。
檔案名work.txt重複出現。
重複且不清晰的檔案指針類型定義，容易忽略 ostream 前面的 *。
e 和 i 變量命名不顧名思義。
變量的定義與使用離得太遠。
無異常處理，檔案可能不可讀。

借喬老爺子的話說：“看不見的地方也要用心做好”——這些代碼的問題使用者雖然看不見也不在乎，但也要用心做好——已有幾處顯眼的地方出現重複。不過，在代碼變得清晰之前，不應急着動手去重構，因為清晰的代碼更容易找出重複！針對上述意圖不明的問題，準備對代碼做以下調整：

确認數字 4 在三處的意義都是員工記錄數，是以定義共享常量 #define RECORD_COUNT 4。
常量"work.txt"和 4 不同，内容雖然相同但意義不同：一個作輸入，一個作輸出。如果也隻簡單的定義一個常量 FILE_NAME 共用，後續兩者獨立變化時，工作量并沒減少。是以去除重複代碼時，切忌隻看表面相同，背後意義相同的才是真正的相同，否則就像給所有常量 1 定義 ONE 别名一樣沒有意義。是以需要定義三個常量 FILE_NAME、INPUT_FILE_NAME 和 OUTPUT_FILE_NAME。
用自定義的檔案類型 typedef FILE File; 替代 FILE，可避免遺漏指針。
變量 e 是所有職員資訊，把變量名改成 employees。
變量 i 是疊代過程的下标，把變量名改成 index。
将 index 變量定義放到 for 語句中。
将 File 變量定義從頂部挪到各自使用之前的位置。
對檔案指針做異常檢查，當檔案無法打開時輸出錯誤資訊并提前終止程式。
程式退出時用 < stdlib.h> 中更語義化的 EXIT_FAILURE，正常退出時用 EXIT_SUCCESS。

你可能會問：“數字30000和3000也是魔法數字，為什麼不調整？”原因是此時它們即不重複也無歧義。整理後的完整代碼如下：

#include < stdlib.h>
#include < stdio.h>

#define RECORD_COUNT 4

#define FILE_NAME "work.txt"
#define INPUT_FILE_NAME FILE_NAME
#define OUTPUT_FILE_NAME FILE_NAME

typedef FILE* File;

int main(void) {
  struct {    char name[8];
    int age;
    int salary;
  } employees[RECORD_COUNT];

  File istream = fopen(INPUT_FILE_NAME, "r");
  if (istream == NULL) {
    fprintf(stderr, "Cannot open %s with r mode.\n", INPUT_FILE_NAME);
    exit(EXIT_FAILURE);
  }
  for (int index = 0; index < RECORD_COUNT; index++) {
    fscanf(istream, "%s%d%d", employees[index].name, &employees[index].age, &employees[index].salary);
    printf("%s %d %d\n", employees[index].name, employees[index].age, employees[index].salary);
    if (employees[index].salary < 30000) {
      employees[index].salary += 3000;
    }
  }
  fclose(istream);

  File ostream = fopen(OUTPUT_FILE_NAME, "w");
  if (ostream == NULL) {
    fprintf(stderr, "Cannot open %s with w mode.\n", OUTPUT_FILE_NAME);
    exit(EXIT_FAILURE);
  }
  for (int index = 0; index < RECORD_COUNT; index++) {
    printf("%s %d %d\n", employees[index].name, employees[index].age, employees[index].salary);
    fprintf(ostream, "%s %d %d\n", employees[index].name, employees[index].age, employees[index].salary);
  }
  fclose(ostream);

  return EXIT_SUCCESS;
}

将以上代碼儲存成2.c并執行 ./check.sh 2.c，得到期望的輸出PASS，證明本次重構沒有改變程式的行為。

第三版：代碼映射需求

經過第二版的優化，單行代碼的意圖已比較清晰，但還存在一些過早優化導緻代碼塊的含義不清晰。

例如第一個循環中耦合了“輸出到螢幕”和“調整薪資”兩個功能，好處是可減少一次循環，性能也許有些提升；但這兩個功能在需求中是互相獨立的，後續獨立變化的可能性更大。假設新需求是第一步輸出到螢幕後，要求使用者輸入指令，再決定是否要進行薪資調整工作。此時，對需求方而言隻新增一個步驟，隻有一個改動；但到了代碼層面，卻不是新增一個步驟對應新增一塊代碼，還會牽涉理論上不相關的代碼塊；負責維護的程式員在不了解背景時，就不确定這兩段代碼放在一起有沒有曆史原因，也就不敢輕易将它們拆開。當系統規模越大，這種與需求不是一一對應的代碼就越讓維護人員手足無措！

回想日常開發，需求改動很小而代碼卻牽一發動全身，根源往往就是過早優化。“優化”和“通用”往往是對立的，優化的越徹底就與業務場景結合越緊密，通用性也越差。比如某個系統會在緩沖隊列中對收到的消息進行排序，上線運作後發現因為産品設計等外部原因，消息可能天然接近排好序，于是用插入排序代替快速排序等更通用的排序算法，這就是一次不通用的優化：它讓系統的性能更好，但系統的适用面更窄。過早的優化就是過早的給系統能力設定天花闆。

理想情況是代碼塊與需求功能點一一對應，例如目前需求有4個功能點，得有4個獨立的代碼塊與之對應。這樣做的好處是：當需求發生變化時，代碼的修改也相對集中。是以，基于第二版本代碼準備做以下調整：

拆分耦合的循環代碼塊，每段代碼塊都隻完成一件事情。
用注釋明确标出每段代碼塊對應的需求。

整理後的完整代碼如下：

#include < stdlib.h>
#include < stdio.h>

#define RECORD_COUNT 4

#define FILE_NAME "work.txt"
#define INPUT_FILE_NAME FILE_NAME
#define OUTPUT_FILE_NAME FILE_NAME

typedef FILE* File;

int main(void) {
  struct {
    char name[8];
    int age;
    int salary;
  } employees[RECORD_COUNT];

  /* 從檔案讀入 */
  File istream = fopen(INPUT_FILE_NAME, "r");
  if (istream == NULL) {
    fprintf(stderr, "Cannot open %s with r mode.\n", INPUT_FILE_NAME);
    exit(EXIT_FAILURE);
  }
  for (int index = 0; index < RECORD_COUNT; index++) {
    fscanf(istream, "%s%d%d", employees[index].name, &employees[index].age, &employees[index].salary);
  }
  fclose(istream);

  /* 1. 輸出到螢幕 */
  for (int index = 0; index < RECORD_COUNT; index++) {
    printf("%s %d %d\n", employees[index].name, employees[index].age, employees[index].salary);
  }

  /* 2. 調整薪資 */
  for (int index = 0; index < RECORD_COUNT; index++) {
    if (employees[index].salary < 30000) {
      employees[index].salary += 3000;
    }
  }

  /* 3. 輸出調整後的結果 */
  for (int index = 0; index < RECORD_COUNT; index++) {
    printf("%s %d %d\n", employees[index].name, employees[index].age, employees[index].salary);
  }

  /* 4. 儲存到檔案 */
  File ostream = fopen(OUTPUT_FILE_NAME, "w");
  if (ostream == NULL) {
    fprintf(stderr, "Cannot open %s with w mode.\n", OUTPUT_FILE_NAME);
    exit(EXIT_FAILURE);
  }
  for (int index = 0; index < RECORD_COUNT; index++) {
    fprintf(ostream, "%s %d %d\n", employees[index].name, employees[index].age, employees[index].salary);
  }
  fclose(ostream);

  return EXIT_SUCCESS;
}

将以上代碼儲存成3.c并執行 ./check.sh 3.c，確定程式的行為沒有改變。

五面向對象風格

第四版：職員對象抽象

經過兩輪改造，代碼結構已足夠清晰；現在可以開始重構，來梳理代碼層次。

最顯眼的就是格式化輸出職員資訊：除了輸出流不同，格式、内容完全相同，四條需求中出現了三次。一般遇到相同/相似代碼時，可以抽象出一個函數：相同的部分寫在函數體中，不同的部分作為參數傳入。此處，能抽象出一個以結構體資料和檔案流為入參的函數，但目前這個結構體還是匿名的，無法作為函數的參數，是以第一步得先給匿名的職員結構體取一個合适的類型名稱：

typedef struct _Employee {  char name[8];
  int age;
  int salary;
} *Employee;

然後抽象公共函數用于格式化輸出 Employee 到 File，這其中還耦合了兩個功能：

Employee 序列化成字元串。
序列化結果輸出到指定檔案流。

因為暫無獨立使用某項功能的場景，目前無需進一步拆分：

void employee_print(Employee employee, File ostream) {
  fprintf(ostream, "%s %d %d\n", employee->name, employee->age, employee->salary);
}

Employee 結構體 + employee_print 函數很容易聯想到面向對象的“類”。面向對象的本質是由一組功能獨立的對象組成系統，對象之間通過發消息協作完成任務，不見得非要有 class 關鍵字，繼承、封裝、多态等文法糖。

對象的“功能獨立”，即高内聚，要求資料和操作資料的相關方法放在一起，大多數支援面向對象的程式設計語言都提供了 class 關鍵字，在語言層面強制捆綁，C語言并沒有這樣的文法，但可以制定編碼規範，讓資料結構與函數在實體上挨得更近。
“給對象發消息”，不同的程式設計語言裡表現形式各不相同，例如在Java中 foo.baz() 就是向 foo 對象發送baz消息，C++中等價的文法是 foo->baz()，Smalltalk中是 foo baz，C語言則是 baz(foo)。

綜上所述，雖然C語言通常被認為不是面向對象的語言，其實它也能支援面向對象風格。沿上述思路，可以抽象出職員對象的四個方法：

employee_read：構造函數，配置設定空間、輸入并反序列化，類似于Java的 new。
employee_free：析構函數，釋放空間，即純手工的 GC。
employee_print：序列化并輸出。
employee_adjust_salary：調整職員薪資，唯一的業務邏輯。

有了職員對象，程式不再隻有一個 main 函數。假設把 main 函數看作應用層，其他函數看作類庫、架構或中間件，這樣程式有了層級，層間僅通過開放的接口通訊，即對象的封裝性。

在Java中有 public、protected、default 和 private 四種可見性修飾符，C語言的函數預設是公開的，加上 static 關鍵字後隻在目前檔案可見。為避免應用層向對象随意發送消息，約定隻有在應用層用到的函數才公開，是以額外定義了 public 和 private 兩個修飾符，目前職員對象的四個方法都是公開的。

重構之後的完整代碼如下：

#include < stdlib.h>
#include < stdio.h>

#define private static
#define public

#define RECORD_COUNT 4

#define FILE_NAME "work.txt"
#define INPUT_FILE_NAME FILE_NAME
#define OUTPUT_FILE_NAME FILE_NAME

typedef FILE *File;

/* 職員對象 */

typedef struct _Employee {
  char name[8];
  int age;
  int salary;
} *Employee;

public void employee_free(Employee employee) {
  free(employee);
}

public Employee employee_read(File istream) {
  Employee employee = (Employee) calloc(1, sizeof(struct _Employee));
  if (employee == NULL) {
    fprintf(stderr, "employee_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  if (fscanf(istream, "%s%d%d", employee->name, &employee->age, &employee->salary) != 3) {
    employee_free(employee);
    return NULL;
  }
  return employee;
}

public void employee_print(Employee employee, File ostream) {
  fprintf(ostream, "%s %d %d\n", employee->name, employee->age, employee->salary);
}

public void employee_adjust_salary(Employee employee) {
  if (employee->salary < 30000) {
    employee->salary += 3000;
  }
}

/* 應用層 */

int main(void) {
  Employee employees[RECORD_COUNT];

  /* 從檔案讀入 */
  File istream = fopen(INPUT_FILE_NAME, "r");
  if (istream == NULL) {
    fprintf(stderr, "Cannot open %s with r mode.\n", INPUT_FILE_NAME);
    exit(EXIT_FAILURE);
  }
  for (int index = 0; index < RECORD_COUNT; index++) {
    employees[index] = employee_read(istream);
  }
  fclose(istream);

  /* 1. 輸出到螢幕 */
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_print(employees[index], stdout);
  }

  /* 2. 調整薪資 */
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_adjust_salary(employees[index]);
  }

  /* 3. 輸出調整後的結果 */
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_print(employees[index], stdout);
  }

  /* 4. 儲存到檔案 */
  File ostream = fopen(OUTPUT_FILE_NAME, "w");
  if (ostream == NULL) {
    fprintf(stderr, "Cannot open %s with w mode.\n", OUTPUT_FILE_NAME);
    exit(EXIT_FAILURE);
  }
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_print(employees[index], ostream);
  }
  fclose(ostream);

  /* 釋放資源 */
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_free(employees[index]);
  }

  return EXIT_SUCCESS;
}

将代碼儲存為4.c，照例執行 ./check.sh 4.c，檢測是否有改變程式行為。

第五版：容器對象抽象

之前的重構，去除了詞法和句法上的重複，就像一篇文章裡的單詞和語句，接着可以看段落有沒有重複，即代碼塊。

與 employee_print 類似，三段循環輸出職員資訊代碼也是明顯的重複，可以抽象出 employees_print，同時也抽象出另一個對象——職員清單—— Employees。參考職員對象，可以抽象出四個與之對應的函數：

employees_read：構造函數，配置設定清單空間，并依次建立職員對象。
employees_free：析構函數，釋放清單空間，以及職員對象的空間。
employees_print：序列化并輸出清單中每一位職員資訊。
employees_adjust_salary：調整所有符合要求職員的薪資。

此時，main 函數隻需調用職員清單對象的方法，不再直接調用職員對象的方法，是以後者可見性從 public 降為 private。

#include < stdlib.h>
#include < stdio.h>

#define private static
#define public

#define RECORD_COUNT 4

#define FILE_NAME "work.txt"
#define INPUT_FILE_NAME FILE_NAME
#define OUTPUT_FILE_NAME FILE_NAME

typedef FILE *File;

/* 職員對象 */

typedef struct _Employee {
  char name[8];
  int age;
  int salary;
} *Employee;

private void employee_free(Employee employee) {
  free(employee);
}

private Employee employee_read(File istream) {
  Employee employee = (Employee) calloc(1, sizeof(struct _Employee));
  if (employee == NULL) {
    fprintf(stderr, "employee_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  if (fscanf(istream, "%s%d%d", employee->name, &employee->age, &employee->salary) != 3) {
    employee_free(employee);
    return NULL;
  }
  return employee;
}

private void employee_print(Employee employee, File ostream) {
  fprintf(ostream, "%s %d %d\n", employee->name, employee->age, employee->salary);
}

private void employee_adjust_salary(Employee employee) {
  if (employee->salary < 30000) {
    employee->salary += 3000;
  }
}

/* 職員清單對象 */

typedef Employee* Employees;

public Employees employees_read(File istream) {
  Employees employees = (Employees) calloc(RECORD_COUNT, sizeof(Employee));
  if (employees == NULL) {
    fprintf(stderr, "employees_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  for (int index = 0; index < RECORD_COUNT; index++) {
    employees[index] = employee_read(istream);
  }
  return employees;
}

public void employees_print(Employees employees, File ostream) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_print(employees[index], ostream);
  }
}

public void employees_adjust_salary(Employees employees) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_adjust_salary(employees[index]);
  }
}

public void employees_free(Employees employees) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_free(employees[index]);
  }
  free(employees);
}

/* 應用層 */

int main(void) {
  /* 從檔案讀入 */
  File istream = fopen(INPUT_FILE_NAME, "r");
  if (istream == NULL) {
    fprintf(stderr, "Cannot open %s with r mode.\n", INPUT_FILE_NAME);
    exit(EXIT_FAILURE);
  }
  Employees employees = employees_read(istream);
  fclose(istream);

  /* 1. 輸出到螢幕 */
  employees_print(employees, stdout);

  /* 2. 調整薪資 */
  employees_adjust_salary(employees);

  /* 3. 輸出調整後的結果 */
  employees_print(employees, stdout);

  /* 4. 儲存到檔案 */
  File ostream = fopen(OUTPUT_FILE_NAME, "w");
  if (ostream == NULL) {
    fprintf(stderr, "Cannot open %s with w mode.\n", OUTPUT_FILE_NAME);
    exit(EXIT_FAILURE);
  }
  employees_print(employees, ostream);
  fclose(ostream);

  /* 釋放資源 */
  employees_free(employees);

  return EXIT_SUCCESS;
}

不要忘記運作 ./check.sh 作回歸測試。

第六版：輸入輸出抽象

此時的 main 函數已經比較清爽，剩下一處明顯的重複：打開檔案并檢查檔案是否正常打開。這屬于檔案相關的操作，可以抽象出一個 file_open 代替 fopen：

private File file_open(char* filename, char* mode) {
  File stream = fopen(filename, mode);
  if (stream == NULL) {
    fprintf(stderr, "Cannot open %s with %s mode.\n", filename, mode);
    exit(EXIT_FAILURE);
  }
  return stream;
}

接着可以繼續抽象職員清單對象的輸入和輸出方法：

employees_input：從檔案中擷取資料并建立職員清單對象。
employees_output：将職員清單對象的内容輸出到檔案。

重構後 employees_read 不再被 main 通路，是以改成 private。重構後的完整代碼如下：

#include < stdlib.h>
#include < stdio.h>

#define private static
#define public

#define RECORD_COUNT 4

#define FILE_NAME "work.txt"
#define INPUT_FILE_NAME FILE_NAME
#define OUTPUT_FILE_NAME FILE_NAME

typedef FILE *File;
typedef char* String;

/* 職員對象 */

typedef struct _Employee {
  char name[8];
  int age;
  int salary;
} *Employee;

private void employee_free(Employee employee) {
  free(employee);
}

private Employee employee_read(File istream) {
  Employee employee = (Employee) calloc(1, sizeof(struct _Employee));
  if (employee == NULL) {
    fprintf(stderr, "employee_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  if (fscanf(istream, "%s%d%d", employee->name, &employee->age, &employee->salary) != 3) {
    employee_free(employee);
    return NULL;
  }
  return employee;
}

private void employee_print(Employee employee, File ostream) {
  fprintf(ostream, "%s %d %d\n", employee->name, employee->age, employee->salary);
}

private void employee_adjust_salary(Employee employee) {
  if (employee->salary < 30000) {
    employee->salary += 3000;
  }
}

/* 職員清單對象 */

typedef Employee* Employees;

private Employees employees_read(File istream) {
  Employees employees = (Employees) calloc(RECORD_COUNT, sizeof(Employee));
  if (employees == NULL) {
    fprintf(stderr, "employees_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  for (int index = 0; index < RECORD_COUNT; index++) {
    employees[index] = employee_read(istream);
  }
  return employees;
}

public void employees_print(Employees employees, File ostream) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_print(employees[index], ostream);
  }
}

public void employees_adjust_salary(Employees employees) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_adjust_salary(employees[index]);
  }
}

public void employees_free(Employees employees) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    employee_free(employees[index]);
  }
  free(employees);
}

/* I/O層 */

private File file_open(String filename, String mode) {
  File stream = fopen(filename, mode);
  if (stream == NULL) {
    fprintf(stderr, "Cannot open %s with %s mode.\n", filename, mode);
    exit(EXIT_FAILURE);
  }
  return stream;
}

public Employees employees_input(String filename) {
  File istream = file_open(filename, "r");
  Employees employees = employees_read(istream);
  fclose(istream);
  return employees;
}

public void employees_output(Employees employees, String filename) {
  File ostream = file_open(filename, "w");
  employees_print(employees, ostream);
  fclose(ostream);
}

/* 應用層 */

int main(void) {
  Employees employees = employees_input(INPUT_FILE_NAME); /* 從檔案讀入 */
  employees_print(employees, stdout); /* 1. 輸出到螢幕 */
  employees_adjust_salary(employees); /* 2. 調整薪資 */
  employees_print(employees, stdout);/* 3. 輸出調整後的結果 */
  employees_output(employees, OUTPUT_FILE_NAME);/* 4. 儲存到檔案 */
  employees_free(employees); /* 釋放資源 */

  return EXIT_SUCCESS;
}

别忘記執行 ./check.sh。

六函數式程式設計

第七版：容器疊代重用

現在，main 裡隻用到了職員清單相關的函數，且代碼和需求幾乎一一對應。這些函數可以看成職員管理領域的DSL，領域特定語言是業務和技術雙方的共識，理論上需求不變，基于DSL開發的業務代碼也不變。之前所有的改動僅要求 main 行為一緻，後續的重構還要盡量保證 main 自身也無任何變化，即API向後相容。

回到繼續挖掘代碼中重複的問題上，其中職員清單方法中幾乎都有一個 for 循環：for (int index = 0; index < RECORD_COUNT; index++) { ... }，例如調整薪資和釋放空間兩段代碼：

for (int index = 0; index < RECORD_COUNT; index++) {
  employee_adjust_salary(employees[index]);
}

for (int index = 0; index < RECORD_COUNT; index++) {
  employee_free(employees[index]);
}

除了循環體中分别調用了 employee_adjust_salary 和 employee_free，其餘都一摸一樣，即它們的疊代規則相同，而循環體不同。是否有可能自定義一個 for 語句代替這些重複的疊代？

在大多數程式設計語言中，if、for 等控制語句是一種特殊的存在，開發者通常無法自定義。這是 if 和 for 在大多數語言中的樣子：

if (condition) {
  ...
}

for (init; term; inc) {
  ...
}

如果把它們想象成是函數，文法可以改成更熟悉的函數調用形式：

if (condition, {
  ...
});

for (init, term, inc, {
  ...
});

和普通函數調用相比，唯一不同的是允許花括号包圍的代碼片段作為參數。是以，若程式設計語言允許代碼作為函數的參數，那就能自定義新的控制語句！這句話隐含了兩個語言特性：

代碼是一種資料類型。
代碼類型的資料可作為函數的參數。

所有程式設計語言都包含一套類型系統，它決定資料的類型，而資料的類型又決定資料的功能。例如，數值類型可以做四則運算；字元串類型的資料可以拼接、查找、替換等；代碼如果也是一種資料類型，就可以随時“執行”它。C語言中具備“執行”能力的元素就是“函數”，函數之于代碼類型，猶如 int、double 之于數值類型，都隻是C這個特定程式設計語言對特定類型的特定實作，換成Visual Basic改叫“過程”，換成Java又稱作“成員方法”。

至于特性#2，它正是函數式程式設計的本質！提到函數式風格，腦海中通常會閃過一些耳熟能詳的詞彙：無副作用、無狀态、易于并行程式設計，甚至是Lisp那扭曲的字首表達式。追根溯源，函數式程式設計源自λ演算——函數能作為值傳遞給其他函數或由其他函數傳回——其本質是函數作為類型系統中的“第一等公民”（First-Class），符合以下四項要求：

可以用變量命名。
可以提供給過程作為參數。
可以由過程作為結果傳回。
可以包含在資料結構中。

對照之下會驚訝地發現，C語言這門看似與函數式程式設計最遠的上古程式設計語言，利用函數指針，居然也完全符合上述條件。觀察 employee_adjust_salary 和 employee_free 兩個函數，都隻有一個 Employee 類型的參數且沒有傳回值，翻譯成C語言就是 typedef void (*EmployeeFn)(Employee)，把它作為函數的參數，就能抽象出：

private void employees_each(Employees employees, EmployeeFn fn) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    fn(employees[index]);
  }
}

在函數式語言中，這類将函數作為參數或傳回值的函數稱為高階函數，C語言裡稱為控制語句。用這個自定義的控制語句代替原生的 for 循環，則代碼可以簡化成：

employees_each(employees, employee_adjust_salary);
employees_each(employees, employee_free);

不過，此時還隻解決了一半問題：employees_read 和 employees_print 中依然有重複的 for 循環，并無法用 employees_each 簡化。原因是這些循環體中函數調用的參數數目與類型和 EmployeeFn 不相容：

employee_read：包含 File 類型的參數，傳回 Employee 類型。
employee_print：包含 Employee 和 File 兩類參數，無傳回值。
EmployeeFn：包含 Employee 類型的參數，無傳回值。

想涵蓋所有場景，最簡單的方法就是提取一個參數與傳回結果的全集——Employee (*EmployeeFn)(Employee, File)——包含 Employee 和 File 兩個類型的參數，且傳回 Employee 類型的結果。用新接口重構 Employee 的四個方法：

忽略無用的參數。
除了employee_free 傳回 NULL，其他都傳回 Employee 入參。

同時，需要改造 employees_each 去适應新接口：加入 File 參數，以及傳回處理結果。在程式設計的語義中，單純利用副作用的疊代被稱為 foreach，而關注疊代每個元素的處理結果則稱為 map，即映射。是以，用 employees_map 取代之前的 employees_each：

private Employees employees_map(Employees employees, File stream, EmployeeFn fn) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    employees[index] = fn(employees[index], stream);
  }
  return employees;
}

重構後的完整代碼如下：

#include < stdlib.h>
#include < stdio.h>

#define private static
#define public

#define RECORD_COUNT 4

#define FILE_NAME "work.txt"
#define INPUT_FILE_NAME FILE_NAME
#define OUTPUT_FILE_NAME FILE_NAME

typedef FILE *File;
typedef char* String;

/* 職員對象 */

typedef struct _Employee {
  char name[8];
  int age;
  int salary;
} *Employee;

typedef Employee (*EmployeeFn)(Employee, File);

private Employee employee_free(Employee employee, File stream) {
  free(employee);
  return NULL;
}

private Employee employee_read(Employee employee, File istream) {
  employee = (Employee) calloc(1, sizeof(struct _Employee));
  if (employee == NULL) {
    fprintf(stderr, "employee_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  if (fscanf(istream, "%s%d%d", employee->name, &employee->age, &employee->salary) != 3) {
    employee_free(employee, NULL);
    return NULL;
  }
  return employee;
}

private Employee employee_print(Employee employee, File ostream) {
  fprintf(ostream, "%s %d %d\n", employee->name, employee->age, employee->salary);
  return employee;
}

private Employee employee_adjust_salary(Employee employee, File stream) {
  if (employee->salary < 30000) {
    employee->salary += 3000;
  }
  return employee;
}

/* 職員清單對象 */

typedef Employee* Employees;

private Employees employees_map(Employees employees, File stream, EmployeeFn fn) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    employees[index] = fn(employees[index], stream);
  }
  return employees;
}

private Employees employees_read(File istream) {
  Employees employees = (Employees) calloc(RECORD_COUNT, sizeof(Employee));
  if (employees == NULL) {
    fprintf(stderr, "employees_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  return employees_map(employees, istream, employee_read);
}

public void employees_print(Employees employees, File ostream) {
  employees_map(employees, ostream, employee_print);
}

public void employees_adjust_salary(Employees employees) {
  employees_map(employees, NULL, employee_adjust_salary);
}

public void employees_free(Employees employees) {
  employees_map(employees, NULL, employee_free);
  free(employees);
}

/* I/O層 */

private File file_open(String filename, String mode) {
  File stream = fopen(filename, mode);
  if (stream == NULL) {
    fprintf(stderr, "Cannot open %s with %s mode.\n", filename, mode);
    exit(EXIT_FAILURE);
  }
  return stream;
}

public Employees employees_input(String filename) {
  File istream = file_open(filename, "r");
  Employees employees = employees_read(istream);
  fclose(istream);
  return employees;
}

public void employees_output(Employees employees, String filename) {
  File ostream = file_open(filename, "w");
  employees_print(employees, ostream);
  fclose(ostream);
}

/* 應用層 */

int main(void) {
  Employees employees = employees_input(INPUT_FILE_NAME); /* 從檔案讀入 */
  employees_print(employees, stdout); /* 1. 輸出到螢幕 */
  employees_adjust_salary(employees); /* 2. 調整薪資 */
  employees_print(employees, stdout);/* 3. 輸出調整後的結果 */
  employees_output(employees, OUTPUT_FILE_NAME);/* 4. 儲存到檔案 */
  employees_free(employees); /* 釋放資源 */

  return EXIT_SUCCESS;
}

這一系列的改造展示了“代碼即資料”的一些好處：使用不支援函數式程式設計的語言開發，将迫使我們永遠在語言恰好提供的基礎功能上工作；而“代碼即資料”讓我們擺脫這樣的束縛，允許自定義控制語句。例如，Java 5引入 foreach 文法糖、Java 7引入 try-with-resource 文法糖，在Java 8之前想要任何新的語言特性隻能等Oracle大發慈悲，Java 8之後想要任何語言特性就可以自給自足！

經過這麼大的改造，切勿忘記測試！

第八版：動态作用域與上下文包裝

上一版本的代碼雖然可以工作，但也暴露出一個常見問題：函數的參數不斷膨脹。這個問題在程式的層次不斷增加過程會慢慢滋生。例如函數 A 會調用 B、B 又調用 C，假設 C 需要一個檔案對象，假設 B 中并不建立檔案對象，就得從 A 依次傳遞到 B 再傳遞到 C。函數調用的層次越深，資料逐層傳遞的問題就越嚴重，上層函數的入參就會爆炸！

這類函數參數過多且逐層傳遞的問題，最簡單的解決方法就是使用全局變量。例如定義一個全局的檔案對象，指向目前輸入/輸出的目标，這樣就能去除所有的檔案對象入參。全局變量的弊端是很難判斷它的影響範圍，不加限制地使用全局變量就和無限制地使用goto一樣，代碼會迅速變成意大利面條。是以，建議有節制地使用全局變量：用完之後及時将值恢複。例如以下代碼：

int is_debug = 0;

void a() {
  if (is_debug == 1) {
    printf("debug is enable\n");
  }
  printf("call a()\n");
}

void b() {
  a();
  printf("call b()\n");
}

void c() {
  int original = is_debug;
  is_debug = 1;
  b();
  is_debug = original;
}

其中函數 c 臨時開啟了調試選項，并在退出前恢複成原始值。一旦忘記恢複，後續所有調試資訊就都會輸出，惡夢就會開始。為避免這種尴尬問題，可以利用上一版本中提到的函數式程式設計的方法，将重複的開啟選項、恢複工作抽象成函數：

typedef void (*Callback)(void);

void with_debug(Callback fn) {
  int original = is_debug;
  is_debug = 1;
  fn();
  is_debug = original;
}

void c() {
  with_debug(b);
}

像 with_debug 這種負責資源配置設定再自動回收（或資源修改再自動恢複）工作的函數稱為上下文包裝器（wrapper），開啟調試選項是一個常見的應用場景，還可以用于自動關閉打開的檔案對象（例如Java 7的try-with-resources）。不過，目前的解決方案在多線程環境下依然有問題，為避免不同的線程之間互相沖突，理想的方案是采用類似Java中的 ThreadLocal 包裝所有全局變量，C語言的多線程方案POSIX thread有Thread Specific元件實作類似的線程特有資料功能，此處就不展開讨論。

綜上所述，我們真正需要的功能似乎是一種代碼的包裝能力：全局變量某個特定的值隻在指定範圍内生效（包括範圍内代碼調用的函數、調用函數的調用等等），類似于會話級别的變量。這種功能被裁剪的全局變量在程式設計語言中稱為動态作用域（Dynamic Scope）變量。

大多數主流程式設計語言隻支援靜态作用域——也叫詞法作用域——在編譯時靜态确定的作用域；但動态作用域是在運作過程中動态确定的。簡言之，靜态作用域由代碼的層次結構決定，動态作用域由調用的堆棧層次結構決定。以下代碼是Perl語言動态作用域變量的示例，儲存成demo.pl，執行 perl demo.pl 能輸出 $v = 1：

sub foo {
    print "\$v = $v\n";
}

sub baz {
    local $v = 1;
    foo;
}

baz;

回到重構問題，利用動态作用域的思路，可以抽象出一個檔案對象包裝器：用指定檔案替換全局的檔案流，退出時恢複。C語言提供了打開指定檔案并替代标準輸入輸出流的函數——freopen——但卻沒自帶恢複的功能，是以不同的平台恢複方法不同，本文以類UNIX環境為例，在unistd.h包下有 dup 和 fdopen 兩個函數，分别用于克隆和恢複檔案句柄。示例代碼如下：

void file_with(String filename, String mode) {
  int handler = dup(mode[0] == 'r'? 0: 1); /* 克隆檔案句柄 */  File stream = freopen(filename, mode, mode[0] == 'r'? stdin: stdout);
  if (stream == NULL) {
    fprintf(stderr, "Cannot open %s with %s mode.\n", filename, mode);
    exit(EXIT_FAILURE);
  }
  /* TODO */  fclose(stream);
  fdopen(handler, mode);                   /* 完成後恢複标準IO */}

有了這個功能，可以删除掉所有函數和接口的 File file 參數！唯一真正和檔案相關的隻剩下 employees_input 和 employees_output，它們分别調用 Employees employees_read() 和 void employees_print(Employees)，為了使用 file_with 做統一的重定向，利用上一版接口全集的方法，把它們的接口統一改成 typedef Employees (*EmployeesFn)(Employees);。最終，重構後的完整代碼如下：

#include < stdlib.h>
#include < stdio.h>

#include < unistd.h>

#define private static
#define public

#define RECORD_COUNT 4

#define FILE_NAME "work.txt"
#define INPUT_FILE_NAME FILE_NAME
#define OUTPUT_FILE_NAME FILE_NAME

typedef FILE *File;
typedef char* String;

/* 職員對象 */

typedef struct _Employee {
  char name[8];
  int age;
  int salary;
} *Employee;

typedef Employee (*EmployeeFn)(Employee);

private Employee employee_free(Employee employee) {
  free(employee);
  return NULL;
}

private Employee employee_read(Employee employee) {
  employee = (Employee) calloc(1, sizeof(struct _Employee));
  if (employee == NULL) {
    fprintf(stderr, "employee_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  if (scanf("%s%d%d", employee->name, &employee->age, &employee->salary) != 3) {
    employee_free(employee);
    return NULL;
  }
  return employee;
}

private Employee employee_print(Employee employee) {
  printf("%s %d %d\n", employee->name, employee->age, employee->salary);
  return employee;
}

private Employee employee_adjust_salary(Employee employee) {
  if (employee->salary < 30000) {
    employee->salary += 3000;
  }
  return employee;
}

/* 職員清單對象 */

typedef Employee* Employees;

typedef Employees (*EmployeesFn)(Employees);

private Employees employees_map(Employees employees, EmployeeFn fn) {
  for (int index = 0; index < RECORD_COUNT; index++) {
    employees[index] = fn(employees[index]);
  }
  return employees;
}

private Employees employees_read(Employees employees) {
  employees = (Employees) calloc(RECORD_COUNT, sizeof(Employee));
  if (employees == NULL) {
    fprintf(stderr, "employees_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  return employees_map(employees, employee_read);
}

public Employees employees_print(Employees employees) {
  return employees_map(employees, employee_print);
}

public void employees_adjust_salary(Employees employees) {
  employees_map(employees, employee_adjust_salary);
}

public void employees_free(Employees employees) {
  employees_map(employees, employee_free);
  free(employees);
}

/* I/O層 */

private File file_open(String filename, String mode) {
  File stream = freopen(filename, mode, mode[0] == 'r'? stdin: stdout);
  if (stream == NULL) {
    fprintf(stderr, "Cannot open %s with %s mode.\n", filename, mode);
    exit(EXIT_FAILURE);
  }
  return stream;
}

private Employees file_with(String filename, String mode, Employees employees, EmployeesFn fn) {
  int handler = dup(mode[0] == 'r'? 0: 1); /* 克隆檔案句柄 */
  File stream = file_open(filename, mode);
  employees = fn(employees);
  fclose(stream);
  fdopen(handler, mode);                   /* 完成後恢複标準IO */
  return employees;
}

public Employees employees_input(String filename) {
  return file_with(filename, "r", NULL, employees_read);
}

public void employees_output(Employees employees, String filename) {
  file_with(filename, "w", employees, employees_print);
}

/* 應用層 */

int main(void) {
  Employees employees = employees_input(INPUT_FILE_NAME); /* 從檔案讀入 */
  employees_print(employees); /* 1. 輸出到螢幕 */
  employees_adjust_salary(employees); /* 2. 調整薪資 */
  employees_print(employees); /* 3. 輸出調整後的結果 */
  employees_output(employees, OUTPUT_FILE_NAME); /* 4. 儲存到檔案 */
  employees_free(employees); /* 釋放資源 */

  return EXIT_SUCCESS;
}

這一版本改動非常大，連應用層接口都有不向下相容的改動，是以不要忘記回歸測試。

本節介紹了一個重構的黑科技——動态作用域。它很有用，Web系統中 Session 變量就是動态作用域；但它也會加大判斷代碼所處上下文的難度，導緻行為不易預測。比如JavaScript中的 this 是JS中唯一一個動态作用域的變量，看看社群對 this 的抱怨就知道它的可怕了，它的值由函數的調用方決定，很難預測後續的系統維護者會把這個函數綁定到哪個對象上。

簡言之，動态有風險，入坑需謹慎！

第九版：資料結構替換

前文都在讨論如何讓代碼變得更抽象、更加可維護，但到底有沒有取得期望的效果，需要一個例子來證明。

之前的版本中，職員清單對象采用的底層存儲方案是固定長度為 4 的數組結構，如果未來"work.txt"檔案中的記錄數不固定，希望把底層的資料結構從數組改成更合适的單連結清單結構。這個需求是底層資料結構的改造，理論上與應用層無關，類似從MySQL遷移到Oracle，理論上至多隻能影響持久層代碼，業務邏輯層等不相關的代碼是不應該有任何修改的。是以，先評估一下這個需求涉及的變更點：

資料結構變化，職員清單結構體 struct _Employees 必然發生變化。
接着，職員清單對象的構造函數 employees_read 也會發生變化。
然後，與構造函數對應的析構函數 employees_print 也會變化。
最後，資料結構的疊代方法也會變化 employees_map。

除了以上四點，其他任何與資料結構本身無關的代碼都不應該發生變化。是以，代碼重構完并通過測試之後，如果所有的改動範圍确實隻出現在上述四點中，證明前文所有的改造有效——隻改動與需求相關的代碼段；否則，證明代碼抽象程度依舊不夠，一段代碼中還耦合着多個業務邏輯，依舊牽一發動全身。

最終重構後的完整代碼如下，改造過程此處就不再詳述，大家可以一起動手試着重構看看。

#include < stdlib.h>
#include < stdio.h>

#include < unistd.h>

#define private static
#define public

#define FILE_NAME "work.txt"
#define INPUT_FILE_NAME FILE_NAME
#define OUTPUT_FILE_NAME FILE_NAME

typedef FILE *File;
typedef char* String;

/* 職員對象 */

typedef struct _Employee {
  char name[8];
  int age;
  int salary;
} *Employee;

typedef Employee (*EmployeeFn)(Employee);

private Employee employee_free(Employee employee) {
  free(employee);
  return NULL;
}

private Employee employee_read(Employee employee) {
  employee = (Employee) calloc(1, sizeof(struct _Employee));
  if (employee == NULL) {
    fprintf(stderr, "employee_read: out of memory\n");
    exit(EXIT_FAILURE);
  }
  if (scanf("%s%d%d", employee->name, &employee->age, &employee->salary) != 3) {
    employee_free(employee);
    return NULL;
  }
  return employee;
}

private Employee employee_print(Employee employee) {
  printf("%s %d %d\n", employee->name, employee->age, employee->salary);
  return employee;
}

private Employee employee_adjust_salary(Employee employee) {
  if (employee->salary < 30000) {
    employee->salary += 3000;
  }
  return employee;
}

/* 職員清單對象 */

typedef struct _Employees {
  Employee employee;
  struct _Employees *next;
} *Employees;

typedef Employees (*EmployeesFn)(Employees);

private Employees employees_map(Employees employees, EmployeeFn fn) {
  for (Employees p = employees; p; p = p->next) {
    p->employee = fn(p->employee);
  }
  return employees;
}

private Employees employees_read(Employees head) {
  Employees tail = NULL;
  for (;;) {
    Employee employee = employee_read(NULL);
    if (employee == NULL) {
      return head;
    }

    Employees employees = (Employees) calloc(1, sizeof(Employees));
    if (employees == NULL) {
      fprintf(stderr, "employees_read: out of memory\n");
      exit(EXIT_FAILURE);
    }

    if (tail == NULL) {
      head = tail = employees;
    } else {
      tail->next = employees;
      tail = tail->next;
    }
    tail->employee = employee;
  }
}

public Employees employees_print(Employees employees) {
  return employees_map(employees, employee_print);
}

public void employees_adjust_salary(Employees employees) {
  employees_map(employees, employee_adjust_salary);
}

public void employees_free(Employees employees) {
  employees_map(employees, employee_free);
  while (employees) {
    Employees e = employees;
    employees = employees->next;
    free(e);
  }
}

/* I/O層 */

private File file_open(String filename, String mode) {
  File stream = freopen(filename, mode, mode[0] == 'r'? stdin: stdout);
  if (stream == NULL) {
    fprintf(stderr, "Cannot open %s with %s mode.\n", filename, mode);
    exit(EXIT_FAILURE);
  }
  return stream;
}

private Employees file_with(String filename, String mode, Employees employees, EmployeesFn fn) {
  int handler = dup(mode[0] == 'r'? 0: 1); /* 克隆檔案句柄 */
  File stream = file_open(filename, mode);
  employees = fn(employees);
  fclose(stream);
  fdopen(handler, mode);                   /* 完成後恢複标準IO */
  return employees;
}

public Employees employees_input(String filename) {
  return file_with(filename, "r", NULL, employees_read);
}

public void employees_output(Employees employees, String filename) {
  file_with(filename, "w", employees, employees_print);
}

/* 應用層 */

int main(void) {
  Employees employees = employees_input(INPUT_FILE_NAME); /* 從檔案讀入 */
  employees_print(employees); /* 1. 輸出到螢幕 */
  employees_adjust_salary(employees); /* 2. 調整薪資 */
  employees_print(employees); /* 3. 輸出調整後的結果 */
  employees_output(employees, OUTPUT_FILE_NAME); /* 4. 儲存到檔案 */
  employees_free(employees); /* 釋放資源 */

  return EXIT_SUCCESS;
}

首先執行 check.sh 檢查功能是否正确，然後執行 diff 檢查修改點是否有超出預期。

七總結

本文對代碼做了多次疊代，介紹如何使用面向對象、函數式程式設計、動态作用域等方法不斷抽象其中重複的代碼。通過這個過程，可以看到面向對象程式設計和函數式程式設計兩者并非對立，都是為了提高代碼的抽象，可以相輔相成：

函數式程式設計重點是增強類型系統：常見的資料類型有數值型、字元串型等，函數式程式設計要求函數也是一種資料類型，即代碼也是一種資料。
面向對象風格側重于代碼的組織形式：把資料和操作資料的函數組織在類中，提高内聚；對象之間通過調用開放的接口通訊，降低耦合。

本文隻是抛磚引玉，并不是标準答案，是以并不是要求後續所有的代碼都要抽象多少次才能送出。是以，首次傳遞出去的代碼，到底要到達第幾版本，這個問題留給大家自己思考。

在說再見之前，再分享兩個關于識别重複、抽象重用的tips。

編碼規範

編碼規範在很多地方被反複強調，也特别容易引發争論（如花括号的位置）；在我看來，編碼規範最大的價值是便于發現代碼中的重複！

程式設計語言本身或多或少會有一些限制，例如檔案必須先 open 再 close，這類問題一般不容易出現不一緻；更多的問題并不會在語言層面做限制，例如 if else 中異常處理是放在if代碼塊中還是 else，這類問題沒有标準答案，公說公有理婆說婆有理。程式設計規範用于解決第二類問題：TOOWTDI（There is Only One Way To Do It）。

隻有統一才能清晰，清晰的代碼不一定是短的代碼，但啰嗦的代碼一定是不清晰的，勿忘清晰是重構的基礎。

重構順序

開始重構時，切記重構的元素一定要從小到大！

就像文章的元素，從單詞、句子、段落依次遞增，重構時也應遵循從小到大的原則，依次解決重複的常量/變量、語句、代碼塊、函數、類、庫……發現重複不能隻浮于表面相同，得了解其背後的意義，隻有後續需要一起變化的重複才是真正的重複。從小到大的重構順序能幫助了解每一個重複的細節，而反之卻容易導緻忽略這些背後的細節。

還記得"work.txt"這個重複的檔案名嗎？如果采用從大到小的重構順序，極有可能馬上抽象了一個重用的 file_open，把檔案名寫死在這個公共函數裡。這樣做的确解決了重複問題，整段代碼隻有這一處出現"work.txt"；但是一旦輸入輸出的檔案名變得不同，這個公共函數隻能棄用。

傳遞接力棒

本文第九版的代碼遠不是完美的代碼，還存在不少重複：

employee_read 和 employees_read 中都用到 calloc 配置設定記憶體空間，并檢查是否配置設定成功。
employees_print 之于 employee_print 和 employees_adjust_salary 之于employee_adjust_salary，差別隻是前者名稱多了一個s，是否有可能根據這個規則自動為 Employees 生成與 Employee 一一對應的函數？
……

試試有什麼辦法繼續抽象。第二個問題是讓代碼生成代碼，給個提示，可以用“宏”。

附錄I：Common Lisp的解決方案

從函數式風格重構的過程中能體會到，如果C語言能支援動态類型，就不必在 employee_read 中做強制轉換；如果C語言支援匿名函數，亦不用寫這麼多小函數；如果C語言除了能讀入整型、字元串等基礎類型，還能直接讀入數組、結構體等複合類型，就無需 employee_read 和 employee_print 等輸入輸出函數……

其實許多程式設計語言（如Python、Ruby、Lisp等）已經讓這些“如果”變成現實！讓看看Common Lisp的解決方案：

;; 從檔案讀入
(defparameter employees
  (with-open-file (file #P"work.lisp") ; 内置檔案環繞包裝
    (read file))) ; 内置讀取清單等複雜結構

;; 1. 輸出到螢幕
(print employees) ; 内置輸出清單等複雜結構

;; 2. 調整薪資
(dolist (employee employees)
  (if (< (third employee) 30000)
    (incf (third employee) 3000))) ; 就地修改

;; 3. 輸出調整後的結果
(print employees)

;; 4. 儲存到檔案
(with-open-file (file #P"work.lisp" :direction :output :if-exists :overwrite)
  (print employees file)) ; print是多态函數，file取代預設标準輸出流

其中work.lisp的内容是：

((William 35 25000)
 (Kishore 41 35000)
 (Wallace 37 30000)
 (Bruce 39 29999))

資料檔案的格式是Common Lisp的清單結構，Lisp支援直接從流中讀取 sexp 複雜結構，猶如JavaScript直接讀寫JSON結構資料。

2021阿裡雲峰會暨開發者大會

大資料+AI将會産生怎樣的火花？雲上的大資料開發該怎麼玩？開發者如何加入大資料開源社群？5月29日，阿裡雲開發者大會特邀阿裡巴巴集團副總裁、阿裡雲智能計算平台事業部進階研究員賈揚清和你分享《雲上大資料與AI開發範式的演進》。

點選這裡

，立即參與吧！

從重複到重用

一前言

二問題

三測試

四可維護代碼

五面向對象風格

六函數式程式設計

七總結

繼續閱讀

适用于JavaScript的ECMAScript 2020規範向前發展

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

NOSQL安全攻擊

mybatis_入門程式Mybatis入門

JS生成uuid的四種方法

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

面試題解析：你接口測試是怎麼做的？

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

layui多任務上傳添加進度條

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method

hdu7108哈希

從重複到重用

一 前言

二 問題

三 測試

四 可維護代碼

五 面向對象風格

六 函數式程式設計

七 總結

繼續閱讀

一前言

二問題

三測試

四可維護代碼

五面向對象風格

六函數式程式設計

七總結