下內容，基于 Express 4.x 版本

Node.js 的 Express

Express 估計是那種你第一次接觸，就會喜歡上用它的框架。因為它真的非常簡單，直接。

在當前版本上，一共才這么幾個文件：

lib/
├── application.js
├── express.js
├── middleware
│ ├── init.js
│ └── query.js
├── request.js
├── response.js
├── router
│ ├── index.js
│ ├── layer.js
│ └── route.js
├── utils.js
└── view.js

這種程度，說它是一個“框架”可能都有些過了，幾乎都是工具性質的實現，只限于 Web 層。

當然，直接了當地實現了 Web 層的基本功能，是得益于 Node.js 本身的 API 中，就提供了 net 和 http 這兩層， Express 對 http 的方法包裝一下即可。

不過，本身功能簡單的東西，在 package.json 中卻有好長一串 dependencies 列表。

Hello World

在跑 Express 前，你可能需要初始化一個 npm 項目，然后再使用 npm 安裝 Express：

mkdir p
cd p
npm init
npm install express --save

新建一個 app.js ：

const express = require('express');
const app = express();
app.all('/', (req, res) => res.send('hello') );
app.listen(8888);

調試信息是通過環境變量 DEBUG 控制的：

const process = require('process');
process.env['DEBUG'] = 'express:*';

這樣就可以在終端看到帶顏色的輸出了，嗯，是的，帶顏色控制字符，vim 中直接跑就 SB 了。

應用 Application

Application 是一個上層統籌的概念，整合“請求-響應”流程。 express() 的調用會返回一個 application ，一個項目中，有多個 app 是沒問題的：

const express = require('express');
const app = express();
app.all('/', (req, res) => res.send('hello'));
app.listen(8888);
const app2 = express();
app2.all('/', (req, res) => res.send('hello2'));
app2.listen(8889);

多個 app 的另一個用法，是直接把某個 path 映射到整個 app ：

const express = require('express');
const app = express();
app.all('/', (req, res) => {
 res.send('ok');
});
const app2 = express();
app2.get('/xx', (req, res, next) => res.send('in app2') )
app.use('/2', app2)
app.listen(8888);

這樣，當訪問 /2/xx 時，就會看到 in app2 的響應。

前面說了 app 實際上是一個上層調度的角色，在看后面的內容之前，先說一下 Express 的特點，整體上來說，它的結構基本上是“回調函數串行”，無論是 app ，或者 route， handle， middleware這些不同的概念，它們的形式，基本是一致的，就是 (res, req, next) => {} ，串行的流程依賴 next() 的顯式調用。

我們把 app 的功能，分成五個部分來說。

路由 - Handler 映射

app.all('/', (req, res, next) => {});
app.get('/', (req, res, next) => {});
app.post('/', (req, res, next) => {});
app.put('/', (req, res, next) => {});
app.delete('/', (req, res, next) => {});

上面的代碼就是基本的幾個方法，路由的匹配是串行的，可以通過 next() 控制：

const express = require('express');
const app = express();
app.all('/', (req, res, next) => {
 res.send('1 ');
 console.log('here');
 next();
});
app.get('/', (req, res, next) => {
 res.send('2 ');
 console.log('get');
 next();
});
app.listen(8888);

對于上面的代碼，因為重復調用 send() 會報錯。

同樣的功能，也可以使用 app.route() 來實現：

const express = require('express');
const app = express();
app.route('/').all( (req, res, next) => {
 console.log('all');
 next();
}).get( (req, res, next) => {
 res.send('get');
 next();
}).all( (req, res, next) => {
 console.log('tail');
 next();
});
app.listen(8888);

app.route() 也是一種抽象通用邏輯的形式。

還有一個方法是 app.params ，它把“命名參數”的處理單獨拆出來了（我個人不理解這玩意兒有什么用）：

const express = require('express');
const app = express();
app.route('/:id').all( (req, res, next) => {
 console.log('all');
 next();
}).get( (req, res, next) => {
 res.send('get');
 next()
}).all( (req, res, next) => {
 console.log('tail');
});
app.route('/').all( (req, res) => {res.send('ok')});
app.param('id', (req, res, next, value) => {
 console.log('param', value);
 next();
});
app.listen(8888);

app.params 中的對應函數會先行執行，并且，記得顯式調用 next() 。

Middleware

其實前面講了一些方法，要實現 Middleware 功能，只需要 app.all(/.*/, () => {}) 就可以了， Express 還專門提供了 app.use() 做通用邏輯的定義：

const express = require('express');
const app = express();
app.all(/.*/, (req, res, next) => {
 console.log('reg');
 next();
});
app.all('/', (req, res, next) => {
 console.log('pre');
 next();
});
app.use((req, res, next) => {
 console.log('use');
 next();
});
app.all('/', (req, res, next) => {
 console.log('all');
 res.send('/ here');
 next();
});
app.use((req, res, next) => {
 console.log('use2');
 next();
});
app.listen(8888);

注意 next() 的顯式調用，同時，注意定義的順序， use() 和 all() 順序上是平等的。

Middleware 本身也是 (req, res, next) => {} 這種形式，自然也可以和 app 有對等的機制——接受路由過濾， Express 提供了 Router ，可以單獨定義一組邏輯，然后這組邏輯可以跟 Middleware一樣使用。

const express = require('express');
const app = express();
const router = express.Router();
app.all('/', (req, res) => {
 res.send({a: '123'});
});
router.all('/a', (req, res) => {
 res.send('hello');
});
app.use('/route', router);
app.listen(8888);

功能開關，變量容器

app.set() 和 app.get() 可以用來保存 app 級別的變量（對， app.get() 還和 GET 方法的實現名字上還沖突了）：

const express = require('express');
const app = express();
app.all('/', (req, res) => {
 app.set('title', '標題123');
 res.send('ok');
});
app.all('/t', (req, res) => {
 res.send(app.get('title'));
});
app.listen(8888);

上面的代碼，啟動之后直接訪問 /t 是沒有內容的，先訪問 / 再訪問 /t 才可以看到內容。

對于變量名， Express 預置了一些，這些變量的值，可以叫 settings ，它們同時也影響整個應用的行為：

• case sensitive routing
• env
• etag
• jsonp callback name
• json escape
• json replacer
• json spaces
• query parser
• strict routing
• subdomain offset
• trust proxy
• views
• view cache
• view engine
• x-powered-by

具體的作用，可以參考 https://expressjs.com/en/4x/api.html#app.set 。

（上面這些值中，干嘛不放一個最基本的 debug 呢……）

除了基本的 set() / get() ，還有一組 enable() / disable() / enabled() / disabled() 的包裝方法，其實就是 set(name, false) 這種。 set(name) 這種只傳一個參數，也可以獲取到值，等于 get(name) 。

模板引擎

Express 沒有自帶模板，所以模板引擎這塊就被設計成一個基礎的配置機制了。

const process = require('process');
const express = require('express');
const app = express();
app.set('views', process.cwd() + '/template');
app.engine('t2t', (path, options, callback) => {
 console.log(path, options);
 callback(false, '123');
});
app.all('/', (req, res) => {
 res.render('demo.t2t', {title: "標題"}, (err, html) => {
 res.send(html)
 });
});
app.listen(8888);

app.set('views', ...) 是配置模板在文件系統上的路徑， app.engine() 是擴展名為標識，注冊對應的處理函數，然后， res.render() 就可以渲染指定的模板了。 res.render('demo') 這樣不寫擴展名也可以，通過 app.set('view engine', 't2t') 可以配置默認的擴展名。

這里，注意一下 callback() 的形式，是 callback(err, html) 。

端口監聽

app 功能的最后一部分， app.listen() ，它完成的形式是：

app.listen([port[, host[, backlog]]][, callback])

注意， host 是第二個參數。

backlog 是一個數字，配置可等待的最大連接數。這個值同時受操作系統的配置影響。默認是 512 。

請求 Request

這一塊倒沒有太多可以說的，一個請求你想知道的信息，都被包裝到 req 的屬性中的。除了，頭。頭的信息，需要使用 req.get(name) 來獲取。

GET 參數

使用 req.query 可以獲取 GET 參數：

const express = require('express');
const app = express();
app.all('/', (req, res) => {
 console.log(req.query);
 res.send('ok');
});
app.listen(8888);

請求：

# -*- coding: utf-8 -*-
import requests
requests.get('http://localhost:8888', params={"a": '中文'.encode('utf8')})

POST 參數

POST 參數的獲取，使用 req.body ，但是，在此之前，需要專門掛一個 Middleware ， req.body才有值：

const express = require('express');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.all('/', (req, res) => {
 console.log(req.body);
 res.send('ok');
});
app.listen(8888);
# -*- coding: utf-8 -*-
import requests
requests.post('http://localhost:8888', data={"a": '中文'})

如果你是整塊扔的 json 的話：

# -*- coding: utf-8 -*-
import requests
import json
requests.post('http://localhost:8888', data=json.dumps({"a": '中文'}),
 headers={'Content-Type': 'application/json'})

Express 中也有對應的 express.json() 來處理：

const express = require('express');
const app = express();
app.use(express.json());
app.all('/', (req, res) => {
 console.log(req.body);
 res.send('ok');
});
app.listen(8888);

Express 中處理 body 部分的邏輯，是單獨放在 body-parser 這個 npm 模塊中的。 Express 也沒有提供方法，方便地獲取原始 raw 的內容。另外，對于 POST 提交的編碼數據， Express 只支持 UTF-8 編碼。

如果你要處理文件上傳，嗯， Express 沒有現成的 Middleware ，額外的實現在 https://github.com/expressjs/multer 。（ Node.js 天然沒有“字節”類型，所以在字節級別的處理上，就會感覺很不順啊）

Cookie

Cookie 的獲取，也跟 POST 參數一樣，需要外掛一個 cookie-parser 模塊才行：

const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser())
app.all('/', (req, res) => {
 console.log(req.cookies);
 res.send('ok');
});
app.listen(8888);

請求：

# -*- coding: utf-8 -*-
import requests
import json
requests.post('http://localhost:8888', data={'a': '中文'},
 headers={'Cookie': 'a=1'})

如果 Cookie 在響應時，是配置 res 做了簽名的，則在 req 中可以通過 req.signedCookies 處理簽名，并獲取結果。

來源 IP

Express 對 X-Forwarded-For 頭，做了特殊處理，你可以通過 req.ips 獲取這個頭的解析后的值，這個功能需要配置 trust proxy 這個 settings 來使用：

const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser())
app.set('trust proxy', true);
app.all('/', (req, res) => {
 console.log(req.ips);
 console.log(req.ip);
 res.send('ok');
});
app.listen(8888);

請求：

# -*- coding: utf-8 -*-
import requests
import json
#requests.get('http://localhost:8888', params={"a": '中文'.encode('utf8')})
requests.post('http://localhost:8888', data={'a': '中文'},
 headers={'X-Forwarded-For': 'a, b, c'})

如果 trust proxy 不是 true ，則 req.ip 會是一個 ipv4 或者 ipv6 的值。

響應 Response

Express 的響應，針對不同類型，本身就提供了幾種包裝了。

普通響應

使用 res.send 處理確定性的內容響應：

res.send({ some: 'json' });
res.send('<p>some html</p>');
res.status(404); res.end();
res.status(500); res.end();

res.send() 會自動 res.end() ，但是，如果只使用 res.status() 的話，記得加上 res.end() 。

模板渲染

模板需要預先配置，在 Request 那節已經介紹過了。

const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser())
app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {
 callback(false, '<h1>Hello</h1>');
});
app.all('/', (req, res) => {
 res.render('index', {}, (err, html) => {
 res.send(html);
 });
});
app.listen(8888);

這里有一個坑點，就是必須在對應的目錄下，有對應的文件存在，比如上面例子的 template/index.html ，那么 app.engine() 中的回調函數才會執行。都自定義回調函數了，這個限制沒有任何意義， path, options 傳入就好了，至于是不是要通過文件系統讀取內容，怎么讀取，又有什么關系呢。

Cookie

res.cookie 來處理 Cookie 頭：

const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser("key"))
app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {
 callback(false, '<h1>Hello</h1>');
});
app.all('/', (req, res) => {
 res.render('index', {}, (err, html) => {
 console.log('cookie', req.signedCookies.a);
 res.cookie('a', '123', {signed: true});
 res.cookie('b', '123', {signed: true});
 res.clearCookie('b');
 res.send(html);
 });
});
app.listen(8888);

請求：

# -*- coding: utf-8 -*-
import requests
import json
res = requests.post('http://localhost:8888', data={'a': '中文'},
 headers={'X-Forwarded-For': 'a, b, c',
 'Cookie': 'a=s%3A123.p%2Fdzmx3FtOkisSJsn8vcg0mN7jdTgsruCP1SoT63z%2BI'})
print(res, res.text, res.headers)

注意三點：

• app.use(cookieParser("key")) 這里必須要有一個字符串做 key ，才可以正確使用簽名的 cookie 。
• clearCookie() 仍然是用“設置過期”的方式來達到刪除目的，cookie() 和 clearCookie() 并不會整合，會寫兩組 b=xx 進頭。
• res.send() 會在連接上完成一個響應，所以，與頭相關的操作，都必須放在 res.send() 前面。

頭和其它

res.set() 可以設置指定的響應頭， res.rediect(301, 'http://www.zouyesheng.com') 處理重定向， res.status(404); res.end() 處理非 20 響應。

const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser("key"))
app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {
 callback(false, '<h1>Hello</h1>');
});
app.all('/', (req, res) => {
 res.render('index', {}, (err, html) => {
 res.set('X-ME', 'zys');
 //res.redirect('back');
 //res.redirect('http://www.zouyesheng.com');
 res.status(404);
 res.end();
 });
});
app.listen(8888);

res.redirect('back') 會自動獲取 referer 頭作為 Location 的值，使用這個時，注意 referer為空的情況，會造成循環重復重定向的后果。

Chunk 響應

Chunk 方式的響應，指連接建立之后，服務端的響應內容是不定長的，會加個頭： Transfer-Encoding: chunked ，這種狀態下，服務端可以不定時往連接中寫入內容（不排除服務端的實現會有緩沖區機制，不過我看 Express 沒有）。

const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser("key"))
app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {
 callback(false, '<h1>Hello</h1>');
});
app.all('/', (req, res) => {
 const f = () => {
 const t = new Date().getTime() + '\n';
 res.write(t);
 console.log(t);
 setTimeout(f, 1000);
 }
 setTimeout(f, 1000);
});
app.listen(8888);

上面的代碼，訪問之后，每過一秒，都會收到新的內容。

大概是 res 本身是 Node.js 中的 stream 類似對象，所以，它有一個 write() 方法。

要測試這個效果，比較方便的是直接 telet：

zys@zys-alibaba:/home/zys/temp >>> telnet localhost 8888
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
GET / HTTP/1.1
Host: localhost
HTTP/1.1 200 OK
X-Powered-By: Express
Date: Thu, 20 Jun 2019 08:11:40 GMT
Connection: keep-alive
Transfer-Encoding: chunked
e
1561018300451
e
1561018301454
e
1561018302456
e
1561018303457
e
1561018304458
e
1561018305460
e
1561018306460

每行前面的一個字節的 e ，為 16 進制的 14 這個數字，也就是后面緊跟著的內容的長度，是 Chunk 格式的要求。具體可以參考 HTTP 的 RFC ， https://tools.ietf.org/html/rfc2616#page-2 。

Tornado 中的類似實現是：

# -*- coding: utf-8 -*-
import tornado.ioloop
import tornado.web
import tornado.gen
import time
class MainHandler(tornado.web.RequestHandler):
 @tornado.gen.coroutine
 def get(self):
 while True:
 yield tornado.gen.sleep(1)
 s = time.time()
 self.write(str(s))
 print(s)
 yield self.flush()
def make_app():
 return tornado.web.Application([
 (r"/", MainHandler),
 ])
if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

Express 中的實現，有個大坑，就是：

app.all('/', (req, res) => {
 const f = () => {
 const t = new Date().getTime() + '\n';
 res.write(t);
 console.log(t);
 setTimeout(f, 1000);
 }
 setTimeout(f, 1000);
});

這段邏輯，在連接已經斷了的情況下，并不會停止，還是會永遠執行下去。所以，你得自己處理好：

const process = require('process');
const express = require('express');
const cookieParser = require('cookie-parser');
const app = express();
app.use(express.urlencoded({ extended: true }));
app.use(express.json());
app.use(cookieParser("key"))
app.set('trust proxy', false);
app.set('views', process.cwd() + '/template');
app.set('view engine', 'html');
app.engine('html', (path, options, callback) => {
 callback(false, '<h1>Hello</h1>');
});
app.all('/', (req, res) => {
 let close = false;
 const f = () => {
 const t = new Date().getTime() + '\n';
 res.write(t);
 console.log(t);
 if(!close){
 setTimeout(f, 1000);
 }
 }
 req.on('close', () => {
 close = true;
 });
 setTimeout(f, 1000);
});
app.listen(8888);

req 掛了一些事件的，可以通過 close 事件來得到當前連接是否已經關閉了。

req 上直接掛連接事件，從 net http Express 這個層次結構上來說，也很，尷尬了。 Web 層不應該關心到網絡連接這么底層的東西的。

我還是習慣這樣：

app.all('/', (req, res) => {
 res.write('<h1>123</h1>');
 res.end();
});

不過 res.write() 是不能直接處理 json 對象的，還是老老實實 res.send() 吧。

我會怎么用 Express

先說一下，我自己，目前在 Express 運用方面，并沒有太多的時間和復雜場景的積累。

即使這樣，作為技術上相對傳統的人，我會以我以往的 web 開發的套路，來使用 Express 。

我不喜歡日常用 app.all(path, callback) 這種形式去組織代碼。

首先，這會使 path 定義散落在各處，方便了開發，麻煩了維護。

其次，把 path 和具體實現邏輯 callback 綁在一起，我覺得也是反思維的。至少，對于我個人來說，開發的過程，先是想如何實現一個 handler ，最后，再是考慮要把這個 handle 與哪些 path 綁定。

再次，單純的 callback 缺乏層次感，用 app.use(path, callback) 這種來處理共用邏輯的方式，我覺得完全是扯談。共用邏輯是代碼之間本身實現上的關系，硬生生跟網絡應用層 HTTP 協議的 path 概念抽上關系，何必呢。當然，對于 callback 的組織，用純函數來串是可以的，不過我在這方面并沒有太多經驗，所以，我還是選擇用類繼承的方式來作層次化的實現。

我自己要用 Express ，大概會這樣組件項目代碼（不包括關系數據庫的 Model 抽象如何組織這部分）：

./
├── config.conf
├── config.js
├── handler
│ ├── base.js
│ └── index.js
├── middleware.js
├── server.js
└── url.js

• config.conf 是 ini 格式的項目配置。
• config.js 處理配置，包括日志，數據庫連接等。
• middleware.js 是針對整體流程的擴展機制，比如，給每個請求加一個 UUID ，每個請求都記錄一條日志，日志內容有請求的細節及本次請求的處理時間。
• server.js 是主要的服務啟動邏輯，整合各種資源，命令行參數 port 控制監聽哪個端口。不需要考慮多進程問題，（正式部署時 nginx 反向代理到多個應用實例，多個實例及其它資源統一用 supervisor 管理）。
• url.js 定義路徑與 handler 的映射關系。
• handler ，具體邏輯實現的地方，所有 handler 都從 BaseHandler 繼承。

BaseHandler 的實現：

class BaseHandler {
 constructor(req, res, next){
 this.req = req;
 this.res = res;
 this._next = next;
 this._finised = false;
 }
 run(){
 this.prepare();
 if(!this._finised){
 if(this.req.method === 'GET'){
 this.get();
 return;
 }
 if(this.req.method === 'POST'){
 this.post();
 return;
 }
 throw Error(this.req.method + ' this method had not been implemented');
 }
 }
 prepare(){}
 get(){
 throw Error('this method had not been implemented');
 }
 post(){
 throw Error('this method had not been implemented');
 }
 render(template, values){
 this.res.render(template, values, (err, html) => {
 this.finish(html);
 });
 }
 write(content){
 if(Object.prototype.toString.call(content) === '[object Object]'){
 this.res.write(JSON.stringify(content));
 } else {
 this.res.write(content);
 }
 }
 finish(content){
 if(this._finised){
 throw Error('this handle was finished');
 }
 this.res.send(content);
 this._finised = true;
 if(this._next){ this._next() }
 }
}
module.exports = {BaseHandler};
if(module === require.main){
 const express = require('express');
 const app = express();
 app.all('/', (req, res, next) => new BaseHandler(req, res, next).run() );
 app.listen(8888);
}

要用的話，比如 index.js ：

const BaseHandler = require('./base').BaseHandler;
class IndexHandler extends BaseHandler {
 get(){
 this.finish({a: 'hello'});
 }
}
module.exports = {IndexHandler};

url.js 中的樣子：

const IndexHandler = require('./handler/index').IndexHandler;
const Handlers = [];
Handlers.push(['/', IndexHandler]);
module.exports = {Handlers};

日志

后面這幾部分，都不屬于 Express 本身的內容了，只是我個人，隨便想到的一些東西。

找一個日志模塊的實現，功能上，就看這么幾點：

• 標準的級別： DEBUG，INFO，WARN, ERROR 這些。
• 層級的多個 logger 。
• 可注冊式的多種 Handler 實現，比如文件系統，操作系統的 rsyslog ，標準輸出，等。
• 格式定義，一般都帶上時間和代碼位置。

Node.js 中，大概就是 log4js 了， https://github.com/log4js-node/log4js-node 。

const log4js = require('log4js');
const layout = {
 type: 'pattern',
 pattern: '- * %p * %x{time} * %c * %f * %l * %m',
 tokens: {
 time: logEvent => {
 return new Date().toISOString().replace('T', ' ').split('.')[0];
 }
 }
};
log4js.configure({
 appenders: {
 file: { type: 'dateFile', layout: layout, filename: 'app.log', keepFileExt: true },
 stream: { type: 'stdout', layout: layout }
 },
 categories: {
 default: { appenders: [ 'stream' ], level: 'info', enableCallStack: false },
 app: { appenders: [ 'stream', 'file' ], level: 'info', enableCallStack: true }
 }
});
const logger = log4js.getLogger('app');
logger.error('xxx');
const l2 = log4js.getLogger('app.good');
l2.error('ii');

總的來說，還是很好用的，但是官網的文檔不太好讀，有些細節的東西沒講，好在源碼還是比較簡單。

說幾點：

• getLogger(name) 需要給一個名字，否則 default 的規則都匹配不到。
• getLogger('parent.child') 中的名字，規則匹配上，可以通過 . 作父子繼承的。
• enableCallStack: true 加上，才能拿到文件名和行號。

ini 格式配置

json 作配置文件，功能上沒問題，但是對人為修改是不友好的。所以，個人還是喜歡用 ini 格式作項目的環境配置文件。

Node.js 中，可以使用 ini 模塊作解析：

const s = `
[database]
host = 127.0.0.1
port = 5432
user = dbuser
password = dbpassword
database = use_this_database
[paths.default]
datadir = /var/lib/data
array[] = first value
array[] = second value
array[] = third value
`
const fs = require('fs');
const ini = require('ini');
const config = ini.parse(s);
console.log(config);

它擴展了 array[] 這種格式，但沒有對類型作處理（除了 true false），比如，獲取 port ，結果是 "5432" 。簡單夠用了。

WebSocket

Node.js 中的 WebSocket 實現，可以使用 ws 模塊， https://github.com/websockets/ws 。

要把 ws 的 WebSocket Server 和 Express 的 app 整合，需要在 Express 的 Server 層面動手，實際上這里說的 Server 就是 Node.js 的 http 模塊中的 http.createServer() 。

const express = require('express');
const ws = require('ws');
const app = express();
app.all('/', (req, res) => {
 console.log('/');
 res.send('hello');
});
const server = app.listen(8888);
const wss = new ws.Server({server, path: '/ws'});
wss.on('connection', conn => {
 conn.on('message', msg => {
 console.log(msg);
 conn.send(new Date().toISOString());
 });
});

對應的一個客戶端實現，來自： https://github.com/ilkerkesen/tornado-websocket-client-example/blob/master/client.py

# -*- coding: utf-8 -*-
import time
from tornado.ioloop import IOLoop, PeriodicCallback
from tornado import gen
from tornado.websocket import websocket_connect
class Client(object):
 def __init__(self, url, timeout):
 self.url = url
 self.timeout = timeout
 self.ioloop = IOLoop.instance()
 self.ws = None
 self.connect()
 PeriodicCallback(self.keep_alive, 2000).start()
 self.ioloop.start()
 @gen.coroutine
 def connect(self):
 print("trying to connect")
 try:
 self.ws = yield websocket_connect(self.url)
 except Exception:
 print("connection error")
 else:
 print("connected")
 self.run()
 @gen.coroutine
 def run(self):
 while True:
 msg = yield self.ws.read_message()
 print('read', msg)
 if msg is None:
 print("connection closed")
 self.ws = None
 break
 def keep_alive(self):
 if self.ws is None:
 self.connect()
 else:
 self.ws.write_message(str(time.time()))
if __name__ == "__main__":
 client = Client("ws://localhost:8888/ws", 5)

其它

• 命令行解析， yargs ，https://github.com/yargs/yargs
• UUID， uuid ， https://github.com/kelektiv/node-uuid

作者：zephyr

ode.js GET/POST請求

視頻地址: https://pan.baidu.com/s/1nvop1nN 密碼: s9iy

在很多場景中，我們的服務器都需要跟用戶的瀏覽器打交道，如表單提交。

表單提交到服務器一般都使用 GET/POST 請求。

本章節我們將為大家介紹 Node.js GET/POS T請求。

獲取GET請求內容

由于GET請求直接被嵌入在路徑中，URL是完整的請求路徑，包括了?后面的部分，因此你可以手動解析后面的內容作為GET請求的參數。

node.js 中 url 模塊中的 parse 函數提供了這個功能。

實例

varhttp = require('http');varurl = require('url');varutil = require('util'); http.createServer(function(req, res){res.writeHead(200, {'Content-Type': 'text/plain; charset=utf-8'}); res.end(util.inspect(url.parse(req.url, true)));}).listen(3000);

在瀏覽器中訪問 http://localhost:3000/user?name=編程改變未來&url=www.biancheng.com 然后查看返回結果:

獲取 URL 的參數

我們可以使用 url.parse 方法來解析 URL 中的參數，代碼如下：

實例

varhttp = require('http');varurl = require('url');varutil = require('util'); http.createServer(function(req, res){res.writeHead(200, {'Content-Type': 'text/plain'}); // 解析 url 參數varparams = url.parse(req.url, true).query; res.write("網站名：" + params.name); res.write("\n"); res.write("網站 URL：" + params.url); res.end(); }).listen(3000);

在瀏覽器中訪問 http://localhost:3000/user?name=編程改變未來&url=www.biancheng.com 然后查看返回結果:

獲取 POST 請求內容

POST 請求的內容全部的都在請求體中，http.ServerRequest 并沒有一個屬性內容為請求體，原因是等待請求體傳輸可能是一件耗時的工作。

比如上傳文件，而很多時候我們可能并不需要理會請求體的內容，惡意的POST請求會大大消耗服務器的資源，所以 node.js 默認是不會解析請求體的，當你需要的時候，需要手動來做。

基本語法結構說明

varhttp = require('http');varquerystring = require('querystring'); http.createServer(function(req, res){// 定義了一個post變量，用于暫存請求體的信息varpost = ''; // 通過req的data事件監聽函數，每當接受到請求體的數據，就累加到post變量中req.on('data', function(chunk){post += chunk; }); // 在end事件觸發后，通過querystring.parse將post解析為真正的POST請求格式，然后向客戶端返回。req.on('end', function(){post = querystring.parse(post); res.end(util.inspect(post)); });}).listen(3000);

以下實例表單通過 POST 提交并輸出數據：

實例

varhttp = require('http');varquerystring = require('querystring'); varpostHTML = '<html><head><meta charset="utf-8"><title>編程改變未來Node.js 實例</title></head>' + '<body>' + '<form method="post">' + '網站名： <input name="name"><br>' + '網站 URL： <input name="url"><br>' + '<input type="submit">' + '</form>' + '</body></html>'; http.createServer(function(req, res){varbody = ""; req.on('data', function(chunk){body += chunk; }); req.on('end', function(){// 解析參數body = querystring.parse(body); // 設置響應頭部信息及編碼res.writeHead(200, {'Content-Type': 'text/html; charset=utf8'}); if(body.name && body.url){// 輸出提交的數據res.write("網站名：" + body.name); res.write("<br>"); res.write("網站 URL：" + body.url); }else{// 輸出表單res.write(postHTML); }res.end(); });}).listen(3000);

Node.js Web 模塊

什么是 Web 服務器？

Web服務器一般指網站服務器，是指駐留于因特網上某種類型計算機的程序，Web服務器的基本功能就是提供Web信息瀏覽服務。它只需支持HTTP協議、HTML文檔格式及URL，與客戶端的網絡瀏覽器配合。

大多數 web 服務器都支持服務端的腳本語言（php、python、ruby）等，并通過腳本語言從數據庫獲取數據，將結果返回給客戶端瀏覽器。

目前最主流的三個Web服務器是Apache、Nginx、IIS。

Web 應用架構

• Client - 客戶端，一般指瀏覽器，瀏覽器可以通過 HTTP 協議向服務器請求數據。

• Server - 服務端，一般指 Web 服務器，可以接收客戶端請求，并向客戶端發送響應數據。

• Business - 業務層， 通過 Web 服務器處理應用程序，如與數據庫交互，邏輯運算，調用外部程序等。

• Data - 數據層，一般由數據庫組成。

使用 Node 創建 Web 服務器

Node.js 提供了 http 模塊，http 模塊主要用于搭建 HTTP 服務端和客戶端，使用 HTTP 服務器或客戶端功能必須調用 http 模塊，代碼如下：

var http = require('http');

以下是演示一個最基本的 HTTP 服務器架構(使用8081端口)，創建 server.js 文件，代碼如下所示：

var http = require('http');
var fs = require('fs');
var url = require('url');
// 創建服務器
http.createServer( function (request, response) { 
// 解析請求，包括文件名
var pathname = url.parse(request.url).pathname;
// 輸出請求的文件名
console.log("Request for " + pathname + " received.");
// 從文件系統中讀取請求的文件內容
fs.readFile(pathname.substr(1), function (err, data) {
if (err) {
console.log(err);
// HTTP 狀態碼: 404 : NOT FOUND
// Content Type: text/plain
response.writeHead(404, {'Content-Type': 'text/html'});
}else{ 
// HTTP 狀態碼: 200 : OK
// Content Type: text/plain
response.writeHead(200, {'Content-Type': 'text/html'}); 
// 響應文件內容
response.write(data.toString()); 
}
// 發送響應數據
response.end();
}); 
}).listen(8081);
// 控制臺會輸出以下信息
console.log('Server running at http://127.0.0.1:8081/');

接下來我們在該目錄下創建一個 index.htm 文件，代碼如下：

<html>
<head>
<title>Sample Page</title>
</head>
<body>
Hello World!
</body>
</html>

執行 server.js 文件：

$ node server.js
Server running at http://127.0.0.1:8081/

接著我們在瀏覽器中打開地址：http://127.0.0.1:8081/index.htm，顯示如下圖所示:

執行 server.js 的控制臺輸出信息如下：

Server running at http://127.0.0.1:8081/
Request for /index.htm received. # 客戶端請求信息

Gif 實例演示

使用 Node 創建 Web 客戶端

Node 創建 Web 客戶端需要引入 http 模塊，創建 client.js 文件，代碼如下所示：

var http = require('http');
// 用于請求的選項
var options = {
host: 'localhost',
port: '8081',
path: '/index.htm' 
};
// 處理響應的回調函數
var callback = function(response){
// 不斷更新數據
var body = '';
response.on('data', function(data) {
body += data;
});
response.on('end', function() {
// 數據接收完成
console.log(body);
});
}
// 向服務端發送請求
var req = http.request(options, callback);
req.end();

新開一個終端，執行 client.js 文件，輸出結果如下：

$ node client.js
<html>
<head>
<title>Sample Page</title>
</head>
<body>
Hello World!
</body>
</html>

執行 server.js 的控制臺輸出信息如下：

Server running at http://127.0.0.1:8081/
Request for /index.htm received. # 客戶端請求信息

Gif 實例演示

Express 簡介

Express 是一個簡潔而靈活的 node.js Web應用框架, 提供了一系列強大特性幫助你創建各種 Web 應用，和豐富的 HTTP 工具。

使用 Express 可以快速地搭建一個完整功能的網站。

Express 框架核心特性：

• 可以設置中間件來響應 HTTP 請求。

• 定義了路由表用于執行不同的 HTTP 請求動作。

• 可以通過向模板傳遞參數來動態渲染 HTML 頁面。

安裝 Express

安裝 Express 并將其保存到依賴列表中：

$ cnpm install express --save

以上命令會將 Express 框架安裝在當前目錄的 node_modules 目錄中， node_modules 目錄下會自動創建 express 目錄。以下幾個重要的模塊是需要與 express 框架一起安裝的：

• body-parser - node.js 中間件，用于處理 JSON, Raw, Text 和 URL 編碼的數據。

• cookie-parser - 這就是一個解析Cookie的工具。通過req.cookies可以取到傳過來的cookie，并把它們轉成對象。

• multer - node.js 中間件，用于處理 enctype="multipart/form-data"（設置表單的MIME編碼）的表單數據。

$ cnpm install body-parser --save
$ cnpm install cookie-parser --save
$ cnpm install multer --save

安裝完后，我們可以查看下 express 使用的版本號：

$ cnpm list express/data/www/node└── express@4.15.2 -> /Users/tianqixin/www/node/node_modules/.4.15.2@express

第一個 Express 框架實例

接下來我們使用 Express 框架來輸出 "Hello World"。

以下實例中我們引入了 express 模塊，并在客戶端發起請求后，響應 "Hello World" 字符串。

創建 express_demo.js 文件，代碼如下所示：

express_demo.js 文件代碼：

//express_demo.js 文件varexpress = require('express');varapp = express(); app.get('/', function(req, res){res.send('Hello World');})varserver = app.listen(8081, function(){varhost = server.address().addressvarport = server.address().portconsole.log("應用實例，訪問地址為 http://%s:%s", host, port)})

執行以上代碼：

$ node express_demo.js
應用實例，訪問地址為 http://0.0.0.0:8081

在瀏覽器中訪問 http://127.0.0.1:8081，結果如下圖所示：

請求和響應

Express 應用使用回調函數的參數： request 和 response 對象來處理請求和響應的數據。

app.get('/', function (req, res) {
 // --})

request 和 response 對象的具體介紹：

Request 對象 - request 對象表示 HTTP 請求，包含了請求查詢字符串，參數，內容，HTTP 頭部等屬性。常見屬性有：

1. req.app：當callback為外部文件時，用req.app訪問express的實例

2. req.baseUrl：獲取路由當前安裝的URL路徑

3. req.body / req.cookies：獲得「請求主體」/ Cookies

4. req.fresh / req.stale：判斷請求是否還「新鮮」

5. req.hostname / req.ip：獲取主機名和IP地址

6. req.originalUrl：獲取原始請求URL

7. req.params：獲取路由的parameters

8. req.path：獲取請求路徑

9. req.protocol：獲取協議類型

10. req.query：獲取URL的查詢參數串

11. req.route：獲取當前匹配的路由

12. req.subdomains：獲取子域名

13. req.accepts()：檢查可接受的請求的文檔類型

14. req.acceptsCharsets / req.acceptsEncodings / req.acceptsLanguages：返回指定字符集的第一個可接受字符編碼

15. req.get()：獲取指定的HTTP請求頭

16. req.is()：判斷請求頭Content-Type的MIME類型

Response 對象 - response 對象表示 HTTP 響應，即在接收到請求時向客戶端發送的 HTTP 響應數據。常見屬性有：

1. res.app：同req.app一樣

2. res.append()：追加指定HTTP頭

3. res.set()在res.append()后將重置之前設置的頭

4. res.cookie(name，value [，option])：設置Cookie

5. opition: domain / expires / httpOnly / maxAge / path / secure / signed

6. res.clearCookie()：清除Cookie

7. res.download()：傳送指定路徑的文件

8. res.get()：返回指定的HTTP頭

9. res.json()：傳送JSON響應

10. res.jsonp()：傳送JSONP響應

11. res.location()：只設置響應的Location HTTP頭，不設置狀態碼或者close response

12. res.redirect()：設置響應的Location HTTP頭，并且設置狀態碼302

13. res.send()：傳送HTTP響應

14. res.sendFile(path [，options] [，fn])：傳送指定路徑的文件 -會自動根據文件extension設定Content-Type

15. res.set()：設置HTTP頭，傳入object可以一次設置多個頭

16. res.status()：設置HTTP狀態碼

17. res.type()：設置Content-Type的MIME類型

路由

我們已經了解了 HTTP 請求的基本應用，而路由決定了由誰(指定腳本)去響應客戶端請求。

在HTTP請求中，我們可以通過路由提取出請求的URL以及GET/POST參數。

接下來我們擴展 Hello World，添加一些功能來處理更多類型的 HTTP 請求。

創建 express_demo2.js 文件，代碼如下所示：

express_demo2.js 文件代碼：

varexpress = require('express');varapp = express(); // 主頁輸出 "Hello World"app.get('/', function(req, res){console.log("主頁 GET 請求"); res.send('Hello GET');})// POST 請求app.post('/', function(req, res){console.log("主頁 POST 請求"); res.send('Hello POST');})// /del_user 頁面響應app.get('/del_user', function(req, res){console.log("/del_user 響應 DELETE 請求"); res.send('刪除頁面');})// /list_user 頁面 GET 請求app.get('/list_user', function(req, res){console.log("/list_user GET 請求"); res.send('用戶列表頁面');})// 對頁面 abcd, abxcd, ab123cd, 等響應 GET 請求app.get('/ab*cd', function(req, res){console.log("/ab*cd GET 請求"); res.send('正則匹配');})varserver = app.listen(8081, function(){varhost = server.address().addressvarport = server.address().portconsole.log("應用實例，訪問地址為 http://%s:%s", host, port)})

執行以上代碼：

$ node express_demo2.js
應用實例，訪問地址為 http://0.0.0.0:8081

接下來你可以嘗試訪問 http://127.0.0.1:8081 不同的地址，查看效果。

在瀏覽器中訪問 http://127.0.0.1:8081/list_user，結果如下圖所示：

在瀏覽器中訪問 http://127.0.0.1:8081/abcd，結果如下圖所示：

在瀏覽器中訪問 http://127.0.0.1:8081/abcdefg，結果如下圖所示：

靜態文件

Express 提供了內置的中間件 express.static 來設置靜態文件如：圖片， CSS, JavaScript 等。

你可以使用 express.static 中間件來設置靜態文件路徑。例如，如果你將圖片， CSS, JavaScript 文件放在 public 目錄下，你可以這么寫：

app.use(express.static('public'));

我們可以到 public/images 目錄下放些圖片,如下所示：

node_modules
server.jspublic/public/imagespublic/images/logo.png

讓我們再修改下 "Hello World" 應用添加處理靜態文件的功能。

創建 express_demo3.js 文件，代碼如下所示：

express_demo3.js 文件代碼：

varexpress = require('express');varapp = express(); app.use(express.static('public')); app.get('/', function(req, res){res.send('Hello World');})varserver = app.listen(8081, function(){varhost = server.address().addressvarport = server.address().portconsole.log("應用實例，訪問地址為 http://%s:%s", host, port)})

執行以上代碼：

$ node express_demo3.js
應用實例，訪問地址為 http://0.0.0.0:8081

執行以上代碼：

GET 方法

以下實例演示了在表單中通過 GET 方法提交兩個參數，我們可以使用 server.js 文件內的 process_get 路由器來處理輸入：

index.htm 文件代碼：

<html><body><formaction="http://127.0.0.1:8081/process_get"method="GET">First Name: <inputtype="text"name="first_name"><br> Last Name: <inputtype="text"name="last_name"><inputtype="submit"value="Submit"></form></body></html>

server.js 文件代碼：

varexpress = require('express');varapp = express(); app.use(express.static('public')); app.get('/index.htm', function(req, res){res.sendFile(__dirname + "/" + "index.htm");})app.get('/process_get', function(req, res){// 輸出 JSON 格式varresponse = {"first_name":req.query.first_name, "last_name":req.query.last_name}; console.log(response); res.end(JSON.stringify(response));})varserver = app.listen(8081, function(){varhost = server.address().addressvarport = server.address().portconsole.log("應用實例，訪問地址為 http://%s:%s", host, port)})

執行以上代碼：

node server.js
應用實例，訪問地址為 http://0.0.0.0:8081

瀏覽器訪問 http://127.0.0.1:8081/index.htm，如圖所示：

現在你可以向表單輸入數據，并提交，如下演示：

POST 方法

以下實例演示了在表單中通過 POST 方法提交兩個參數，我們可以使用 server.js 文件內的 process_post 路由器來處理輸入：

index.htm 文件代碼：

<html><body><formaction="http://127.0.0.1:8081/process_post"method="POST">First Name: <inputtype="text"name="first_name"><br> Last Name: <inputtype="text"name="last_name"><inputtype="submit"value="Submit"></form></body></html>

server.js 文件代碼：

varexpress = require('express');varapp = express();varbodyParser = require('body-parser'); // 創建 application/x-www-form-urlencoded 編碼解析varurlencodedParser = bodyParser.urlencoded({extended: false})app.use(express.static('public')); app.get('/index.htm', function(req, res){res.sendFile(__dirname + "/" + "index.htm");})app.post('/process_post', urlencodedParser, function(req, res){// 輸出 JSON 格式varresponse = {"first_name":req.body.first_name, "last_name":req.body.last_name}; console.log(response); res.end(JSON.stringify(response));})varserver = app.listen(8081, function(){varhost = server.address().addressvarport = server.address().portconsole.log("應用實例，訪問地址為 http://%s:%s", host, port)})

執行以上代碼：

$ node server.js應用實例，訪問地址為 http://0.0.0.0:8081

瀏覽器訪問 http://127.0.0.1:8081/index.htm，如圖所示：

現在你可以向表單輸入數據，并提交，如下演示：

文件上傳

以下我們創建一個用于上傳文件的表單，使用 POST 方法，表單 enctype 屬性設置為 multipart/form-data。

index.htm 文件代碼：

<html><head><title>文件上傳表單</title></head><body><h3>文件上傳：</h3>選擇一個文件上傳: <br/><formaction="/file_upload"method="post"enctype="multipart/form-data"><inputtype="file"name="image"size="50"/><br/><inputtype="submit"value="上傳文件"/></form></body></html>

server.js 文件代碼：

<pre>varexpress = require('express');varapp = express();varfs = require("fs"); varbodyParser = require('body-parser');varmulter = require('multer'); app.use(express.static('public'));app.use(bodyParser.urlencoded({extended: false}));app.use(multer({dest: '/tmp/'}).array('image')); app.get('/index.htm', function(req, res){res.sendFile(__dirname + "/" + "index.htm");})app.post('/file_upload', function(req, res){console.log(req.files[0]); // 上傳的文件信息vardes_file = __dirname + "/" + req.files[0].originalname; fs.readFile(req.files[0].path, function(err, data){fs.writeFile(des_file, data, function(err){if(err){console.log(err); }else{response = {message:'File uploaded successfully', filename:req.files[0].originalname}; }console.log(response); res.end(JSON.stringify(response)); }); });})varserver = app.listen(8081, function(){varhost = server.address().addressvarport = server.address().portconsole.log("應用實例，訪問地址為 http://%s:%s", host, port)})

執行以上代碼：

$ node server.js
應用實例，訪問地址為 http://0.0.0.0:8081

瀏覽器訪問 http://127.0.0.1:8081/index.htm，如圖所示：

現在你可以向表單輸入數據，并提交，如下演示：

Cookie 管理

我們可以使用中間件向 Node.js 服務器發送 cookie 信息，以下代碼輸出了客戶端發送的 cookie 信息：

express_cookie.js 文件代碼：

// express_cookie.js 文件varexpress = require('express')varcookieParser = require('cookie-parser')varapp = express()app.use(cookieParser())app.get('/', function(req, res){console.log("Cookies: ", req.cookies)})app.listen(8081)

執行以上代碼：

$ node express_cookie.js

現在你可以訪問 http://127.0.0.1:8081 并查看終端信息的輸出，如下演示：

相關資料

• Express官網： http://expressjs.com/

• Express4.x API 中文版： Express4.x API Chinese

• Express4.x API：http://expressjs.com/zh-cn/4x/api.html