【利用AI讓知識體系化】入門Express架構

思維導圖

第一章：介紹Express

什麼是Express

Express是一個流行的基于Node.js的Web應用程式架構，它提供了一個簡單而靈活的方式來建構Web應用程式和API。Express具有輕量級、子產品化和可擴充的特點，是以被廣泛用于快速、高效地開發Web應用程式。

Express架構提供了許多常用的Web開發功能，如路由、中間件、模闆引擎、請求處理、錯誤處理等，可以讓開發人員更加專注于業務邏輯的實作。同時，Express架構也很容易與其他Node.js子產品進行內建，充分利用Node.js生态圈的各種資源。

Express優點

Express作為一種流行的Web應用程式架構，具有以下優點：

1. 輕量級：Express的設計理念是輕量級、簡單、靈活，是以它不會在項目中增加太多代碼。
2. 清晰的路由處理：Express提供了清晰的路由處理，開發者可以輕松建立路由處理程式，以及多個中間件來處理請求。
3. 中間件：中間件是Express的一個重要特點，它允許您在請求和響應之間添加處理邏輯，以實作許多功能，如身份驗證、請求日志記錄等等。
4. 可擴充：Express具有強大的插件系統，可以輕松地添加其他元件，如模闆引擎、資料庫驅動器等。
5. 較少的學習曲線：由于Express設計簡單，它對新手也很友好，您不需要很長時間來學習Express程式設計。

這些優點使得Express成為一個流行的選擇，特别是對于需要快速建構Web應用程式和API的開發人員來說。

Express應用場景

Express适用于許多Web應用程式開發和API建構場景，特别是那些希望快速建立起可靠、安全且高效的Web應用程式的場景。

以下是Express的一些應用場景：

1. 快速建構API： Express是開發RESTful API的理想選擇，它提供了清晰的路由和映射關系，允許開發人員通過中間件輕松地添加身份驗證、日志記錄等功能。
2. 前端應用程式：Express可以與React、Angular等前端架構很好地內建，幫助前端開發人員建構完整的Web應用程式。
3. 單頁應用程式： Express的路由特性非常适合建構單頁應用程式，這些應用程式将路由轉換成Ajax請求，并根據Ajax響應更新頁面。
4. 靜态網站： Express提供了靜态檔案托管功能，可以将靜态網站部署到雲上，極大地簡化了網站部署的過程。
5. 實時應用程式： Express也适用于實時應用程式，例如遊戲、聊天應用程式等，因為它提供了WebSocket支援。

綜上所述，Express适用于許多Web應用程式和API場景，是一個快速、高效和可擴充的架構。

第二章：安裝和基礎用法

安裝Express

安裝Express可以通過 npm 指令行工具來完成，具體步驟如下：

1. 安裝 Node.js：請前往官方網站下載下傳并安裝最新版本的 Node.js。
2. 初始化應用程式：在應用程式目錄下打開指令行終端，建立 package.json 檔案，這個檔案用于管理應用依賴的包。在終端中輸入以下指令：

npm init
           

按照提示輸入你的應用程式的名稱、版本、描述等資訊，完成初始化。

1. 安裝 Express：在終端中運作以下指令安裝 Express 庫：

npm install express --save
           

–save 參數将 Express 添加到 package.json 檔案中的依賴清單，友善其他開發人員或伺服器部署程式的自動安裝。

1. 建立并運作應用程式：在應用程式目錄下建立一個名為 app.js 或 index.js 的 JavaScript 檔案，并在其中添加以下示例代碼：

const express = require('express')
const app = express()

app.get('/', (req, res) => {
  res.send('Hello World!')
})

app.listen(3000, () => {
  console.log('Example app listening on port 3000!')
})
           

這段代碼建立了一個 Express 應用程式，并在根路由上監聽 HTTP GET 請求。當請求到達時，它會傳回 “Hello World!” 字元串。

1. 在終端中執行以下指令啟動應用程式：

node app.js
           

或者

node index.js
           

如果一切正常，你将在終端中看到 “Example app listening on port 3000!” 的輸出，然後可以在浏覽器中通路 “http://localhost:3000” 來檢視應用程式的響應。

以上是在 Windows 作業系統下的示例指令，Mac OS 和 Linux 使用者執行類似的指令，具體指令可能因作業系統和 Node.js 版本不同而有所差異。

搭建第一個Express應用

以下是搭建一個基本的Express應用的步驟：

1. 首先我們需要在電腦上安裝Node.js，可以在https://nodejs.org/en/官網下載下傳最新版本的Node.js。
2. 打開指令行工具，建立一個新的檔案夾，我們假設檔案夾名為myapp
3. 在指令行工具中進入myapp檔案夾，然後輸入以下指令進行初始化：

npm init
           

1. 接下來我們需要安裝Express架構，輸入以下指令：

npm i express
           

1. 建立一個名為index.js的檔案，輸入以下代碼:

const express = require('express')
const app = express()

app.get('/', (req, res) => {
  res.send('Hello World!')
})

app.listen(3000, () => {
  console.log('Example app listening on port 3000!')
})
           

1. 最後，在指令行工具中輸入以下指令運作應用程式：

node index.js
           

1. 打開浏覽器，通路http://localhost:3000/，你應該看到 “Hello World!” 的輸出。

恭喜，你已經成功搭建了你的第一個Express應用！

中間件的使用

中間件是Express架構中的一個非常重要的概念，它允許處理HTTP請求和響應之前進行一系列的操作，例如：身份驗證、記錄日志等等。

下面我将介紹一下中間件的使用：

1. 建立一個中間件函數，它接收三個參數：請求對象req，響應對象res和next函數。next函數用于訓示Express應用程式将處理下一個中間件或路由。
2. const myMiddleware = (req, res, next) => { console.log('This is my middleware!'); next(); }
3. 在應用程式中使用中間件函數，可以通過以下方法使用：
4. app.use(myMiddleware);

這将在所有路由之前運作myMiddleware函數。

1. 你也可以在特定路由中使用中間件函數。例如，以下代碼在處理初始請求之前運作myMiddleware函數：app.get('/', myMiddleware, (req, res) => { res.send('Hello World!'); });
2. Express中内置了許多中間件，例如：body-parser、morgan、cors等，你可以通過npm安裝并使用。

以上就是中間件的使用步驟，希望可以幫助你更好地了解和使用Express架構。

第三章：路由和控制器

路由的原理

路由是指将一個URL請求映射到相應的處理程式或控制器上，是一個Web架構中非常重要的概念。在Express架構中，路由允許我們定義應用程式的端點(URIs)和如何響應用戶端請求。

下面是路由的實作原理：

1. Express應用程式中定義的每一個路由都有一個HTTP方法（GET、POST、PUT、DELETE）和一個URL路徑。
2. 當用戶端浏覽器發起HTTP請求時，Express伺服器會根據該HTTP請求的方法和路徑尋找比對的路由。
3. 如果找到了比對的路由，伺服器将執行相應的處理程式或控制器，并傳回用戶端響應。
4. 如果伺服器無法找到比對的路由，則向用戶端發送404響應。

例如，以下代碼中，我們定義了一個路由路徑為’/hello’，并指定使用GET方法來響應該路由：

app.get('/hello', function(req, res) {
    res.send('Hello World!');
});
           

當浏覽器請求’/hello’路徑時，Express将尋找比對的路由，并執行上述代碼中指定的處理程式，最後傳回一個包含"Hello World"字元串的響應給用戶端浏覽器。

基于上述原理，我們可以在Express應用程式中定義任何數量的路由以及HTTP請求方法來處理用戶端請求。同時，路由的使用還可以幫助我們更好地組織應用程式的代碼結構和清晰地定義應用程式的功能。

路由的基本用法

在Express應用程式中，使用路由來定義應用程式的端點和如何響應用戶端請求。

下面是路由的基本用法：

1. 定義路由

在Express應用程式中，使用HTTP方法（GET、POST、PUT、DELETE等）和URL路徑來定義路由，如下示例定義了一個GET方法的路由：

app.get('/', function(req, res) {
    res.send('Hello World!');
});
           

在上面的例子中，我們定義了一個路由"/"，使用GET方法并指定一個回調函數。回調函數中接收兩個參數，req和res分别代表請求對象和響應對象，這裡我們将"Hello World!"字元串發送給用戶端作為響應。

2. 路由參數

路由參數可用于在路由路徑中類似動态映射的方式來接收參數值。例如，以下路由定義了一個帶參數的路由：

app.get('/users/:id', function(req, res) {
    res.send('User id is: ' + req.params.id);
});
           

在上面的例子中，我們定義了一個"/users/:id"的路由，其中":id"是一個參數占位符，可以在路由路徑中通過req.params.id參數擷取到值。例如，當用戶端請求"/users/123"時，我們的代碼會響應"User id is: 123"字元串。

3. 路由處理函數

路由處理函數可以是一個函數，也可以是多個函數組成的數組。當我們定義多個路由處理函數時，它們會依次執行。例如，以下代碼定義了一個處理函數數組并使用它作為路由處理函數：

let firstHandler = function(req, res, next) {
    console.log('This is the first handler');
    next();
};

let secondHandler = function(req, res) {
    res.send('Hello World!');
};

app.get('/', [firstHandler, secondHandler]);
           

在上面的例子中，我們定義了兩個處理函數，第一個處理函數會列印一個日志并執行next()向下一個處理函數進行傳遞，第二個處理函數則将"Hello World!"字元串發送給用戶端。

在Express應用程式中，路由是一種非常靈活和強大的機制，它可以幫助我們更好地組織應用程式的代碼結構和定義應用程式的功能。

路由的進階用法

在Express應用程式中，路由有許多進階用法。

下面是一些常見的進階用法：

1. 鍊式路由

鍊式路由允許我們在一個路由上定義多個處理函數，這些處理函數都會按照順序執行。

例如，以下代碼示範如何使用鍊式路由：

app.route('/users')
   .get(function(req, res) {
       res.send('Get a user');
   })
   .post(function(req, res) {
       res.send('Create a user');
   })
   .put(function(req, res) {
       res.send('Update a user');
   })
   .delete(function(req, res) {
       res.send('Delete a user');
   });
           

在上面的例子中，我們使用route()方法定義一個路由"/users"，并對其使用鍊式路由。在鍊式路由中，我們使用get()、post()、put()和delete()方法來定義不同的HTTP方法的處理函數。

2. 路由子產品化

當我們的應用程式變得比較大時，所有的路由定義可能會變得混亂和不易維護。是以，我們可以使用路由子產品化來改善這種情況。

首先，在routes目錄下建立一個專門用于存放路由的檔案，例如users.js。接着，我們在users.js檔案中定義路由，如下所示：

const express = require('express');
const router = express.Router();

router.get('/', function(req, res) {
    res.send('Get all users');
});

router.post('/', function(req, res) {
    res.send('Create a user');
});

module.exports = router;
           

在上面的例子中，我們定義了兩個路由，一個是GET方法的路由"/“，另一個是POST方法的路由”/"，最後使用module.exports導出路由子產品。

接着，在應用程式中，我們可以使用app.use()來向Express應用程式注冊該路由子產品，如下所示：

const usersRouter = require('./routes/users');
app.use('/users', usersRouter);
           

在上面的例子中，我們首先使用require()函數導入路由子產品，然後在應用程式中使用app.use()方法來注冊路由子產品。注意，在注冊路由子產品時，第一個參數"/users"代表的是路由子產品的根路徑。

這樣，我們就成功地将路由定義子產品化，并将其注冊到應用程式中。

3. 異步路由

在Express應用程式中，我們還可以使用異步函數來實作異步路由。例如，下面的示例示範如何使用async/await來實作異步路由：

app.get('/async', async function(req, res) {
    const result = await someAsyncFunction();
    res.send('Async result: ' + result);
});
           

在上面的例子中，我們使用async來修飾路由處理函數，然後使用await關鍵字調用異步函數。當異步函數執行完畢後，我們将其傳回值與字元串拼接後發送給用戶端。

總的來說，路由在Express應用程式中是非常靈活和強大的，可以幫助我們定義應用程式的功能，提高代碼的可讀性和可維護性。

控制器的使用

在 Express 架構中，控制器通常指的是處理特定請求的函數，它們通常被稱為路由處理程式 (route handlers)。控制器是為了提高應用程式的可維護性和可讀性，将具體的業務邏輯和路由操作分離開來，進而使得每個路由處理程式隻需要關注其自身的業務邏輯，而不用承擔額外的業務職責。通常，使用控制器可以使得代碼更具有可重用性，以及更容易進行調試和測試。

下面是在 Express 中建立一個控制器的一般步驟：

1. 建立路由。在你的 Express 應用程式中建立一個路由，用于處理 HTTP 請求。

const express = require('express');
const router = express.Router();
           

2. 編寫控制器函數。編寫具體的業務邏輯，并将其封裝在一個函數中。

const myController = (req, res) => {
  // 處理業務邏輯
  res.send('Hello World!');
}
           

3. 将控制器函數綁定到路由。将你編寫的控制器函數挂載到剛剛建立的路由中。

router.get('/myRoute', myController);
           

4. 在應用程式中使用該路由。将你建立的路由挂載到你的 Express 應用程式中。

const app = express();
app.use('/api', router);
           

這樣，當你的應用程式接收到 GET /api/myRoute 的請求時，會自動調用 myController 函數來處理這個請求，并傳回 'Hello World!' 給用戶端。

請注意，這隻是一個簡單的示例。在實際使用中，你可能需要更多的控制器函數，并在應用程式中使用多個路由。此外，你可以在控制器函數中使用模型和資料庫等資料操作，以執行更複雜的操作。

第四章：模闆引擎

EJS模闆引擎

EJS 是一種基于 JavaScript 的模闆引擎，它允許你使用 JavaScript 代碼在 HTML 中嵌入動态内容。

下面是在 Express 中使用 EJS 模闆引擎的一般步驟：

1. 安裝 EJS。從 npm 上安裝 EJS 模闆引擎。

npm install ejs
           

2. 配置 Express 應用程式。在你的 Express 應用程式中設定 EJS 作為視圖引擎。

const express = require('express');
const app = express();

// 設定 EJS 視圖引擎
app.set('view engine', 'ejs');
           

3. 建立一個 EJS 視圖。在你的應用程式中建立一個 EJS 視圖，用 EJS 文法編寫你的 HTML 模闆。

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title><%= pageTitle %> - My App</title>
</head>
<body>
  <h1>Welcome to <%= appName %>!</h1>
</body>
</html>
           

4. 在路由控制器中使用 EJS 模闆。在路由控制器中調用 res.render() 函數來使用 EJS 視圖，并将需要動态替換的資料傳遞給視圖。

app.get('/', (req, res) => {
  res.render('index', { pageTitle: 'Home', appName: 'My App' });
});
           

在這個例子中，EJS 變量 <%= pageTitle %> 和 <%= appName %> 将會被動态替換為 'Home' 和 'My App'。最終用戶端将會看到一條歡迎語句和一個頁面标題。

這隻是一個簡單的例子。使用 EJS 模闆引擎，你可以輕松地建立更複雜的視圖和互動元素，例如表格、表單、按鈕等等。

Pug模闆引擎

Pug（以前稱為Jade）是一種基于縮進的模闆引擎，它使用一種簡潔的、類似于 Python 的文法來描述 HTML 的結構和内容。

下面是在 Express 中使用 Pug 模闆引擎的一般步驟：

1. 安裝 Pug。從 npm 上安裝 Pug 模闆引擎。

npm install pug
           

2. 配置 Express 應用程式。在你的 Express 應用程式中設定 Pug 作為視圖引擎。

const express = require('express');
const app = express();

// 設定 Pug 視圖引擎
app.set('view engine', 'pug');
           

3. 建立一個 Pug 視圖。在你的應用程式中建立一個 Pug 視圖，用 Pug 文法編寫你的 HTML 模闆。

<!DOCTYPE html>
html
  head
    meta(charset='UTF-8')
    title=pageTitle + ' - My App'
  body
    h1 Welcome to #{appName}!
           

4. 在路由控制器中使用 Pug 模闆。在路由控制器中調用 res.render() 函數來使用 Pug 視圖，并将需要動态替換的資料傳遞給視圖。

app.get('/', (req, res) => {
  res.render('index', { pageTitle: 'Home', appName: 'My App' });
});
           

在這個例子中，Pug 變量 #{appName} 将會被動态替換為 'My App'。最終用戶端将會看到一條歡迎語句和一個頁面标題。

使用 Pug 模闆引擎，你可以輕松地建立更複雜的視圖和互動元素，例如表格、表單、按鈕等等。

Mustache模闆引擎

Mustache 是一種簡單、輕量的模闆引擎，可以應用于多種程式設計語言中。

它提供了一個非常簡單的模闆語言，用于将資料渲染為 HTML、XML 或純文字。

在 Express 中使用 Mustache 模闆引擎的一般步驟為：

1. 安裝 Mustache。從 npm 上安裝 Mustache 模闆引擎。

npm install mustache
           

2. 配置 Express 應用程式。在你的 Express 應用程式中設定 Mustache 作為視圖引擎。

const express = require('express');
const app = express();

// 設定 Mustache 視圖引擎
app.engine('mustache', require('mustache-express')());
app.set('view engine', 'mustache');
app.set('views', __dirname + '/views');
           

3. 建立一個 Mustache 視圖。在你的應用程式中建立一個 Mustache 視圖，用 Mustache 文法編寫你的 HTML 模闆。

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>{{pageTitle}} - My App</title>
</head>
<body>
  <h1>Welcome to {{appName}}!</h1>
</body>
</html>
           

4. 在路由控制器中使用 Mustache 模闆。在路由控制器中調用 res.render() 函數來使用 Mustache 視圖，并将需要動态替換的資料傳遞給視圖。

app.get('/', (req, res) => {
  res.render('index', { pageTitle: 'Home', appName: 'My App' });
});
           

在這個例子中，Mustache 變量 {{appName}} 将會被動态替換為 'My App'。最終用戶端将會看到一條歡迎語句和一個頁面标題。

使用 Mustache 模闆引擎，你可以輕松地建立更複雜的視圖和互動元素，例如表格、表單、按鈕等等。

第五章：檔案上傳和下載下傳

檔案上傳的原理和實作

檔案上傳通常涉及到兩個部分：用戶端和服務端。

在Web應用中，我們通常使用HTTP協定進行檔案傳輸。

用戶端：使用者在頁面上選擇要上傳的檔案後，浏覽器會将該檔案通過HTTP協定傳輸到服務端。通常情況下，我們會使用HTML表單來生成上傳控件，然後通過JavaScript監聽表單送出事件，在送出前擷取檔案資料并使用FormData對象建立一個上傳請求，再通過XMLHttpRequest或fetch API将請求發送到服務端。

服務端：伺服器接收到檔案上傳的請求後，通常會使用伺服器端程式設計語言（如Node.js中的express架構）來處理請求，并将檔案儲存到伺服器的指定目錄中。在express架構中，可以使用multer中間件來處理檔案上傳的請求。multer支援多種上傳方式，如多檔案上傳、限制檔案大小等，并且提供了一些有用的API，如req.file和req.files，用于擷取上傳的檔案資料。

下面是一個使用express和multer實作檔案上傳的示例代碼：

// 引入multer庫
const multer = require('multer');

// 建立multer執行個體，指定上傳目錄和上傳方式
const upload = multer({ dest: 'uploads/' });

// 處理POST請求
app.post('/upload', upload.single('file'), (req, res) => {
  // req.file是上傳的檔案對象
  console.log(req.file);

  res.status(200).send('上傳成功');
});
           

在上面的代碼中，我們首先引入了multer庫，然後使用multer.create()方法建立一個multer執行個體，傳入一個對象作為參數，其中dest屬性指定了上傳檔案的儲存目錄。

然後，在處理POST請求的回調函數中，使用upload.single()方法指定了檔案的上傳方式，這裡使用的是單檔案上傳。最後，我們通過req.file擷取上傳的檔案對象，将其儲存到指定的目錄中，并傳回上傳成功的消息。

檔案下載下傳的實作

在Node.js的express架構中，要實作檔案下載下傳功能，可以通過res.sendFile()方法來實作。該方法會将指定的檔案發送到用戶端，觸發檔案下載下傳的過程。

首先，確定伺服器端已經有需要下載下傳的檔案，然後使用express的get()方法定義一個路由，指定檔案下載下傳的URL和下載下傳檔案的名稱。當用戶端請求下載下傳該檔案時，服務端會将檔案發送給用戶端，觸發檔案下載下傳。

下面是一個使用express架構實作檔案下載下傳的示例代碼：

// 引入express架構和fs檔案系統子產品
const express = require('express');
const fs = require('fs');

// 建立express執行個體
const app = express();

// 定義檔案下載下傳的路由
app.get('/download', (req, res) => {
  // 設定檔案下載下傳的名稱
  res.attachment('test.pdf');
  // 讀取檔案，并将其發送到用戶端下載下傳
  const filePath = './files/test.pdf';
  const readStream = fs.createReadStream(filePath);
  readStream.pipe(res);
});

// 啟動伺服器
const port = 3000;
app.listen(port, () => {
  console.log(`Server started on port ${port}`);
});
           

在上面的代碼中，我們首先引入了express架構和fs檔案系統子產品，然後建立一個express執行個體。在定義檔案下載下傳的路由時，我們使用res.attachment()方法指定了檔案下載下傳的名稱，然後使用fs.createReadStream()方法建立一個可讀流，讀取要下載下傳的檔案，并使用.pipe()方法将檔案流發送到用戶端res中，進而觸發檔案下載下傳的過程。

最後，我們通過app.listen()方法啟動伺服器，監聽指定的端口。當用戶端請求下載下傳該檔案時，服務端會将檔案發送給用戶端，用戶端收到檔案後會彈出檔案下載下傳對話框，讓使用者選擇儲存檔案的位置和檔案名。

第六章：錯誤處理和調試

錯誤進行中間件的使用

在Node.js的express架構中，錯誤進行中間件主要用于捕獲應用程式中出現的錯誤和異常，并做出相應的處理。例如，将錯誤資訊傳回給用戶端，或者記錄錯誤日志。

在express中，錯誤進行中間件有兩個參數：err和req/res/next。其中err表示捕獲到的錯誤資訊，req/res/next用于傳遞請求和響應對象以及下一個中間件函數。

要使用錯誤進行中間件，可以通過app.use()方法，将錯誤進行中間件作為最後一個中間件，放在所有路由定義的最後面。這樣，當請求無法比對任何路由時，将會被錯誤進行中間件捕獲，并傳回一個錯誤響應。

下面是一個示例代碼，示範如何定義和使用錯誤進行中間件：

const express = require('express');
const app = express();

// 定義路由
app.get('/', (req, res) => {
  // 抛出一個錯誤，并将其傳遞給下一個中間件
  const err = new Error('Something went wrong');
  err.status = 500;
  next(err);
});

// 定義錯誤進行中間件
app.use((err, req, res, next) => {
  // 處理錯誤資訊，并将錯誤響應發送給用戶端
  res.status(err.status || 500);
  res.send({
    error: {
      message: err.message
    }
  });
});

// 啟動伺服器
app.listen(3000, () => {
  console.log('Server started on port 3000');
});
           

在上面的代碼中，我們首先定義了一個路由，其中抛出了一個錯誤，并将其傳遞給下一個中間件。然後，通過app.use()方法定義了一個錯誤進行中間件，該中間件将捕獲到了抛出的錯誤，将其相關資訊傳回到用戶端響應中。

總之，使用錯誤進行中間件可以在應用程式出現錯誤或異常時，準确地響應錯誤資訊，進而改善應用程式的使用者體驗。

調試和日志

在Node.js的express架構中，調試很重要，可以幫助我們快速發現代碼中的問題。同時，記錄日志可以幫助我們了解應用程式的執行情況，檢視資料和錯誤資訊。

調試

在express中，調試通常使用debug子產品實作。使用debug子產品，可以輕松地控制輸出調試資訊。隻需要在需要調試的子產品中引入debug子產品即可，例如：

const debug = require('debug')('app');

debug('Starting server...');
           

在這個例子中，我們引入了debug子產品，并将錯誤資訊标記為“app”。這樣做的好處是，可以在應用程式啟動時，通過設定DEBUG環境變量控制調試的輸出：

DEBUG=app node server.js
           

在上面的指令中，我們通過設定DEBUG環境變量來啟用具有指定字首的調試資訊輸出。

日志

記錄日志有助于我們了解應用程式的運作狀況，以及查找和解決應用程式中的問題。在express中，通常使用winston或morgan等子產品來記錄日志。

下面是使用winston子產品記錄日志的一個例子：

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  defaultMeta: { service: 'user-service' },
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' }),
  ],
});

if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple(),
  }));
}

module.exports = logger;
           

在這個例子中，我們使用了winston子產品建立了一個記錄日志的執行個體logger，在logger中定義了日志的級别、格式和記錄位置等，并且通過if語句判斷目前是否為生産環境，如果不是，則添加控制台輸出的記錄方法。

在需要記錄日志的地方，我們隻需要引入logger執行個體即可，例如：

const logger = require('./logger');

logger.info('Hello, world!');
           

在這個例子中，我們在hello.js檔案中引入了logger執行個體，并使用logger.info()方法記錄日志。logger中的一些常見方法包括info、warn、error等，可以根據具體需求進行選擇。

總之，調試和日志都是在express中很重要的一部分，能夠幫助開發者快速定位和修複問題，提高應用程式的健壯性和可維護性。

第七章：測試

單元測試和內建測試

在Node.js的express架構中，單元測試和內建測試都是非常重要的，可以幫助我們測試應用程式的不同方面，確定應用程式在各種場景下都能夠正确運作。下面我們分别介紹單元測試和內建測試：

單元測試

單元測試是指對應用程式中的單個子產品、函數或方法進行測試。我們通常使用Mocha、Chai、Sinon等架構和工具來編寫和運作單元測試。

下面是一個使用Mocha和Chai架構進行單元測試的示例代碼：

const { expect } = require('chai');
const myModule = require('../my-module');

describe('myModule', () => {
  it('should return 4 when add(2, 2)', () => {
    const result = myModule.add(2, 2);
    expect(result).to.equal(4);
  });

  it('should throw an error when divide(4, 0)', () => {
    expect(() => myModule.divide(4, 0)).to.throw('Cannot divide by zero');
  });
});
           

在上面的代碼中，我們引入了chai庫，并使用describe()方法定義了一個測試套件。在測試套件中，我們使用it()方法定義了兩個測試用例，分别測試了add()和divide()方法，在測試用例中使用chai斷言庫驗證代碼的正确性。

當運作測試代碼時，Mocha将自動執行該測試套件中的所有測試用例，并輸出測試結果。

內建測試

內建測試是指測試應用程式的多個子產品之間的互動，以及應用程式與外部系統之間的互動。我們通常使用Supertest、Nock等架構和工具來編寫和運作內建測試。

下面是一個使用Supertest架構進行內建測試的示例代碼：

const request = require('supertest');
const app = require('../app');

describe('POST /users', () => {
  it('should return 201 created', (done) => {
    request(app)
      .post('/users')
      .send({ name: 'John' })
      .set('Accept', 'application/json')
      .expect('Content-Type', /json/)
      .expect(201, done);
  });
});
           

在這個例子中，我們使用Supertest庫編寫了一個內建測試用例，測試了POST /users路由的響應。我們使用request()方法建立了一個HTTP請求，并使用鍊式調用的方式設定請求參數、頭部和期望的響應結果等。

當運作測試代碼時，Supertest将發送HTTP請求到應用程式，并驗證請求和響應是否與期望的一緻。

總之，單元測試和內建測試都是在express中非常重要的一部分，在開發過程中可以幫助我們發現和修複問題，提高應用程式的健壯性和可維護性。

測試架構和工具介紹

在 Express 架構中，有許多測試架構和工具可供選擇。下面是一些常用的測試架構和工具：

1. Mocha：Mocha 是一個功能強大的 JavaScript 測試架構，它支援異步測試、嵌套測試、報告和定時器等功能。
2. Chai：Chai 是一個 BDD/TDD 斷言庫，它為 JavaScript 測試提供了一緻的語言和 API。
3. supertest：supertest 是一個 HTTP 請求庫，它允許你模拟 HTTP 請求和響應，用于測試 Express 應用程式。
4. istanbul：istanbul 是一個 JavaScript 代碼覆寫率工具，它可幫助你了解你的測試樣本在代碼庫中的分布情況。
5. sinon：sinon 是一個 JavaScript 的測試工具庫，它提供了各種功能來模拟和替換功能以及測試邊緣情況。

這些測試架構和工具提供了豐富的功能和靈活的 API，可以讓你輕松地編寫測試用例并測試你的 Express 應用程式。