実行ファイル1つで動く — Goで同じAPIを書く

GoでAPIを書く。コードの画面とコンパイル装置、小さな実行ファイルの箱。

roadmap.sh のどこをやっているか

Backend›Pick a Language
  • Go(JavaScript / Node.js 以外の選択肢を1つ触る)
  • Learn a Language — 同じ HTTP サーバーを書き直して比べる

この記事は、上の項目を実際に手を動かして確かめる回です。

このサイトの本編は、引き続き Node.js で進みます。

前回: 部分一致は索引が効かない — 全文検索とMeilisearch 作業場所はVMの中(Ubuntu)です。サーバーとは何かの回で書いた ~/server/server.js を、隣に置いて見比べます。

ここまで、サーバー側のコードは全部 JavaScript で書いてきました。

15行のHTTPサーバーも、Express のAPIも、MySQL に繋いだところも、全部です。

それ自体は悪いことではありません。 ただ、1つしか知らないと、こういう勘違いが静かに育ちます。

npm install でライブラリを入れるのは、プログラミングというものの決まりだ。 try / catch でエラーを捕まえるのは、プログラミングというものの決まりだ。 ソースを置いておけば動くのは、プログラミングというものの決まりだ。

全部、JavaScript(と Node.js)の性質です。 決まりではありません。

そして、それを知る方法は1つしかありません。2つ目を触ることです。

この記事は Go の入門ではありません。 Go を仕事で使えるようにする回でもありません。やることは1つだけです。

すでに動いているものと、まったく同じものを、違う言語でもう一度書く。

同じ /api/tasks が返ってきたとき、違っていた部分が「言語の性質」、同じだった部分が「サーバーというものの性質」です。その線引きをするのが、この記事の目的です。

対象レベル: 初級〜中級 / 区分: 必修

目次

この記事でわかること

  • 1つの言語しか知らないと、「言語の性質」と「プログラミング一般」の区別が付かないこと。それを外から見るために2つ目を触る
  • サーバーがやっていることは、言語が変わっても1ミリも変わらないこと。掴んで・待って・受けて・返す、は Go でも同じ場所に出てくる
  • apt で入る Go は古いことがあること。公式の配布物を自分で展開して、PATH を通す必要があること
  • コンパイルすると実行ファイルが1つできること。Go も Node.js も入っていない場所で、そのまま動く。Dockerイメージが小さくなる理由はここ
  • エラーは投げるものではなく、返り値で返ってくるものでもありうること。try / catch は世界の決まりではない
  • どちらが優れているかという話ではないこと。言語は目的で選ぶ道具で、このサイトは引き続き Node.js で進めます

この記事でやること

  1. 公式の tar.gz から Go を入れて、PATH を通す(apt は使いません)
  2. サーバーとは何かの回の15行と、同じものを Go で書いて、行ごとに並べる
  3. 同じ /api/tasks を返すところまで書く
  4. ビルドして実行ファイルを作り、node が見えない状態で動かす。ldd と ls -lh でサイズを見る
  5. go fmt と「使っていない変数はエラー」を実際に踏む

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
コンパイルソースコードを、先にまとめて機械が実行できる形に変換しておくこと。変換された結果が「実行ファイル」です。Node.js は変換せず、実行するたびにソースを読みます。
実行ファイル(バイナリ)それ単体で起動できるファイル。./taskserver のように直接叩けます。ソースコードも、言語のインストールも要りません。
静的リンク必要な部品を全部、実行ファイルの中に入れてしまうこと。逆に、外部の共有ライブラリを起動時に読むのが動的リンクです。
ldd「この実行ファイルは、起動時にどの共有ライブラリを必要とするか」を表示する道具。静的リンクなら「必要なし」と返ります。
goroutine(ゴルーチン)Go で「これを同時に動かして」と指示したときにできる、非常に軽い処理の単位。go 関数名() と書くだけで作れます。この記事では深入りしません。
go.modそのフォルダが「Goのプロジェクト1つ」であることと、その名前を書いておくファイル。Node.js の package.json にあたる位置です。

なぜ、わざわざ2つ目の言語を触るのか

「言語をたくさん知っていると偉い」という話ではありません。 逆です。

1つしか知らない状態には、はっきりした欠陥があります。

比較対象が無いので、何が「その言語の都合」なのかが見えない。

具体的に書きます。ここまでの記事で、当たり前のように出てきたものです。

ここまで当たり前だったこと実は
node_modules がすぐ数百MBになるJavaScript の文化。 小さいライブラリを大量に積む前提の作り
エラーは throw されて、try / catch で捕まえる多くの言語がそうというだけ。 そうでない言語もある
型は後から TypeScript で足すもの最初から必須の言語のほうが多い
書き方(インデント・改行位置)は ESLint と Prettier で決める言語側が1つに決めてしまうやり方もある
デプロイするにはソース一式を配る1ファイル配れば終わる言語もある

右の列は、外から見ないと絶対に見えません。

なぜ Go なのか。 理由は2つだけです。

1. JavaScript との違いが、はっきり目に見える(コンパイルする・型を書く・例外が無い) 2. 標準ライブラリだけでHTTPサーバーが書ける。 Express にあたるものを入れなくていいので、比較が濁りません

Rust でも Python でも Java でも、「2つ目を触る」という目的は達成できます。 Go はその中で、この記事の分量に収まるというだけの理由で選んでいます。

① Go を入れる — apt は使わない

まず、apt で何が入るのかを見ます。 入れずに、見るだけです。

bash
$ apt-cache policy golang-go
golang-go:
  インストールされていません
  候補: 2:1.22~2build1
  バージョンテーブル:
     2:1.22~2build1 500
        500 http://jp.archive.ubuntu.com/ubuntu noble/main amd64 Packages

候補: の数字を見てください。 この例では 1.22 です。

これは Ubuntu が悪いのではありません。 apt の回に書いたとおり、Ubuntu のリポジトリは「そのリリース時点のバージョンで固定」します。安定して動くことのほうが大事だからです。 ですが Go はおよそ半年に1回、新しいバージョンが出ます。 その結果、apt の Go は1年以上前のものになっていることがあります。 入門記事どおりに書いたのに、そのバージョンにはまだ無い機能でエラーになる、というのがここで起きる事故です。言語そのものは、公式の配布物から入れるのが基本だと考えてください。

公式の配布物を取ってくる

まず、いま何番が最新かを自分で確認します。

<https://go.dev/dl/> を開いて、一番上の「Featured downloads」にある番号を見てください。go1.25.1 のような形です。

[スクリーンショット: 01_go_dl_ページ.png] ホストのWindowsのブラウザで <https://go.dev/dl/> を開き、最新版のバージョン番号が見えている部分を撮ってください。

VMの中で、その番号を入れて取ってきます。

bash
$ cd ~
$ GOVER=1.25.1
$ curl -LO https://go.dev/dl/go${GOVER}.linux-amd64.tar.gz
$ ls -lh go${GOVER}.linux-amd64.tar.gz

GOVER=1.25.1 の数字は、いま見た番号に置き換えてください。

部分意味
linuxOS。VMの中は Linux です
amd64CPUの種類。Intel / AMD の64bit のこと。VMware で立てた普通のVMはこれです
.tar.gzLinuxの基本コマンドの回で触った、まとめて圧縮した箱

curl -LO の意味。 -O は「URLの最後の名前でファイルとして保存する」、-L は「転送します、と言われたら付いていく」です。-L が無いと、中身が空のファイルが落ちてきます。

展開して、PATH を通す

bash
$ sudo rm -rf /usr/local/go
$ sudo tar -C /usr/local -xzf go${GOVER}.linux-amd64.tar.gz
$ ls /usr/local/go
CONTRIBUTING.md  LICENSE  README.md  api  bin  go.env  lib  misc  pkg  src  test
部分意味
sudo rm -rf /usr/local/go古いGoが入っていたら消す。 公式が指定しているやり方です。上書きすると古いファイルが混ざります
tar -C /usr/local/usr/local の中に展開する(-C は「そこへ移動してから作業する」)
-xzfx=取り出す、z=gzip圧縮を解く、f=このファイルを

/usr/local は「自分で入れたもの置き場」です。Linuxのディレクトリの回で書いたとおり、apt が管理する /usr/bin とは分けます。 ここに置いておけば、apt の更新とぶつかりません。

この時点では、まだ動きません。

bash
$ go version
go: command not found

入っているのに見つからない。 これは Linuxのコマンドの回でやった PATH の話です。

bash
$ echo $PATH

/usr/local/go/bin が入っていません。 シェルは PATH に書いてある場所しか探しません。足します。

bash
$ echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
$ source ~/.profile
$ go version
go version go1.25.1 linux/amd64

これで通りました。

部分意味
>> ~/.profile追記する(> だと中身を全部消して上書きします。絶対に間違えないでください)
source ~/.profileいま開いているシェルに、その場で読み込ませる。 これをしないと、ログインし直すまで効きません

~/.profile に書くと、次回ログイン時から自動で通ります。 同じことを npm の回で nvm がやっていました(あちらは ~/.bashrc に書き込んでいます)。「入れたのに command not found」の原因は、9割これです。

[スクリーンショット: 02_go_version.png] VMのターミナルで go version を実行し、バージョンが返っている画面を撮ってください。

② 同じサーバーを、Go で書く

比較対象を先に出します。 サーバーとは何かの回で書いた、これです。

const http = require("node:http");

const server = http.createServer((req, res) => {
  console.log(`${req.method} ${req.url}`);

  res.writeHead(200, { "Content-Type": "text/html; charset=UTF-8" });
  res.end("<h1>Node.js が返しています</h1>");
});

server.listen(3000, "0.0.0.0", () => {
  console.log("http://0.0.0.0:3000/ で待っています");
});

同じものを Go で書きます。 場所を分けます。

bash
$ mkdir -p ~/go-server
$ cd ~/go-server
$ go mod init taskserver
go: creating new go.mod: module taskserver
go: to add module requirements and sums, run:
	go mod tidy

go mod init は、Node.js の npm init にあたります。 npm の回の package.json と同じ位置のファイル(go.mod)ができます。 ただし node_modules にあたるものは、この記事では1つもできません。 これから書くサーバーは標準ライブラリだけで動くからです。

bash
$ nano main.go
package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s", r.Method, r.URL.Path)

		w.Header().Set("Content-Type", "text/html; charset=UTF-8")
		fmt.Fprint(w, "<h1>Go が返しています</h1>")
	})

	log.Println("http://0.0.0.0:8080/ で待っています")
	log.Fatal(http.ListenAndServe("0.0.0.0:8080", nil))
}

Go は未習の前提なので、1行ずつ説明します。

行何をしているか
package mainこのファイルが「実行できるプログラム」の入口だという宣言。 main 以外の名前だと、ライブラリ扱いになって実行ファイルになりません
import ( ... )使う標準ライブラリを並べる。require にあたります。 ただしインストールは不要(Goに最初から入っています)
func main() {プログラムはここから始まります。 JavaScript のようにファイルの上から順に実行されるのではなく、main が呼ばれるという形です
http.HandleFunc("/", ...)「パス / に来たら、この関数を呼べ」と登録する。createServer の中身にあたります
func(w http.ResponseWriter, r *http.Request)その関数の形。w が Node.js の res、r が req です。順番が逆なので注意してください
log.Printf("%s %s", ...)ログを1行出す。console.log にあたります。 %s の場所に、後ろの値が順に入ります
w.Header().Set(...)レスポンスヘッダーを1つ立てる。res.writeHead の第2引数にあたります
fmt.Fprint(w, "...")w に本文を書き込む。 res.end にあたります
http.ListenAndServe("0.0.0.0:8080", nil)ポートを掴んで待つ。 server.listen(3000, "0.0.0.0") そのものです
log.Fatal(...)中身がエラーだったら、ログに出してプログラムを終了する

動かします。

bash
$ go run main.go
2026/09/09 14:02:11 http://0.0.0.0:8080/ で待っています

8080番を開けていないので、先に開けます。別のターミナルで:

bash
$ sudo ufw allow 8080/tcp
$ sudo ufw status

ホストのブラウザで http://192.168.226.50:8080/ を開いてください(IPは自分のVMの値に。VMの中で ip a)。

「Go が返しています」と出ます。 ターミナルにはアクセスのたびに行が増えます。

なぜ 8080 なのか。 サーバーとは何かの回の Node.js が 3000 を掴んでいるので、同じ番号にすると EADDRINUSE になります。 ポートは1つのプロセスしか掴めない、という決まりは言語とは無関係です。これが「言語の性質ではない」ものの1つ目です。

[スクリーンショット: 03_go_hello.png] 左にVMのターミナル(go run main.go のログ)、右にホストのブラウザ(「Go が返しています」が表示されている)を並べて撮ってください。

行ごとに並べる

ここが、この記事の中心です。

やることNode.jsGo
① ポートを掴むserver.listen(3000, "0.0.0.0", ...)http.ListenAndServe("0.0.0.0:8080", nil)
② 待つlisten した後、プログラムが終了しないことListenAndServe から戻ってこないこと
③ 受けるcreateServer((req, res) => { ... })http.HandleFunc("/", func(w, r) { ... })
④ 返すres.writeHead(...) / res.end(...)w.Header().Set(...) / fmt.Fprint(w, ...)
ヘッダーと本文の空行ライブラリが入れるライブラリが入れる
Content-Length の計算ライブラリがやるライブラリがやる
404 を出す自分で writeHead(404, ...)自分で http.NotFound(w, r)

左と右で、書き方は全部違います。 そして、列の左端(やること)は1つも変わっていません。

サーバーとは何かの回で「サーバーがやっているのは4つだけ」と書きました。 あれは Node.js の話ではありませんでした。 言語が変わっても、掴む・待つ・受ける・返すは、そのままそこにあります。 nc で手打ちしたときも同じでした。 変わっているのは書き方だけです。

③ 驚いた順に、違いを並べる

ここからは、書いていて「え」と思った順に並べます。

1. コンパイルする — 実行ファイルが1つできる

さっきは go run で動かしました。これは「コンパイルして、すぐ実行して、結果を捨てる」という便利コマンドです。

結果を捨てずに、残します。

bash
$ cd ~/go-server
$ go build -o taskserver
$ ls -lh
合計 7.4M
-rw-rw-r-- 1 user user   28 Sep  9 14:10 go.mod
-rw-rw-r-- 1 user user  431 Sep  9 14:05 main.go
-rwxr-xr-x 1 user user 7.3M Sep  9 14:10 taskserver

taskserver という7MBほどのファイルが1つできました。

bash
$ ./taskserver

動きます。 go も main.go も、ここでは何も見ていません。

これが Node.js との、一番目に見える違いです。

配るもの相手の環境に必要なもの
Node.jsserver.js + package.json + npm install の結果Node.js 本体(同じ系統のバージョン)
Gotaskserver 1ファイル何も要りません

この「何も要りません」を、実際に確かめます。 ここがこの記事の山場です。

2. Node.js が見えない状態で動かす

まず、いま node が見えていることを確認します。

bash
$ which node
$ node -v
/home/user/.nvm/versions/node/v22.14.0/bin/node
v22.14.0

次に、PATH をまっさらにして、同じことをやります。

bash
$ env -i PATH=/usr/bin:/bin node -v
env: 'node': No such file or directory

node が消えました。

部分意味
env -i環境変数を全部捨ててコマンドを実行する。PATH も HOME も無くなります
PATH=/usr/bin:/binそのうえで、Ubuntu標準の場所だけを PATH に入れ直す

nvm で入れた node はホームディレクトリの下にあるので、この PATH からは見えません。 サーバーとは何かの回で systemd が nvm の node を見つけられなかったのと、まったく同じ状況を手で作っています。

同じ状態で Node.js のサーバーを動かそうとすると、当然こうなります。

bash
$ env -i PATH=/usr/bin:/bin node ~/server/server.js
env: 'node': No such file or directory

では、Go のほうを同じ条件で動かします。

bash
$ env -i PATH=/usr/bin:/bin ~/go-server/taskserver
2026/09/09 14:15:33 http://0.0.0.0:8080/ で待っています

動きます。 ブラウザで開いても、いつもどおり返ってきます。

go も入っていない状態でも同じです。

bash
$ env -i PATH=/usr/bin:/bin go version
env: 'go': No such file or directory

Go 自体が見えなくても、Go で作った実行ファイルは動きます。 中に全部入っているからです。

[スクリーンショット: 04_env_i_で動く.png] env -i PATH=/usr/bin:/bin node -v が No such file or directory になり、その直後に env -i PATH=/usr/bin:/bin ~/go-server/taskserver が起動している、同じターミナルの連続した画面を撮ってください。

3. ldd で「何にも依存していない」を見る

「中に全部入っている」を、道具で確かめます。

まず、比較のために node 本体を見ます。

bash
$ ldd "$(which node)"
	linux-vdso.so.1 (0x00007ffd...)
	libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f...)
	libstdc++.so.6 => /lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007f...)
	libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f...)
	libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f...)
	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f...)

node は、起動時にこれだけの共有ライブラリを外から読んでいます。 どれか1つでも無い環境では起動しません。

Go のほうを見ます。

bash
$ ldd ~/go-server/taskserver
	linux-vdso.so.1 (0x00007ffd...)
	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f...)

ここは環境によって結果が変わります。 libc が出た人は、完全に切り離した形でビルドし直せます。

bash
$ cd ~/go-server
$ CGO_ENABLED=0 go build -o taskserver
$ ldd taskserver
	not a dynamic executable

「動的な実行ファイルではない」=外から読むものが何も無い、という意味です。これが静的リンクです。

指定意味
CGO_ENABLED=0C言語の部品を混ぜないでビルドする。混ざると、その部分が外部ライブラリ頼みになります

ldd は「実行ファイルではない」と怒ることもあります。 not a dynamic executable はエラーではなく、期待どおりの答えです。混同しないでください。

大きさも並べておきます。

bash
$ ls -lh ~/go-server/taskserver
$ ls -lh "$(which node)"
$ du -sh ~/server
-rwxr-xr-x 1 user user 7.0M Sep  9 14:20 /home/user/go-server/taskserver
-rwxr-xr-x 1 user user 111M Feb 12  2026 /home/user/.nvm/versions/node/v22.14.0/bin/node
2.1M	/home/user/server

7MB と 111MB です。 しかも右側は、そこに ~/server のソースと node_modules を足した合計が必要です。

[スクリーンショット: 05_ldd_とサイズ.png] ldd taskserver が not a dynamic executable と返っている行と、ls -lh で両方のサイズが並んでいる部分を撮ってください。

4. これが、Dockerイメージが小さくなる理由

Docker の回で、イメージの大きさを見ました。 その話に繋がります。

コンテナのイメージには、「そのプログラムを動かすのに必要なもの」を全部入れます。

何で書いたかイメージに入れる必要があるものだいたいの大きさ
Node.jsNode.js 本体 + Linuxの土台 + ソース + node_modules数百MB(軽い土台を選んでも100MB台)
Go実行ファイル1つだけ(土台すら不要にできる)10MB前後

Go 側で「土台すら不要」と書けるのは、いま ldd で確かめたからです。外から読むものが何も無いなら、OSのファイルを1つも入れなくても動きます。

この差は、そのまま運用に効きます。

– 転送が速い。 CI/CD の回で毎回イメージを作って配ることを考えると、桁が違います – 起動が速い。 Kubernetes の回で Pod が別のノードに移るとき、イメージを取り直します – 攻撃される面が小さい。 セキュリティの回で書いた「余計なものを置かない」そのものです。シェルすら入っていないイメージが作れます

「Goはインフラ系のツールでよく使われる」と言われる理由の、かなりの部分がこれです。Docker も Kubernetes も、Go で書かれています。

5. 型を必ず書く — 後から足すものではない

TypeScript の回で、型は「後から足すもの」でした。 Go では違います。

さっきの func(w http.ResponseWriter, r *http.Request) を見てください。 w と r の型が、最初から書いてあります。 書かない選択肢がありません。

そして、ここが TypeScript との決定的な差です。

型は、いつ消えるか
TypeScripttsc が消す。 実行時には1文字も残らない(TypeScriptの回)
Go消えない。 コンパイル結果そのものが、型を前提に組み立てられている

どちらが良いという話ではありません。 TypeScript の型は 「書いている最中に教えてくれる注釈」 で、動くコードは JavaScript のままです。だからAPIから返ってきたJSONの中身は保証されません。 Go の型は 言語そのものです。そのぶん、書かないと1行も動きません。

もう1つ、書いていて必ず踏むのがこれです。

	// import に "os" を足して、使わないまま go build すると
./main.go:6:2: "os" imported and not used

使っていないインポートは、警告ではなくエラーです。 変数も同じです。

./main.go:12:2: declared and not used: unused

JavaScript なら、ESLintを入れて初めて「使ってないよ」と言われます。 そして言われても動きます。 Go は言語が拒否します。 「動くけど汚い状態」を作らせない、という設計です。最初はかなり鬱陶しく感じます。

6. エラーを、返り値で受け取る — 例外が無い

これが、たぶん一番驚きます。

JavaScript ではこう書いていました。

try {
  const data = fs.readFileSync("ないファイル.txt", "utf8");
  console.log(data);
} catch (err) {
  console.error("読めませんでした:", err.message);
}

Go ではこうです。

	data, err := os.ReadFile("ないファイル.txt")
	if err != nil {
		log.Printf("読めませんでした: %v", err)
		return
	}
	log.Println(string(data))
行意味
data, err := ...返り値が2つ返ってくる。1つ目が結果、2つ目がエラー。これがGoの決まりごとです
:=新しい変数を作って、そこに入れる。 型は右側から自動で決まります(const / let にあたります)
if err != nilnil は「何も無い」。 null にあたります。エラーが入っていたら、という意味
%v中身をそのまま文字にして埋める指定

Go には try / catch がありません。

つまり、こうです。

JavaScript: エラーは勝手に飛んでくる。捕まえ忘れると、上へ上へ突き抜けてプロセスが落ちる Go: エラーは普通の返り値。受け取って変数に入れたなら、使わないとコンパイルが通らない(_ で捨てることはできる)

非同期処理の回で「await を try / catch で囲み忘れると UnhandledPromiseRejection で落ちる」と書きました。Go には、その事故の形自体がありません。 代わりに、if err != nil が延々と並びます。

どちらもトレードオフです。 「Goはエラー処理が冗長」と言われるのは、この見た目のことです。

7. go fmt — 書き方が1つに決まる

わざと汚く書きます。 main.go の func main() { の直後の行を、こうしてみてください。

	x:=1+2
    log.Println( x )

タブとスペースが混ざっていて、演算子の周りも詰まっています。 そのうえで:

bash
$ cd ~/go-server
$ gofmt -l .
main.go

-l は「整形されていないファイルの名前だけ出す」指定です。直させます。

bash
$ go fmt ./...
$ cat main.go

インデントはタブに揃えられ、x := 1 + 2 に直っています。

部分意味
./...このフォルダ以下、全部という書き方(Go独特です)
go fmt中で gofmt -w(書き換える)を呼んでいます

ESLint と Prettier の回で、設定ファイルを書いて、好みを決めました。 Go には、その議論がありません。 gofmt の出力が唯一の正解で、設定項目がほぼ存在しません(インデントをスペースにする、もできません)。 「どちらが良いか」ではなく、「決める作業自体を無くした」という設計です。他人のGoのコードが読みやすいのは、これが理由です。

確認したら、いま足した2行は消しておいてください。

8. 並行処理が言語に入っている

深入りしません。 存在だけ知っておけば十分です。

	go なにかの関数()

行の頭に go と書くだけで、その処理が別に動き出します。 これが goroutine です。

そして、実は既に使っています。

http.ListenAndServe は、リクエストが来るたびに、その処理を goroutine で走らせています。 自分では1行も書いていないのに、複数のリクエストが同時に処理されています。

同時に来たリクエストを、どう捌くか
Node.js1本の流れで回す。 待ち時間(DBやファイル)の間に他を進める(非同期処理の回の await はこのための仕組み)
Goリクエストごとに goroutine。 それぞれが上から下へ普通に書ける

だから Go のコードには await が出てきません。 非同期処理の回で苦労した「なぜ await が要るのか」は、JavaScript の事情でした。これも「言語の性質」だったわけです。

ここから先(チャネル、sync、競合状態)は、この記事では扱いません。 並行処理は、それだけで1冊になる分野です。 いま必要なのは「await は世界共通ではない」と知ることだけです。

④ 同じ /api/tasks を返す

最後に、APIの回と同じものを返します。

比較対象は、これでした。

let tasks = [
  { id: 1, title: "Linuxのコマンドを覚える", done: true },
  { id: 2, title: "サーバーを立てる", done: true },
  { id: 3, title: "APIを作る", done: false },
];

// GET /api/tasks
res.writeHead(200, { "Content-Type": "application/json; charset=UTF-8" });
res.end(JSON.stringify(tasks));

main.go を、こう書き換えます。

package main

import (
	"encoding/json"
	"log"
	"net/http"
)

type Task struct {
	ID    int    `json:"id"`
	Title string `json:"title"`
	Done  bool   `json:"done"`
}

var tasks = []Task{
	{ID: 1, Title: "Linuxのコマンドを覚える", Done: true},
	{ID: 2, Title: "サーバーを立てる", Done: true},
	{ID: 3, Title: "APIを作る", Done: false},
}

func main() {
	http.HandleFunc("/api/tasks", func(w http.ResponseWriter, r *http.Request) {
		log.Printf("%s %s", r.Method, r.URL.Path)

		if r.Method != http.MethodGet {
			http.Error(w, `{"error":"method not allowed"}`, http.StatusMethodNotAllowed)
			return
		}

		w.Header().Set("Content-Type", "application/json; charset=UTF-8")

		if err := json.NewEncoder(w).Encode(tasks); err != nil {
			log.Printf("書き込みに失敗しました: %v", err)
		}
	})

	log.Println("http://0.0.0.0:8080/api/tasks で待っています")
	log.Fatal(http.ListenAndServe("0.0.0.0:8080", nil))
}

新しく出てきたところだけ説明します。

行意味
type Task struct { ... }「タスクとはこういう形だ」という型を、自分で定義している。 JavaScript の { id: 1, title: "..." } はその場で好きな形を作れましたが、Goは先に形を決めます
ID intフィールド名と、その型。 int は整数、string は文字列、bool は true/false
大文字始まり(ID / Title)Go では、大文字で始まる名前だけが外部から見えます。 小文字にすると JSON に出てきません(これは必ず1回踏みます)
json:"id" のタグJSONにするときの名前の指定。 これが無いと {"ID":1,"Title":...} と大文字で出ます
var tasks = []Task{...}[]Task は「Task の並び」という型。中身の型が決まっている配列です
r.Method != http.MethodGetGET以外は断る。 REST APIの回で書いた 405 を返します
json.NewEncoder(w).Encode(tasks)tasks をJSONにして、w に直接書き込む。 res.end(JSON.stringify(tasks)) にあたります
if err := ...; err != nil実行して、その返り値の err をその場で調べる書き方。Goで頻出します

動かして、叩きます。

bash
$ cd ~/go-server
$ go run main.go

別のターミナルで:

bash
$ curl -s http://localhost:8080/api/tasks | jq
[
  {
    "id": 1,
    "title": "Linuxのコマンドを覚える",
    "done": true
  },
  {
    "id": 2,
    "title": "サーバーを立てる",
    "done": true
  },
  {
    "id": 3,
    "title": "APIを作る",
    "done": false
  }
]

APIの回の Node.js が返したものと、1文字も変わりません。

両方を同時に動かして、並べてみてください。

bash
$ curl -s http://localhost:3000/api/tasks | jq -S . > /tmp/node.json
$ curl -s http://localhost:8080/api/tasks | jq -S . > /tmp/go.json
$ diff /tmp/node.json /tmp/go.json && echo "完全に同じです"
完全に同じです

3000番の Node.js 側も動かしておく必要があります。 止めている人は cd ~/server && node server.js で立ててください。jq -S はキーの順番を揃える指定です。 diff が何も出さない、というのがこの記事の結論です。受け取る側から見れば、どちらの言語で書いたかは分かりません。

[スクリーンショット: 06_同じJSONが返る.png] curl で 3000番(Node.js)と 8080番(Go)を叩き、同じJSONが返っている画面を撮ってください。diff の結果まで入っていると、なお良いです。

データベースには繋いでいません。 MySQLの回と同じことは Go でもできますが(database/sql という標準の窓口があります)、この記事の目的は「同じものを2つの言語で並べる」ことなので、そこは足しません。 ここまでで、比較には十分です。

⑤ で、どちらを使うべきか

この質問の立て方が、そもそも間違っています。

言語は目的で選ぶ道具です。 「速い言語」「良い言語」というランキングは存在しません。

この記事で見た違いを、そのまま長所と短所に読み替えます。

Go が向いていることNode.js が向いていること
配りやすさ実行ファイル1つ。 CLIツール、コンテナ、常駐プロセス—
フロントとの共通化—同じ JavaScript で書ける。 型も TypeScript で共有できる
ライブラリの量標準ライブラリが厚い。外部は少なめnpm に何でもある(npm の回)
書く速さ型と if err != nil のぶん、行数は増える少ない行数で形になる
間違いに気づく時期コンパイル時(動かす前)実行時(TypeScriptを入れれば書いている最中)
人の入れ替わりgofmt で書き方が揃う。読みやすい設定と流儀が分かれる

そして、このサイトの方針をはっきり書きます。

このサイトは、引き続き Node.js で進めます。

理由は「Node.js のほうが優れているから」ではありません。フロントエンドを JavaScript で書いてきたので、同じ言語のままのほうが、学ぶことが1つ減るからです。それだけです。

この記事の Go は、ここで役目を終えます。 消しても構いません。残しても害はありません。

1つだけ、持ち帰ってほしいことがあります。

これから何かの記事を読んで「〜するのが普通です」と書いてあったら、「誰にとって普通なのか」を1回疑ってください。 その多くは、その言語の中でだけ普通です。 それが分かるようになったこと自体が、この記事の成果です。

つまずいたところ

症状原因
go: command not found(展開はできている)PATH に /usr/local/go/bin が無い。 source ~/.profile を忘れている、または ~/.profile に書けていない
ログインし直したら、また command not foundexport PATH=... をターミナルで打っただけで、~/.profile に書いていない
落としたtar.gzが数KBしかないcurl に -L を付けていない。 転送先を追わずに、案内ページを保存している
go: cannot find main modulego mod init をしていないフォルダで go run / go build している
"os" imported and not used使っていないインポートは、Goではエラー。 消す
declared and not used使っていない変数も、Goではエラー。 消すか、使う
JSONが {"ID":1,"Title":...} と大文字で返るjson:"id" のタグを書いていない
JSONにフィールドが出てこないフィールド名が小文字始まりになっている(title ではなく Title)
bind: address already in use8080番を別のプロセスが掴んでいる。 sudo ss -tlnp で犯人を探す(サーバーとは何かの回と同じ)
ブラウザから見えないが curl localhost は通るufw で 8080 を開けていない、または ListenAndServe が 127.0.0.1:8080 になっている
ldd が not a dynamic executable と返るエラーではありません。 期待どおりの結果です

後片づけ

Go を残す場合、ダウンロードした箱だけ消せます。

bash
$ rm ~/go${GOVER}.linux-amd64.tar.gz

Go ごと消す場合はこうします。

bash
$ sudo rm -rf /usr/local/go
$ rm -rf ~/go-server

~/.profile に足した行も消してください。

bash
$ nano ~/.profile

最終行の export PATH=$PATH:/usr/local/go/bin を消して保存します。

開けたポートを閉じます。

bash
$ sudo ufw delete allow 8080/tcp
$ sudo ufw status

~/server/ は残してください。 このサイトの本編は、引き続きそちらで進みます。

まとめ

  • 1つの言語しか知らないと、「言語の性質」と「プログラミング一般」の区別が付かない。 2つ目を触るのは、そこに線を引くため
  • サーバーがやっていることは、言語が変わっても同じ。 掴む・待つ・受ける・返す は、Go でも同じ場所にある
  • apt の Go は古いことがある。 言語そのものは公式の配布物から入れて、PATH を自分で通す
  • go build で実行ファイルが1つできる。 go も node も見えない PATH で、そのまま起動する
  • ldd が not a dynamic executable と返るのが、その証拠。 外から読むものが何も無い
  • Dockerイメージが小さくなるのは、これが理由。 土台のOSごと不要にできる
  • 型は後から足すものとは限らない。 そして Go の型はコンパイル後も消えない(TypeScript は消える)
  • エラーは投げられるとは限らない。 Go は普通の返り値で返す。try / catch は世界の決まりではない
  • 使っていない変数とインポートは、警告ではなくエラー。 「動くけど汚い」を作らせない設計
  • gofmt に設定項目はほぼ無い。 書き方を議論する作業自体が無くなっている
  • await は JavaScript の事情。 Go はリクエストごとに goroutine が走るので、上から下へ普通に書ける
  • 同じ /api/tasks を返せば、diff は何も出さない。 受け取る側から、どちらで書いたかは分からない
  • 言語は目的で選ぶ道具。 優劣ではない。このサイトは引き続き Node.js で進めます

参考リンク


次に読む

この記事は 【第5段階】バックエンドとデータベース の 27 / 29 本目です。

記事
← 前の記事部分一致は索引が効かない — 全文検索とMeilisearch
→ 次の記事GitとGitHubは別物 — VMのコードを初めて上げる

上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。

全体の順路は はじめに にあります。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次