Express実践

libe-irevo@master 2024年1月25日

基本的な使い方

PATHパラメータを受け取る

パス名にコロン(:)をつけるとパラメータとして受け取ることができます。

main.js

const express = require("express");
const app = express();
app.get("/hello/:name", (req, res) => {
  console.log(req.params.name);
  res.send("OK\n");
});
app.listen(80);

クライアントから次の様に呼び出します。

$ curl http://127.0.0.1/hello/Yamada

GETパラメータを受け取る

GET パラメータは req.query で受け取ります。

main.js

const express = require("express");
const app = express();
app.get("/hello", (req, res) => {
  console.log(req.query.name);
  console.log(req.query.age);
  res.send("OK\n");
});
app.listen(80);

クライアントから次の様に呼び出します。

$ curl "http://127.0.0.1/hello?name=Yamada&age=36"

POSTパラメータを受け取る

POST パラメータは express.urlencoded() を用いて受け取ります。

main.js

const express = require("express");
const app = express();
app.use(express.urlencoded({ extended: true }));
app.post("/hello", (req, res) => {
  console.log(req.body.name);
  console.log(req.body.age);
  res.send("OK\n");
});
app.listen(80);

クライアントから次の様に呼び出します。

$ curl -X POST -d 'name=Yamada&age=36' http://127.0.0.1/hello

extended: true の場合はデコーダーとして qs を、extended: false の場合は querystring を使用します。qs ライブラリの場合は、name[1]=Taro, name[2]=Jiro などのデータを配列として解釈してくれます。

$ curl -X POST -d 'name[1]=Yamada&name[2]=Taro&age=36' http://127.0.0.1/hello

express.urlencoded() の部分は express のバージョンによって色々変更があります。元々は bodyDecoder() でしたが bodyParser() に名称変更し、Express4 では body-parser という別モジュールに切り出されたのですが、v4.16.0 で再度 express に同梱されました。

// 古い書き方(1): bodyDecoder時代
app.use(express.bodyDecoder());

// 古い書き方(2): Express3 bodyParser時代
app.use(express.bodyParser());

// 古い書き方(3): Express4前期 urlencoded + body-parser時代
var bodyParser = require("body-parser");
app.use(bodyParser.urlencoded({ extended: false }));

// 新しい書き方: Express 4.16.0 以降
app.use(express.urlencoded({ extended: true }));

JSONデータを受け取る

JSON データは express.json() を用いて受け取ります。res.json() を用いると JSON データを返却できます。

main.js

const express = require("express");
const app = express();
app.use(express.json())
app.post("/", (req, res) => {
  console.log(req.body.name);
  console.log(req.body.age);
  res.json({status: "OK"});
});
app.listen(80);

クライアントから次の様に呼び出します。

$ curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "Yamada", "age": 36}' http://127.0.0.1/

EJSテンプレートエンジンを使用する

EJS, Jade, Pug などのテンプレートエンジンを使用することができます。まず、EJS をインストールします。

$ npm install ejs

views フォルダを作成します。

$ mkdir views

views フォルダ内に test.ejs テンプレートを作成します。<%= var %> は var で指定した変数の値を表示します。

views/test.ejs

<!DOCTYPE html>
<html>
 <head>
  <title>TEST</title>
 </head>
 <body>
  <p>Hello <%= name %></p>
 </body>
</html>

Express からこれを呼び出します。

main.js

const express = require("express");
const app = express();
app.set("view engine", "ejs");
app.get("/", (req, res) => {
  res.render("test", { name: "Yamada" });
});
app.listen(80);

スタティックファイルを返却する

express.static() を用いて特定フォルダ配下のファイルを HTML, CSS, JavaScript, 画像などのスタティックファイルとして返却することができます。

$ mkdir -p static/css static/js static/img

static/css/style.css

* { box-sizing: border-box; }

main.js

const express = require("express");
const app = express();
app.use(express.static("static"));
app.get("/hello", (req, res) => {
  res.send("OK\n");
});
app.listen(80);

Client

$ curl http://127.0.0.1/css/style.css

HTTPステータスを返却する

200 以外の HTTPステータスを返却するには res.status() を用います。

main.js

const express = require('express');
const app = express();
app.get("/", (req, res) => {
  res.status(201).send("Created\n");
});
app.listen(80);

HTTPヘッダを参照・返却する

リクエストのHTTPヘッダを参照するには req.get() を、レスポンスのHTTPヘッダを設定するには res.append() を使用します。

main.js

const express = require('express');
const app = express();
app.get("/", (req, res) => {
  console.log(req.get("Content-Type"));
  res.append("Content-Type", "text/plain");
  res.send("Created\n");
});
app.listen(80);

ルーティング処理を分割する

http://～/users/ 配下の処理は users.js で、http://～/groups/ 配下の処理は groups.js でなど、機能群に応じて実装ファイルを分割することができます。

main.js

const express = require("express");
const app = express();
app.use("/users", require("./users.js"));
app.use("/groups", require("./groups.js"));
app.listen(80);

users.js

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

var users = [
  { name: "Tanaka", age: 36 },
  { name: "Suzuki", age: 42 },
  { name: "Yamada", age: 53 },
];

router.get("/", (req, res) => {
  res.json(users);
});
module.exports = router;

Client

$ curl http://127.0.0.1/users

APIリファレンス(Express)

express.urlencoded([options])

POST データを受け取る際に必要な処理です。データを URLエンコーディングされたデータとして受け取り、req.body に格納します。v4.16.0 でサポートされました。(詳細)

app.use(express.urlencoded({ limit: "100kb" }));

express.json([options])

データを JSON データとして解析し、req.body に格納します。クライアントは Content-Type ヘッダに application/json を指定します。v4.16.0 でサポートされました。(詳細)

app.use(express.json());

express.text([options])

データをテキストデータとして受け取り、req.body に格納します。v4.17.0 でサポートされました。(詳細)

app.use(express.text({ defaultCharset: "utf-8" }));

express.raw([options])

データをバイナリデータとして受け取り、req.body に格納します。v4.17.0 でサポートされました。(詳細)

app.use(express.raw({ limit: "100kb" }));

express.static(root, [options])

root ディレクトリ配下のファイルをスタティックファイルとして返却します。(詳細)

app.use(express.static("static"));

express.Router([options])

Router オブジェクトを作成します。上記の使用例を参照してください。(詳細)

const router = express.Router();
router.get("/", (req, res) => {
  res.json(users);
});

APIリファレンス(Application)

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

port で指定したポート番号でクライアントからのリクエストを待ち受けします。(詳細)

const express = require("express");
const app = express();
app.listen(8080);

port を省略すると適当なポート番号が自動割り当てされます。割り当てられたポート番号は listener.address().port で知ることができます。

const listener = app.listen();
console.log(listener.address().port);

host を指定するとバインドするネットワークインタフェースを指定することができます。

app.listen(8080, "127.0.0.1");

backlog には接続時の待ち受けキューの数を指定します。

app.listen(8080, "127.0.0.1", 10);

callback には接続開始時に呼ばれるコールバックを指定することができます。

app.listen(8080, (err) => {
  if (err) {
    console.log("ERROR");
  } else {
    console.log(`Start server.`);
  }
});

app.get(path, callback [, callback…])

GET メソッドに対応するハンドラを指定します。(詳細)

main.js

app.get("/users/:user_id", (req, res) => {
  res.send(`Get user ${req.params.user_id}.\n`);
});

app.post(path, callback [, callback…])

POST メソッドに対応するハンドラを指定します。(詳細)

main.js

app.post("/users", (req, res) => {
  res.send(`Create user.\n`);
});

app.put(path, callback [, callback…])

PUT メソッドに対応するハンドラを指定します。(詳細)

main.js

app.put("/users/:user_id", (req, res) => {
  res.send(`Update user ${req.params.user_id}.\n`);
});

app.delete(path, callback [, callback…])

DELETE メソッドに対応するハンドラを指定します。(詳細)

main.js

app.delete("/users/:user_id", (req, res) => {
  res.send(`Delete user ${req.params.user_id}.\n`);
});

app.all(path, callback [, callback…])

GET, POST, PUT, DELETE などすべての HTTP メソッドに対して処理を行います。(詳細)

main.js

const express = require("express");
const app = express();
app.all("/", (req, res) => {
  console.log(req.method);
  res.send("OK\n");
});
app.listen(80);

app.use([path,] callback [, callback…])

path で始まる URL にアクセスされた際に呼び出されるミドルウェアコールバックを指定します。path を省略するとすべてのリクエストに対してミドルウェアを実行します。(詳細)

main.js

const express = require("express");
const app = express();
app.use("/", (req, res, next) => {
  console.log("MIDDLEWARE");
  next();
});
app.get("/admin", (req, res) => {
  console.log("ADMIN");
  res.send("OK\n");
});
app.listen(80);

callback には下記のようなサブアプリケーションを指定することもできます。book は http://～/books 配下の URL に対するアプリケーションを定義します。

main.js

const express = require('express');
const app = express();
const book = express();
app.use("/books", book);
book.get("/", (req, res) => {
  res.send("OK\n");
});
app.listen(80);

app.path()

app.use() で設定したアプリケーションの基準パスを返します。(詳細)

main.js

const express = require('express');
const app = express();
const book = express();
app.use("/books", book);
console.log(book.path());     // => /books

app.locals

app.locals.name に設定した値をテンプレートエンジンで参照することができます。app.set() で設定した値は app.locals.settings に格納されます。app.locals に設定した値は次のリクエストでも保持されます。リクエスト内で有効な値を設定するには res.locals を用います。(詳細)

main.js

const express = require("express");
const app = express();
app.set("view engine", "ejs");
app.locals.foo = "FOO";
app.get("/", (req, res) => {
  res.render("test");
});
app.listen(80);

views/test.ejs

<p><%= foo %></p>

app.set(name, value)

app.locals.settings.name に値を設定します。(詳細)

main.js

app.set("foo", "FOO");

app.get(name)

app.locals.settings.name を読み出します。(詳細)

main.js

app.get("foo");          // => FOO

app.enable(name)

app.locals.settings.name パラメータを true に設定します。(詳細)

main.js

app.enable("foo");      // foo=true

app.enabled(name)

app.locals.settings.name パラメータが true であるかを調べます。(詳細)

main.js

app.disable("foo");      // foo=fakse

app.disabled(name)

app.locals.settings.name パラメータが false であるかを調べます。(詳細)

main.js

if (app.disabled("foo")) { ... }

app.mountpath

メインパスに対してサブパスが設定されている場合、サブパスが適用されているパス名を返します。(詳細)

main.js

const express = require("express");
const app = express();            // メインパス
const admin = express();          // サブパス
app.use("/admin", admin);
admin.get("/", (req, res) => {
  console.log(admin.mountpath);   // => /admin
  res.send("OK\n");
});
app.listen(80);

app.on(“mount”, …)

サブパスがマウントされた時に呼ばれます。parent には親の app が渡されます。(詳細)

main.js

const express = require("express");
const app = express();
const admin = express();
admin.on("mount", (parent) => {
  console.log(parent);
});
app.use("/admin", admin);

app.engine(ext, callback)

拡張子 ext に対応するテンプレートエンジンを指定します。(詳細)

main.js

const ejs = require("ejs");
app.engine("ejs", ejs.renderFile);

app.render(view, [locals], callback)

テンプレートエンジンを用いてレンダリングします。res.redner() がレンダリングした結果をクライアントに返すのに対して、app.render() はレンダリング結果をコールバック関数で返却します。(詳細)

main.js

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

app.set('view engine', 'ejs');

app.render('test', { name: "Yamada" }, (err, html) => {
    if (err) console.log(err);
    console.log(html);
});

app.METHOD(path, callback [, callback …])

path に対して METHOD で指定したメソッドを受信した場合に callback を呼び出します。METHOD には get, post, put, delete, head など(下記参照)のうちひとつを指定します。(詳細)

checkout
copy
delete
get
head
lock
merge
mkactivity
mkcol
move
m-search
notify
options
patch
post
purge
put
report
search
subscribe
trace
unlock
unsubscribe

main.js

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

app.get("/", (req, res) => {
  res.send("OK\n");
});

app.listen(80);

app.route(path)

path に対するルートインスタンスを返却します。ルートインスタンスは .get(), .post(), .put(), .delete() および .all() などのメソッドを持ち、それぞれのメソッドに対する処理を行います。(詳細)

main.js

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

app.route("/")
  .get((req, res, next) => {
    res.send("GET\n");
  })
  .post((req, res, next) => {
    res.send("POST\n");
  })
  .all((req, res, next) => {
    res.send("ALL\n");
  });

app.listen(80);

app.param([name], callback)

name で指定したパラメータに対する前処理を行います。下記の例では :user で受け取るユーザ名に対して [ … ] で囲むといった前処理を行っています。(詳細)

main.js

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

app.param("user", (req, res, next, id) => {
  req.params.user = "[" + req.params.user + "]";
  next();
});

app.get("/users/:user", (req, res) => {
  console.log(req.params.user);
  res.send("OK\n");
});

app.listen(80);

APIリファレンス(Request)

req.method

リクエストメソッド(GET, POST, PUT, DELETE)を示します。(詳細)

// GET http://www.example.com/
console.log(req.method);           // => GET

req.protocol

プロトコル(http, https)を示します。(詳細)

// http://www.example.com/
console.log(req.protocol);         // => http

req.hostname

サーバのホスト名を示します。(詳細)

// http://foo.baa.example.com/
console.log(req.hostname);         // => foo.baa.example.com

req.subdomains

サーバのサブドメイン部の配列を返します。(詳細)

// http://foo.baa.example.com/
console.log(req.subdomains);       // => ["baa", "foo"]

req.path

アクセスされたパス名を示します。?foo=FOO などの GETパラメータは除外されます。(詳細)

// http://www.example.com/hello?foo=FOO
console.log(req.path);             // => /hello

req.originalUrl

アクセスされたパス名を示します。?foo=FOO などの GETパラメータも含まれます。(詳細)

// http://www.example.com/hello?foo=FOO
console.log(req.originalUrl);      // => /hello?foo=FOO

req.params

app.get() などの第一引数で :name で指定されたパラメータを受け取ります。(詳細)

// http://www.example.com/groups/G123/U456
app.get("/groups/:group_id/:user_id", (req, res) => {
  res.send(req.params);            // => {"group_id": "G123", "user_id": "U456"}
});

req.query

パスパラメータ(URL の ? 以降に指定された key=value パラメータ)を示します。(詳細)

// http://www.example.com/hello?foo=FOO&baa=BAA
app.get("/hello", (req, res) => {
  res.send(req.query);             // => {"foo": "FOO", "baa": "BAA"}
});

req.body

下記の例では URLエンコーディングされた POST パラメータを示します。(詳細)

app.use(express.urlencoded({ extended: true }));
app.post("/", (req, res) => {
  res.send(req.body);
});

$ curl -X POST -d 'name=Yamada&age=26' http://127.0.0.1
{"name":"Yamada","age":"26"}

下記の例では POST された JSON データを示します。

app.use(express.json())
app.post("/", (req, res) => {
  res.json(req.body);
});

$ curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "Yamada", "age": 26}' http://127.0.0.1
{"name":"Yamada","age":26}

req.cookies

リクエストに含まれる Cookie 情報を参照します。cookie-parser をインストールしてミドルウェアに組み込んでおく必要があります。(詳細)

$ npm install cookie-parser

const express = require("express");
const app = express();
const cookieParser = require("cookie-parser");
app.use(cookieParser());
app.get("/", (req, res) => {
  res.send(req.cookies);
});
app.listen(80);

$ curl -H "Cookie: name=Yamada" http://127.0.0.1/
{"name":"Yamada"}

req.signedCookies

リクエストに含まれる署名付きCookie情報を返します。cookie-parser をインストールしてミドルウェアに組み込んでおく必要があります。(詳細)

console.log(req.signedCookies);      // { "user: "...", ... }

req.app

このリクエストを処理しているアプリケーションを参照します。(詳細)

req.app.get("/", (req, res) => {
  req.sender("OK\n");
});

req.baseUrl

app.use() で設定したアプリケーションの基準パスを参照します。(詳細)

const express = require('express');
const app = express();
const book = express();
app.use("/books", book);

book.get("/", (req, res) => {
  console.log(req.baseUrl);
  res.send("OK\n");
});

app.listen(80);

req.fresh

レスポンスがクライアントキャッシュ中にまだフレッシュな状態か否か true/false で返します。(詳細)

console.log(req.fresh);      // true/false

req.stale

リクエストが古い(stale)か否かを true/false で返します。(詳細)

console.log(req.fresh);      // true/false

req.ip

クライアントのIPアドレスを返します。trust proxy が true に設定されていて、X-Forwarded-For ヘッダがある場合はその一番左側アドレスを返します。(詳細)

app.set("trust proxy", true);
console.log(req.ip);      // 192.168.100.1

req.ips

クライアント、および通信経路のIPアドレスを返します。trust proxy が true に設定されていて、X-Forwarded-For ヘッダがある場合はそのアドレスを配列で返します。(詳細)

// X-Forwarded-For: 192.168.100.1, 192.168.200.1
app.set("trust proxy", true);
console.log(req.ips);      // ["192.168.100.1", "192.168.200.1"]

req.route

ルーティング情報を返します。(詳細)

console.log(req.route);
Route {
  path: '/',
  stack: [
    Layer {
      handle: [Function (anonymous)],
      name: '<anonymous>',
      params: undefined,
      path: undefined,
      keys: [],
      regexp: /^\/?$/i,
      method: 'get'
    }
  ],
  methods: { get: true }
}

req.secure

通信がセキュアか否か (HTTPSを用いているか否か) を true/false で返します。(詳細)

console.log(req.secure);   // => true or false

req.xhr

Ajax 通信か否かを示すための X-Requested-With ヘッダに XMLHttpRequest が設定されていれば true を、さもなくば false を返します。(詳細)

console.log(req.xhr);      // => true or false

req.get(field)

field で指定したヘッダ情報を返します。(詳細)

// Content-Type: application/json
req.get("Content-Type");             // => "application/json"
req.get("No-Such-Header");           // => undefined

req.is(type)

クライアントから送信される Content-Type ヘッダと比較して、今から受け取るコンテンツタイプ types を調べます。types には文字列または文字列の配列を指定します。マッチすればマッチした種別を、マッチしなければ false を返します。リクエストボディが空の時は null が返されます。(詳細)

// Content-Type: application/json
req.is("json")                  // => "json"
req.is("application/json")      // => "application/json"
req.is("xml")                   // => false
req.is(["xml", "json"])         // => "json"

req.accepts(types)

クライアントから送信される Accept ヘッダと比較して、今から返却しようとするコンテンツタイプ types が、クライアントが受け付けられるコンテンツタイプかどうかを調べます。types には文字列または文字列の配列を指定します。マッチすればマッチした種別を、マッチしなければ false を返します。(詳細)

// Accept: text/html
req.access("html")             // => "html"
req.access("text/html")        // => "text/html"
req.access("json")             // => false
req.access(["json", "html"])   // => "html"

req.acceptsCharsets(charsets)

九合アントから送信される Accept-Charset ヘッダと比較して、今から返却しようとするコンテンツの文字コード charsets が、クライアントが受け付けられる文字コードとマッチするかどうかを調べます。(詳細)

// Accept-Charset: utf-8, Shift_JIS
req.acceptsCharsets("utf-8")                 // => "utf-8"
req.acceptsCharsets("Shift_JIS")             // => "Shift_JIS"
req.acceptsCharsets("EUC-JP")                // => false
req.acceptsCharsets(["EUC-JP", "utf-8"])     // => "utf-8"

req.acceptsEncodings(encodings)

クライアントから送信される Accept-Encoding ヘッダと比較して、今から返却しようとするコンテンツのエンコーディング encodings が、クライアントが受け付けられるエンコーディングとマッチするかどうかを調べます。(詳細)

// Accept-Encoding: gzip, compress
req.acceptsEncodings("gzip")                 // => "gzip"
req.acceptsEncodings("deflate")              // => false
req.acceptsEncodings(["deflate", "gzip"])    // => "gzip"

req.acceptsLanguages(languages)

クライアントから送信される Accept-Language ヘッダと比較して、今から返却しようとするコンテンツの言語 language が、クライアントが受け付けられる言語とマッチするかどうかを調べます。(詳細)

// Accept-Language: ja, en
req.acceptsLanguages("ja")                // => "ja"
req.acceptsLanguages("de")                // => false
req.acceptsLanguages(["de", "ja"])        // => "ja"

req.param(name[, defaultValue])

パスパラメータやGETパラメータを受け取ります。このメソッドは非推奨(deprecated) となっており、代わりに req.params, req.body, req.query を使用することが推奨されています。(詳細)

// curl http://www.example.com/users/yamada
app.get("/users/:user", (req, res) => {
  console.log(req.param("user"));             // => "yamada"
  res.send("OK\n");
});

// curl http://www.example.com/users?user=yamada
app.get("/users", (req, res) => {
  console.log(req.param("user"));             // => "yamada"
  res.send("OK\n");
});

// curl -X POST http://www.example.com/users -d 'user=yamada'
app.use(express.urlencoded({ extended: true }));
app.post("/users", (req, res) => {
  console.log(req.param("user"));             // => "yamada"
  res.send("OK\n");
});

req.range(maxsize[, options])

クライアントから送信される Range ヘッダ情報を返します。maxsize にはサーバが返却可能な最大サイズを指定します。(詳細)

// => curl -H "Range: bytes=0-999, 2000-2999" http://www.example.com/
const express = require('express');
const app = express();
app.get("/", (req, res) => {
  var range = req.range(8192);
  if (range.type == "bytes") {
    range.forEach((r) => {
      console.log(r.start + "-" + r.end);    // => 0-999, 2000-2999
    });
  }
  res.send("OK\n");
});
app.listen(80);

APIリファレンス(Response)

res.send([body])

HTTP のレスポンスボディを返却します。(詳細)

res.send("OK\n");
res.send({ foo: "FOO" });
res.status(404).send("Not Found.");

res.json()

JSONデータを返却します。(詳細)

res.json({ status: "OK" });
res.status(404).json({ error: "Not Found" });

res.render(view [, locals] [, callback])

テンプレートエンジンを用いて view で示したテンプレートに locals で示したパラメータを埋め込んで返却します。使用例は「EJSテンプレートエンジンを使用する」を参照してください。(詳細)

res.render("index", { name: "Yamada" });

res.sendFile(path [, options] [, fn])

path で指定したファイルを読み取って返却します。v4.8.0 でサポートされました。(詳細)

res.sendFile("index.html", { root: "./html" });

res.end([data][, encoding])

レスポンスを終了します。(詳細)

res.end();
res.status(404).end();

res.status(code)

HTTPステータスコードを指定します。(詳細)

res.status(403).end();
res.status(404).send("Not Found.");
res.status(404).sendFile("404.html");

res.app

このリクエストを処理しているアプリケーションを参照します。(詳細)

console.log(res.app);

res.headersSent

ヘッダ情報を送信済みか否かを true/false で返します。(詳細)

app.get('/', function (req, res) {
  console.dir(res.headersSent)             // => false
  res.send('OK')
  console.dir(res.headersSent)             // => true
})

res.locals

app.locals 同様、テンプレートエンジンに渡すパラメータを指定します。単一のリクエスト内のみで有効となる点が異なります。(詳細)

app.get("/", (req, res) => {
  res.locals.foo = "FOO";
  res.render("test");
});
// <p>Hello <%= foo %></p>

res.append(field[, value])

HTTPヘッダを加えます。(詳細)

res.append("Set-Cookie", "foo=FOO; path=/; HttpOnly");

res.attachment([filename])

アタッチメントファイルを処理するために Content-Disposition ヘッダを設定します。(詳細)

res.attachment();
// Content-Disposition: attachment

res.attachment("img/test.png");
// Content-Disposition: attachment; filename="test.png"
// Content-Type: image/png

レスポンスクッキーを設定します。(詳細)

res.cookie("foo", "FOO", { path: "/", secure: true });
// Set-Cookie: foo=FOO; Path=/; Secure

res.clearCookie()

設定したレスポンスクッキーを削除します。(詳細)

res.cookie("foo", "FOO", { path: "/", secure: true });
res.clearCookie("foo");

res.download(path [, filename] [, options] [, fn])

ファイルをダウンロードさせます。(詳細)

res.download("./img/test.png");
// Content-Type: image/png
// Content-Disposition: attachment; filename="test.png"

res.download("./img/test.png", "test123.png");
// Content-Disposition: attachment; filename="test123.png"

res.download("./img/test.png", { maxAge: "1d" });
// Cache-Control: public, max-age=86400

res.download("./img/test.png", (err) => { console.log(err) });

res.format(object)

クライアントが Accept ヘッダで指定したフォーマットに応じたレスポンス処理を行います。(詳細)

res.format({
  "text/plain": () => {
    res.send("Hello")
  },
  "text/html": () => {
    res.send("<p>Hello</p>")
  },
  "application/json": () => {
    res.send({ message: "Hello" })
  },
  default: () => {
    res.status(406).send("Not Acceptable")
  }
});

res.set(field [, value])

レスポンスのHTTPヘッダを設定します。(詳細)

res.set("Content-Type", "text/plain");

res.get(field)

レスポンスヘッダを参照します。(詳細)

res.get("Content-Type");          // => text/html; charset=utf-8

res.jsonp()

JSONP を実現するためのスクリプトを返却します。(詳細)

const express = require("express");
const app = express();
app.set('jsonp callback name', 'cb');
app.get("/", (req, res) => {
  res.jsonp({name: "Yamada"});
});
app.listen(80);

$ curl http://www.example.com/?cb=getData
/**/ typeof getData === 'function' && getData({"name":"Yamada"});

res.links(links)

Link ヘッダを返却します。(詳細)

res.links({
  next: '/users?page=2',
  last: '/users?page=5'
});
// Link: </users?page=2>; rel="next", </users?page=5>; rel="last"

res.location(path)

Location ヘッダを返却します。(詳細)

res.location("/login");
// Location: /login

res.redirect([status,] path)

指定したページにリダイレクトします。(詳細)

res.redirect(302, "/maintenance.html");
// HTTP/1.1 302 Found
// Location: /maintenance.html

res.sendStatus(status)

HTTPステータスを返却します。(詳細)

res.sendStatus(404);
// HTTP/1.1 404 Not Found

res.type(type)

Content-Type ヘッダを設定します。(詳細)

res.type("html");             // Content-Type: text/html
res.type("json");             // Content-Type: application/json
res.type("png");              // Content-Type: image/png

res.vary(field)

リクエストに含まれるヘッダ情報によってレスポンスが変動する可能性があることを示す Vary ヘッダを設定します。(詳細)

res.vary("User-Agent").send("OK\n");
// Vary: User-Agent

APIリファレンス(Router)

router.all(path, [callback, …] callback)

app.all() と同様です。(詳細)

const express = require("express");
const app = express();
const routerUser = express.Router();
app.use("/users", routerUser);
routerUser.all("/", (req, res) => {
  res.send("OK\n");
});
app.listen(80);

router.METHOD(path, [callback, …] callback)

app.METHOD() と同様です。(詳細)

const express = require("express");
const app = express();
const routerUser = express.Router();
app.use("/users", routerUser);
routerUser.get("/", (req, res) => {
  res.send("OK\n");
});
app.listen(80);

router.param(name, callback)

app.param() と同様です。(詳細)

router.param("user", (req, res, next, id) => {
  req.params.user = "[" + req.params.user + "]";
  next();
});

router.route(path)

app.route() と同様です。(詳細)

router.route("/")
  .get((req, res, next) => {
    res.send("GET\n");
  })
  .post((req, res, next) => {
    res.send("POST\n");
  })
  .all((req, res, next) => {
    res.send("ALL\n");

router.use([path], [function, …] function)

app.use() と同様です。(詳細)

route.use("/", (req, res, next) => {
  console.log("MIDDLEWARE");
  next();
});

オフィシャル：　https://expressjs.com/ja/

Node.jsテクニック,Express,Express入門,Express実践,Node.js