開發與維運

從重複到重用

2021-05-26

image.png

作者 | 技師
來源 | 阿里技術公眾號

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

一 前言

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

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

二 問題

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

William 35 25000
Kishore 41 35000
Wallace 37 30000
Bruce 39 29999
  1. 要求從文件（work.txt）中讀取員工薪酬，並輸出到屏幕上。
  2. 為所有工資小於三萬的員工漲 3000 元。
  3. 在屏幕上輸出薪資調整後的結果。
  4. 把調整後的結果保存到原始文件。

即運行的結果是屏幕上要有八行輸出，“work.txt”的內容將變成：

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

三 測試

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

  • 初始化work.txt文件。
  • 檢查標準輸出的內容與期望的結果是否一致。
  • 檢查修改後work.txt文件的內容是否與期望一致。
  • 清理現場。

image.png

將上述代碼保存成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語言課堂作業的答案，看起來還不錯——至少縮進一致，也沒混用空格和製表符；但從軟件工程的角度來講，它簡直糟糕透了，因為沒有清晰的表達意圖：

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

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

  1. 確認數字 4 在三處的意義都是員工記錄數，因此定義共享常量 #define RECORD_COUNT 4。
  2. 常量"work.txt"和 4 不同，內容雖然相同但意義不同：一個作輸入，一個作輸出。如果也只簡單的定義一個常量 FILE_NAME 共用，後續兩者獨立變化時，工作量並沒減少。所以去除重複代碼時，切忌只看表面相同，背後意義相同的才是真正的相同，否則就像給所有常量 1 定義 ONE 別名一樣沒有意義。所以需要定義三個常量 FILE_NAME、INPUT_FILE_NAME 和 OUTPUT_FILE_NAME。
  3. 用自定義的文件類型 typedef FILE File; 替代 FILE，可避免遺漏指針。
  4. 變量 e 是所有職員信息，把變量名改成 employees。
  5. 變量 i 是迭代過程的下標，把變量名改成 index。
  6. 將 index 變量定義放到 for 語句中。
  7. 將 File 變量定義從頂部挪到各自使用之前的位置。
  8. 對文件指針做異常檢查，當文件無法打開時輸出錯誤信息並提前終止程序。
  9. 程序退出時用 < 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，這其中還耦合了兩個功能：

  1. Employee 序列化成字符串。
  2. 序列化結果輸出到指定文件流。

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

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, {
  ...
});

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

  1. 代碼是一種數據類型。
  2. 代碼類型的數據可作為函數的參數。

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

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

  1. 可以用變量命名。
  2. 可以提供給過程作為參數。
  3. 可以由過程作為結果返回。
  4. 可以包含在數據結構中。

對照之下會驚訝地發現，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 檢查修改點是否有超出預期。

七 總結

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

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

本文只是拋磚引玉，並不是標準答案，所以並不是要求後續所有的代碼都要抽象多少次才能提交。因此，首次交付出去的代碼，到底要到達第幾版本，這個問題留給大家自己思考。

在說再見之前，再分享兩個關於識別重複、抽象重用的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阿里雲峰會暨開發者大會

image.png

大數據+AI將會產生怎樣的火花？雲上的大數據開發該怎麼玩？開發者如何加入大數據開源社區？5月29日，阿里雲開發者大會特邀阿里巴巴集團副總裁、阿里雲智能計算平臺事業部高級研究員賈揚清和你分享《雲上大數據與AI開發範式的演進》。點擊這裡，立即參與吧！

Leave a Reply

Your email address will not be published. Required fields are marked *