我們用同一份 JavaScript 檔案,在同一臺機器上,讓 QuickJS 跑了一遍 fib(25),只是每次換一個宿主語言(C 直接連結,其餘三個是各語言的繫結):
C quickjs-ng 0.17 7.2 msRust rquickjs 0.14 7.6 msGo fastschema/qjs 22.8 msJava quickjs4j 0.1.1 60.6 ms再讓宿主調 20 萬次指令碼里的 function add(a, b) { return a + b },每次呼叫的平均耗時差得更遠:C 是 21 納秒,Go 的 buke/quickjs-go 預設配置下是 34274 納秒。
QuickJS 是一個 C 寫的引擎,這幾次跑的 JavaScript 一個字都沒變,按理說宿主只是“把它裝進來”。那慢出來的時間是誰花掉的?是 Go、Java 這些語言本身慢,還是裝進來的方式不同?如果要在自己的程式裡嵌一個 QuickJS,選哪門語言、哪個繫結最合適?
我們先弄清楚 QuickJS 是什麼、它是怎樣被裝進別的語言裡的,再一項一項把這些差距拆開。
一、QuickJS 是什麼
一個能整個塞進別的程式裡的引擎
QuickJS 是 Fabrice Bellard(FFmpeg、QEMU 的作者)和 Charlie Gordon 寫的 JavaScript 引擎,2019 年 7 月第一次釋出1。它的目標不是和 V8 比峰值速度,而是小、能嵌進去:幾個 C 檔案,沒有外部依賴,一個 hello world 編出來只有 367 KiB 的 x86 程式碼;一個執行時例項從建立到銷燬不到 300 微秒;語言上支援到 ES20251。
小是靠取捨換來的。它沒有 JIT,原始碼進來之後只走一條很短的路:
這張圖裡有兩件事和後文直接相關。第一,JS 跑得快不快,全看這個 C 寫的直譯器迴圈被編譯成了什麼樣的機器碼。 它不會在執行中生成新程式碼,所以宿主語言既幫不上忙,也拖不了後腿,除非宿主改變了“這段 C 怎樣變成機器碼”。第二,宿主和引擎之間的每一次往來都是一個 C 函式呼叫:建一個數字要 JS_NewInt32,調函式要 JS_Call,用完要 JS_FreeValue。宿主語言呼叫 C 的代價,會乘上這些呼叫的次數。
兩個分支,很多個版本
同一個名字下面其實有兩份程式碼。 Bellard 在 2021 年 3 月釋出一版之後,將近三年沒有新版本。2023 年,Ben Noordhuis 和 Saúl Ibarra Corretgé 分叉出 quickjs-ng,按自己的節奏發版2;2024 年 1 月 Bellard 又恢復了釋出,此後兩邊各走各的3。各語言的繫結打包的是哪一邊、哪一版,全憑作者什麼時候更新過:
版本之間的差距並不小。Bellard 在 2026-06-04 版的釋出說明裡寫的是“在 bench-v8 上比上一版快 42%”1;我們在本機用官方的 bench-v84 跑了一下兩個分支的最新版,Bellard 2026-06-04 得 1333 分,quickjs-ng 0.17 得 1131 分。後面比較宿主時,這是一個必須先剝離的變數。
那麼,同一份 C 程式碼是怎麼進到 Go、Python、Java 這些語言裡的?
二、同一份 C 程式碼進入宿主的三條路
三條路
一個 C 庫要被別的語言用,只有三種辦法:把它編譯成本機機器碼直接連結進去,把它編譯成一種可移植的中間格式再由宿主執行,或者把 C 原始碼翻譯成宿主語言的原始碼。QuickJS 的各個繫結三種都有:
第一條路,執行的是 C 編譯器生成的機器碼,和 C 程式自己用沒有區別;代價在“跨語言呼叫”這一步,每種語言調 C 的機制(Go 的 cgo、Python 的擴充套件 API、Rust 的 FFI)各有開銷。第二條路,執行的是宿主的 WASM 引擎再生成的機器碼,好處是不需要 C 工具鏈、天然隔離,代價是 WASM 引擎的程式碼質量通常不如 GCC,而且每次進出 WASM 都要轉換引數。第三條路是 Go 特有的:ccgo 把 C 逐句翻譯成 Go,不用 cgo 也不用 WASM,但 C 裡的指標運算、malloc 都要由一個用 Go 寫的 libc(modernc.org/libc)來模擬。
被測的宿主
按這三條路,我們把各語言裡常見的 QuickJS 繫結都找了出來。Go 是我們的主力語言,所以 Go 的四種都測:cgo 的 buke/quickjs-go5、wazero 的 fastschema/qjs6、ccgo 翻譯的 modernc.org/quickjs7,再加一個我們自己寫的最薄 cgo 封裝;另外加一個不是 QuickJS 的 goja8 當對照。其他語言是 Rust 的 rquickjs9、Python 的兩個 C 擴充套件1011、Node 的 quickjs-emscripten12 和 Java 的 quickjs4j13:
| 宿主 | 繫結 | 引擎 | 路 |
|---|---|---|---|
| C | 直接連結 | ng 0.17 / Bellard 2026-06-04 | ① 原生 |
| Rust | rquickjs 0.14.0 | ng 0.16.2 | |
| Go | |||
| Go · buke | buke/quickjs-go v0.7.7 | ng 0.15.1 | ① cgo |
| Go · 自寫 | 本文寫的最薄 cgo 封裝 | ng 0.17 | |
| Go · fastschema | fastschema/qjs v0.0.6 | ng 0.10.1 | ② wazero |
| Go · modernc | modernc.org/quickjs v0.27.0 | Bellard 2026-06-04 | ③ ccgo |
| Go · goja | dop251/goja | 純 Go 引擎,不是 QuickJS | 對照 |
| 其他語言 | |||
| Python | quickjs 1.19.4 | Bellard 2021-03-27 | ① C 擴充套件 |
| Python | quickjs-ng 0.17.0.2 | ng 0.17.0 | |
| Node | quickjs-emscripten 0.32.0 | Bellard 2025-09-13 / ng 0.12.1 | ② V8 |
| Java | quickjs4j 0.1.1 | Javy(rquickjs) | ② JVM |
| Node | V8 自己 | JIT,不是 QuickJS | 對照 |
機器:4 vCPU 的 Intel Xeon 2.1 GHz 雲主機,GCC 13.3、Go 1.26、Rust 1.97、Python 3.13、Node 22、JDK 21。
所有宿主跑的是同一份 bench.js,裡面有三類純計算負載(fib(25)、5000 個物件的 JSON 序列化加排序、5000 行文字的正則和字串處理)、兩個用來測邊界的函式,以及一條讀 JSON 的業務規則。每個宿主跑 3 輪取中位數。
先看最基礎的問題:QuickJS 的直譯器本身,在不同宿主裡跑得一樣快嗎?
三、直譯器本身的速度
現象:從 0.8 倍到 12 倍
把三個純計算負載的耗時取幾何平均,以“C 直接連結 quickjs-ng 0.17”為 1 倍:
圖上的條形分成了明顯的幾組。直接連結 C 的宿主(強調色)都在 0.8 到 1.5 倍之間;走 WASM 或翻譯成 Go 的在 1.6 到 3.6 倍;JVM 上的 quickjs4j 是 12 倍。V8 自己跑同樣的指令碼只要 0.19 倍,那是 JIT 的功勞,不在本文的比較範圍裡。
原生這一組:差別來自引擎版本和編譯器
同屬第一條路,為什麼還有 0.83 倍和 1.46 倍之分? 按宿主語言去解釋是解釋不通的:Go 的 buke 比自寫的 cgo 封裝慢,Python 的兩個擴充套件一個慢在 JSON、一個慢在 fib。把它們打包的引擎單獨拿出來、用 C 重新編一遍,答案就出來了:
| 引擎 · 宿主 · 編譯方式 | fib ms | JSON ms | 字串 ms |
|---|---|---|---|
| ng 0.17,GCC 13 -O2 | |||
| C | 7.2 | 21.6 | 8.0 |
| Go 自寫 cgo | 7.5 | 24.0 | 8.3 |
| Rust rquickjs(ng 0.16.2,-O3) | 7.6 | 23.7 | 8.2 |
| Python,本機從 sdist 編譯 | 7.2–7.7 | 23.3–25.2 | 8.2–8.4 |
| ng 0.15.1(buke 打包的版本) | |||
| Go buke | 7.6 | 35.7 | 11.3 |
| C,同一份 0.15.1 原始碼 | 7.4 | 32.9 | 10.2 |
| 其他 | |||
| Python quickjs(Bellard 2021-03-27) | 6.7 | 32.9 | 12.0 |
| Python quickjs-ng(PyPI wheel,GCC 14.2) | 17.9 | 23.7 | 9.1 |
| C,Bellard 2026-06-04 | 6.0 | 17.3 | 6.9 |
Python 的“本機編譯”是用 pip 的 --no-binary 從同一個 0.17.0.2 原始碼包裝的,兩次執行的範圍。
buke 的 JSON 慢,是 0.15.1 慢。 把 buke 打包的那份 0.15.1 原始碼拿出來用 C 編,JSON 一樣是 33 毫秒;換成 0.17,Go 裡也是 24 毫秒。
Python quickjs-ng 的 fib 慢,是 PyPI 上那個預編譯包慢。 同一個 0.17.0.2 的原始碼包,在本機用 GCC 13 編出來,fib 回到 7 毫秒左右;PyPI 上的 manylinux wheel 是 GCC 14.2 編的,fib 要 17.9 毫秒。Bellard 在 2026 年 6 月修過一個“新版 GCC 下效能大幅退化”的問題14,原因是值型別 JSValue 裡一個只初始化了一半的 union 讓新 GCC 生成了更慢的程式碼。ng 0.17 已經帶了同樣的寫法,所以 wheel 慢的具體原因我們沒有完全確認,這裡只能推斷是編譯器版本或編譯引數的問題;能確認的是,換宿主語言不會讓它變快,換個編譯方式會。
Python quickjs 的 JSON 慢,是因為它打包的還是 2021 年的引擎。 它的 fib 不慢,說明 2021 年版的直譯器核心並不差,慢在後來幾年才最佳化的 JSON 和字串處理。
所以第一條路上的結論很乾脆:只要 C 程式碼是被編進來的,JS 執行速度就和宿主語言無關,只和“哪一版引擎、用什麼編譯器編”有關。 選繫結時,先看它打包的是什麼版本。
其他幾條路:執行方式決定量級
第二、三條路就不一樣了,執行的已經不是 GCC 生成的機器碼:
- V8 跑 WASM(Node)約 1.6 倍。 V8 的 WASM 編譯器很成熟,兩個變體之間的差距(1.57 和 2.27 倍)主要還是引擎版本:一個是 Bellard 2025-09,一個是 ng 0.12.1。
- wazero 跑 WASM(Go)約 3.6 倍。 wazero 是純 Go 寫的 WASM 執行時,它的編譯器後端比 V8 的簡單得多;fastschema 打包的 ng 0.10.1 也比較老。
- ccgo 翻譯成 Go 約 2.4 倍。 翻譯出的 Go 程式碼要經過 Go 編譯器,所有記憶體操作都走 modernc 的 libc 模擬層。
- JVM 約 12 倍。 quickjs4j 把 WASM 在構建期翻譯成 JVM 位元組碼,翻譯出來的方法非常大,HotSpot 預設不編譯超過 8000 位元組碼的方法;不加
-XX:-DontCompileHugeMethods,fib 要 513 毫秒,加上也還有 61 毫秒。
goja 不是 QuickJS,但它是 Go 裡最常見的替代品,3.55 倍和 wazero、modernc 在同一個量級。
到這裡還只解釋了開頭那組數字裡的一半:fib 慢 3 倍可以歸給 WASM,可同樣是 cgo,buke 調一次 add 要 34 微秒,比 C 慢了 1600 倍,又是為什麼?
四、跨邊界呼叫的代價
現象:一次 add 從 17 納秒到 34 微秒
嵌入指令碼的程式很少只讓 JS 悶頭算。更常見的是宿主一次次調 JS 函式(每來一個請求跑一次規則),或者 JS 一次次回撥宿主提供的函式(查一下配置、讀一個欄位)。我們測了三個量:宿主調 20 萬次 add(acc, 1);JS 裡迴圈 20 萬次調宿主註冊的 hostAdd;以及宿主把一段 JSON 字串傳進去、讓 JS 解析後判斷一條規則,跑 5 萬次。
| 宿主 | 宿主調 JS | JS 調宿主 | 一條 JSON 規則 |
|---|---|---|---|
| C · Bellard 2026-06 | 17 ns | 34 ns | 3.4 µs |
| C · ng 0.17 | 21 ns | 44 ns | 4.0 µs |
| Rust · rquickjs | 82 ns | 113 ns | 4.4 µs |
| Go · 自寫 cgo | 89 ns | 79 ns | 4.2 µs |
| Python · quickjs | 138 ns | 148 ns | 7.0 µs |
| Python · quickjs-ng | 163 ns | 209 ns | 4.3 µs |
| Go · modernc | 294 ns | 625 ns | 12.4 µs |
| Go · goja(對照) | 329 ns | 777 ns | 26.1 µs |
| Go · buke 關掉檢查 | 730 ns | 466 ns | 10.0 µs |
| Node · emscripten | 1.6 µs | 3.3 µs | 14.6 µs |
| Java · quickjs4j | — | 17.6 µs | — |
| Go · fastschema(wazero) | 29.9 µs | 31.1 µs | 49.8 µs |
| Go · buke 預設 | 34.3 µs | 10.9 µs | 36.2 µs |
“JS 調宿主”包含 JS 自己迴圈一次的開銷(C 里約 43 ns)。quickjs4j 只能透過 JSON 序列化呼叫 JS 函式,沒有測宿主調 JS。
這張表的排序和圖 5 很不一樣。buke 在純計算上和 C 一樣快,在邊界上卻是最慢的;Python 的計算不算快,邊界卻只比 Rust 慢一點。邊界開銷顯然另有來源。
原因一:buke 每個 API 都在查“我是不是在原來那個 goroutine 上”
用 pprof 看 buke 調 add 的過程,94% 的時間花在一個叫 currentGoroutineID 的函式里,它呼叫 runtime.Stack 把當前 goroutine 的棧列印成文字,再從文字里解析出 goroutine 編號。buke 在 Runtime、Context、Value 的幾乎每個方法前都做這個“屬主檢查”,防止別的 goroutine 併發訪問同一個執行時5。一次 add 要建兩個數、調一次、取結果、釋放三個值,一共約十次檢查,每次約 3 微秒。
buke 提供了 WithOwnerGoroutineCheck(false) 關掉這個檢查,代價是呼叫方自己保證一個執行時只在一個 goroutine 上用5。關掉之後一次 add 是 730 納秒,剩下的就是約十次 cgo 呼叫本身,每次 50 到 70 納秒。
原因二:cgo 一次往返本身多貴
cgo 每次呼叫要在 Go 的排程器上登記“這個執行緒進 C 了”,出來時再登記回去,這是它比普通函式呼叫貴的原因。為了看清這筆開銷的下限,我們寫了一個最薄的封裝:Go 只調一次 C 函式 eng_call,建數、呼叫、取結果、釋放全在 C 裡做完。這樣一次 add 是 89 納秒,減去 C 自己的 21 納秒,一次 cgo 往返大約 70 納秒。封裝的核心只有這麼幾行:
/*#include "quickjs.h"typedef struct { JSRuntime *rt; JSContext *ctx; JSValue fn[8]; } eng;
// 一次逻辑调用在 C 里做完:建参数、调用、取结果、释放static int64_t eng_call(eng *e, int f, int argc, int32_t a, int32_t b) { JSValue argv[2] = { JS_NewInt32(e->ctx, a), JS_NewInt32(e->ctx, b) }; JSValue r = JS_Call(e->ctx, e->fn[f], JS_UNDEFINED, argc, argv); int64_t v = 0; JS_ToInt64(e->ctx, &v, r); JS_FreeValue(e->ctx, r); return v;}*/import "C"
func (e *Engine) Call(fn int, a, b int32) int64 { return int64(C.eng_call(e.e, C.int(fn), 2, C.int32_t(a), C.int32_t(b)))}函式控制代碼在建立執行時時就取好存進 fn[],Go 這邊每次只傳一個下標。
反方向也一樣:JS 調一個用 Go 寫的 hostAdd 要 79 納秒,把 hostAdd 換成 C 實現是 42 納秒,C 回撥 Go 大約多出 35 到 40 納秒。
Rust(82 納秒)和 Python(138 到 163 納秒)的數字也在這個量級。Rust 調 C 本身沒有額外開銷,rquickjs 多出來的時間花在它的安全包裝上,比如每次呼叫前都更新一次棧頂(第六節會講為什麼要這麼做)。Python 每次呼叫都要把 Python 的 int 轉成 JSValue、再把結果轉回來,這在 CPython 裡本來就是這個價錢。
原因三:fastschema 每次進 WASM 都查一次函式表
fastschema 的 30 微秒有著類似的來歷。它每次呼叫 WASM 裡的函式,都寫成 m.ExportedFunction("QJS_Call").Call(...),而 wazero 的 ExportedFunction 每次都會新建一個函式例項、分配一塊呼叫棧15。我們繞過 fastschema、直接用 wazero 載入它的 qjs.wasm 做了對比:同一個匯出函式,每次查詢再呼叫是 3075 納秒,查一次快取起來是 32 納秒,差了近 100 倍。一次 add 在 fastschema 裡要進出 WASM 十來次,於是成了 30 微秒。
WASM 的邊界本身並不貴,32 納秒比 cgo 還便宜,因為 wazero 呼叫 WASM 不需要切換到系統棧,也不需要通知排程器。貴的是繫結的寫法。Node 的 quickjs-emscripten 每次呼叫 1.6 微秒則是另一種情況:它的每個引數、返回值都是一個要手動 dispose 的控制代碼物件,一次呼叫要經過好幾次 JS 和 WASM 之間的轉換。
回到業務規則
最後一列“JSON 規則”更接近真實場景:宿主把一個 JSON 字串傳進去,JS 解析、判斷,返回 0 或 1。它本身要做 3 到 4 微秒的事,所以邊界開銷只要在一兩百納秒以內就看不出來:C、Rust、Go 自寫封裝、Python quickjs-ng 都在 4.0 到 4.4 微秒。buke 預設配置下是 36 微秒,fastschema 是 50 微秒,邊界開銷比正事還多十倍。
單次呼叫的成本弄清楚了,下一個問題是:一臺機器上要同時跑很多段指令碼時,又是什麼情況?
五、啟動、記憶體與併發
每來一個請求新建一個執行時,行不行
QuickJS 宣傳的“300 微秒內完成一個執行時的生命週期”,是很多人選它的原因:每個請求一個全新的執行時,指令碼之間互不干擾。我們測了新建執行時和上下文、執行 1+1、銷燬的耗時,以及保持 200 個載入了 bench.js 的例項時平均每個佔多少記憶體:
| 宿主 | 新建一個執行時 | 每個例項記憶體 | 1 / 2 / 4 執行緒吞吐(次/秒) |
|---|---|---|---|
| C · ng 0.17 | 104 µs | 170 KB | — |
| Rust · rquickjs | 106 µs | 182 KB | 119 / 243 / 421 |
| Go · buke 關掉檢查 | 304 µs | 117 KB | 129 / 254 / 496 |
| Go · modernc | 198 µs | 165 KB | 46 / 24 / 21 |
| Go · fastschema(wazero) | 3.4 ms,程序內首次 0.77 s | 660 KB | 33 / 53 / 78 |
| Go · goja(對照) | 11 µs | 35 KB | 34 / 68 / 115 |
| Python · quickjs | 176 µs | 55 KB | 134 / 261 / 459 |
| Python · quickjs-ng | 115 µs | 167 KB | 56 / 108 / 211 |
| Node · emscripten | 209 µs | 54 KB | — |
| Java · quickjs4j | 9.0 ms | — | — |
吞吐:1、2、4 個執行緒(goroutine)各自持有一個執行時,迴圈跑 fib(25),4 vCPU。記憶體是 200 個例項的 RSS 增量平均值,各版本內建物件多少不同,只看量級。
原生的幾種新建一個執行時都在 0.1 到 0.3 毫秒,每個例項一兩百 KB,“一個請求一個執行時”是可行的。表裡有三處需要單獨解釋。
fastschema 程序裡第一次建立執行時要 0.77 秒。 wazero 要先把 1 MB 的 qjs.wasm 編譯成機器碼,這一步在每個程序裡做一次(可以配置磁碟快取),之後每個執行時 3.4 毫秒,因為每個例項都要分配並初始化一塊獨立的 WASM 線性記憶體。對命令列工具、Serverless 這類短命程序,這 0.77 秒很可能比指令碼本身還長。
modernc 執行緒越多越慢。 QuickJS 的執行時是單執行緒的,想用滿多核只能開多個執行時,各跑各的;原生繫結基本能線性擴充套件。modernc 從 1 個 goroutine 的 46 次/秒掉到 4 個的 21 次/秒,原因在它模擬 C 標準庫的 modernc.org/libc:malloc 和 free 共用一把全域性互斥鎖 allocMu,QuickJS 分配又極其頻繁,多個執行時就全卡在這把鎖上。
Python 的兩個擴充套件都能多執行緒擴充套件。 它們在執行 JS 期間釋放了 GIL(Py_BEGIN_ALLOW_THREADS)10,所以多個執行緒各持一個 Context 時真的是並行的。
goja 新建只要 11 微秒,因為它的“執行時”就是普通的 Go 物件,不需要初始化一整套 C 結構;這也是它在 Go 裡的主要優勢。
效能之外,嵌入一個 C 引擎還有一類問題會直接讓程序掛掉,它也和宿主的執行緒模型有關。
六、棧、執行緒與崩潰
現象:沒有遞迴,卻報“棧溢位”
寫自用的 cgo 封裝時,我們第一次跑規則測試,5 萬次裡有 3.6 萬次返回了異常:Maximum call stack size exceeded。規則只是解析一段 JSON,根本沒有遞迴。
原因:QuickJS 記住的是建立時那個執行緒的棧
QuickJS 防止 JS 無限遞迴把 C 棧耗盡的辦法,是在建立執行時時記下當前的棧頂地址,之後每次進入函式都比較“當前棧指標離棧頂有多遠”,超過上限(預設 1 MB)就拋異常。這個辦法預設了一件事:執行時永遠在同一個執行緒、同一塊棧上執行。 在 C 裡這是自然而然的,在 Go 裡卻不是:goroutine 會被排程器換到別的 OS 執行緒上,cgo 呼叫發生在哪個執行緒,取決於這個 goroutine 當時在哪。
兩個地址相差約 0.85 TB,自然“超過了 1 MB 的上限”。解決辦法有兩個:讓持有執行時的 goroutine 調 runtime.LockOSThread() 釘在一個執行緒上;或者像 rquickjs 那樣,每次呼叫前執行一次 JS_UpdateStackTop,按當前執行緒重新記棧頂9。Rust 裡沒有 goroutine 排程,rquickjs 這樣做是為了支援執行時線上程間移動,這也是它的單次呼叫比 C 多出幾十納秒的原因之一。
現成的 Go 繫結怎麼處理:一個關了檢查,一個崩成 panic
那 buke 為什麼沒有這個問題? 因為它預設把棧深上限設成了 0,也就是不檢查5。代價是真的無限遞迴時,沒有人攔著:
| 宿主 | 結果 |
|---|---|
| Go · buke 預設 | SIGSEGV,整個程序退出 |
| Go · buke + WithMaxStackSize(1<<20) | JS 裡拋 RangeError,可以 catch |
| Go · fastschema(wazero) | Go panic:wasm error: out of bounds memory access |
| Go · modernc | JS 裡拋 InternalError: stack overflow |
| Rust · rquickjs、Python 兩個擴充套件 | JS 裡拋異常,可以 catch |
| Node · emscripten | 宿主側拋 RangeError(V8 的棧先滿了) |
指令碼用 try/catch 包住了遞迴,“可以 catch”指指令碼自己能接住,宿主繼續正常執行。
如果指令碼來自使用者,這張表比前面所有效能數字都重要。buke 的預設配置下,一行遞迴就能讓整個服務退出;fastschema 會變成 Go 的 panic,雖然能 recover,但這個執行時的狀態已經不可信,只能丟掉。
到這裡,開頭的幾組數字都找到了出處。最後回答那個問題:嵌在哪裡最好?
七、回到開頭:嵌在哪裡最好
先把開頭的現象逐一對上:
- fib 7.2 和 7.6 毫秒:C 和 Rust 執行的是同一類 GCC 機器碼,差別在引擎小版本和編譯引數。
- fastschema 的 22.8 毫秒、quickjs4j 的 60.6 毫秒:它們執行的不是 GCC 生成的機器碼,而是 wazero 和 JVM 從 WASM 再生成的程式碼,慢在執行方式。
- buke 的 34 微秒一次 add:既不是 Go 慢,也不是 cgo 慢,而是繫結在每個 API 上做了一次
runtime.Stack。
所以“QuickJS 嵌在哪門語言裡表現最好”的答案是:只要走第一條路,把 C 直接編進去,語言本身幾乎不影響 JS 的執行速度;真正拉開差距的是繫結打包的引擎版本、執行方式,以及繫結在邊界上怎麼寫。 只看數字,C 和 Rust 最好,Python 意外地不差(邊界一兩百納秒、執行時釋放 GIL),Node 裡用它只適合需要沙箱的場合,Java 目前的選擇還很慢。
對 Go 來說,選擇取決於能不能接受 cgo:
能用 cgo,就用 cgo:計算速度和 C 一樣,但 buke 的兩個預設值都要改,一個關乎效能(屬主檢查),一個關乎程序會不會被一行指令碼打崩(棧深上限)。如果宿主和 JS 之間來往特別頻繁,自己寫一層薄封裝是值得的,一次往返從 730 納秒降到 89 納秒。
不能用 cgo(要交叉編譯、要靜態二進位制、不想裝 C 工具鏈)時,三個純 Go 方案各有一個硬傷:fastschema 的邊界開銷和首次編譯,modernc 的併發,goja 不是 QuickJS(如果需要和 QuickJS 完全一致的行為,比如同一份指令碼要在 C 端也跑)。附帶一個數字:只執行 1+1 的最小程式,-s -w 編譯後 buke 是 2.9 MB,modernc 5.2 MB,fastschema 6.3 MB,goja 10.6 MB;後三者 CGO_ENABLED=0 交叉編譯到 arm64 都能直接透過,buke 不行。
小結
- QuickJS 是什麼? 一個幾個 C 檔案、無依賴、沒有 JIT 的 JavaScript 引擎:原始碼一遍編譯成位元組碼,由 C 直譯器執行;宿主透過
JS_NewRuntime、JS_Call這些 C 函式和它打交道。Bellard 原版和 quickjs-ng 兩個分支並行發版,各繫結打包的版本橫跨五年。 - 同一份 C 程式碼怎麼進入別的語言? 三條路:編成機器碼直接連結(C、Rust、Go cgo、Python 擴充套件),編成 WASM 由宿主執行(Go wazero、Node、Java),翻譯成 Go 原始碼(modernc)。
- 直譯器速度和宿主語言有關嗎? 走第一條路時無關,差別來自引擎版本(ng 0.15.1 比 0.17 的 JSON 慢 50%,Python quickjs 還是 2021 年的引擎)和編譯器(同一個原始碼包,PyPI wheel 的 fib 慢 2.4 倍)。走 WASM 或翻譯時,慢 1.6 到 12 倍,取決於執行它的虛擬機器。
- 邊界呼叫為什麼能差 400 倍? cgo 往返約 70 納秒、wazero 呼叫約 32 納秒,本身都不貴;buke 的屬主檢查(
runtime.Stack,每次約 3 微秒)和 fastschema 每次ExportedFunction(約 3 微秒)把一次邏輯呼叫變成了 30 多微秒。 - 啟動和併發呢? 原生繫結新建一個執行時 0.1 到 0.3 毫秒,可以一個請求一個;wazero 程序內首次要 0.77 秒;modernc 的 libc 有全域性分配鎖,多 goroutine 反而變慢;Python 擴充套件執行 JS 時釋放 GIL,能多執行緒擴充套件。
- 還有什麼會讓程序掛掉? QuickJS 按建立時的執行緒記棧頂,Go 的 goroutine 換執行緒就會誤報棧溢位,要
LockOSThread或JS_UpdateStackTop;buke 預設關掉棧深檢查,一行無限遞迴就能讓程序段錯誤退出。 - 嵌在哪裡最好? 只看引擎,C 和 Rust 最好,Python 也不差;在 Go 裡優先用 cgo 繫結並改掉兩個預設值,邊界密集時自己封一層;不能用 cgo 時按是否需要併發在 wazero、modernc 和 goja 之間取捨。
參考資料
參考資料
-
QuickJS Javascript Enginebellard.org ↗官網:幾個 C 檔案、無外部依賴,hello world 367 KiB x86 程式碼;執行時例項完整生命週期不到 300 微秒;支援 ES2025;引用計數加環檢測。2026-06-04 版“比上一版在 bench-v8 上快 42%”。https://bellard.org/quickjs/ ↩ ↩2 ↩3
-
quickjs-ng/quickjsgithub.com ↗“a fork of the original QuickJS project … after it went dormant”,維護者 Ben Noordhuis、Saúl Ibarra Corretgé。v0.1.0 釋出於 2023-11-23,文中 C 宿主用 v0.17.0 之後的 main(7a23d8e)。https://github.com/quickjs-ng/quickjs ↩
-
bellard/quickjs:Changeloggithub.com ↗各版本改動。2026-06-04:小塊自定義 malloc(bench-v8 快 11%)、微最佳化(快 30%)。2021-03-27 之後到 2024-01-13 之間沒有釋出。https://github.com/bellard/quickjs/blob/master/Changelog ↩
-
QuickJS extras:tests/bench-v8bellard.org ↗V8 benchmark suite v7 的合併版 combined.js,QuickJS 官網的效能數字就是用它測的。https://bellard.org/quickjs/quickjs-extras-2026-06-04.tar.xz ↩
-
buke/quickjs-gogithub.com ↗cgo 繫結,文中用 v0.7.7,打包 quickjs-ng v0.15.1。
WithOwnerGoroutineCheck、WithMaxStackSize兩個選項見 runtime.go;預設maxStackSize為 0。https://github.com/buke/quickjs-go ↩ ↩2 ↩3 ↩4 -
fastschema/qjsgithub.com ↗把 quickjs-ng 編成 WASM(-O3 + wasm-opt),用 wazero 在 Go 裡跑,不需要 cgo。文中用 v0.0.6,內嵌 qjs.wasm 為 ng 0.10.1。https://github.com/fastschema/qjs ↩
-
modernc.org/quickjsgitlab.com ↗用 ccgo 把 Bellard 版 QuickJS 的 C 原始碼翻譯成 Go。文中用 v0.27.0(libquickjs v0.14.0,對應 2026-06-04 版),linux/amd64 的翻譯結果是一個 19.8 萬行的
ccgo_linux_amd64.go。https://gitlab.com/cznic/quickjs ↩ -
dop251/gojagithub.com ↗純 Go 寫的 ECMAScript 引擎,不是 QuickJS,作為 Go 裡的對照。https://github.com/dop251/goja ↩
-
DelSkayn/rquickjsgithub.com ↗Rust 繫結,文中用 0.14.0,打包 quickjs-ng 0.16.2;每次呼叫前執行
JS_UpdateStackTop(rquickjs-core 的args.rs)。https://github.com/DelSkayn/rquickjs ↩ ↩2 -
PetterS/quickjs(PyPI:quickjs)github.com ↗Python C 擴充套件,文中用 1.19.4;sdist 裡的
upstream-quickjs/VERSION是 2021-03-27。執行 JS 時Py_BEGIN_ALLOW_THREADS釋放 GIL。https://github.com/PetterS/quickjs ↩ ↩2 -
genotrance/quickjs-ng(PyPI:quickjs-ng)github.com ↗PetterS 版的分支,換成 quickjs-ng 0.17.0,文中用 0.17.0.2。PyPI 上的 manylinux wheel 由 GCC 14.2.1 編譯。https://github.com/genotrance/quickjs-ng ↩
-
justjake/quickjs-emscriptengithub.com ↗用 emscripten 編成 WASM,在 Node / 瀏覽器裡跑。文中用 0.32.0 的兩個變體:
@jitl/quickjs-wasmfile-release-sync(Bellard 2025-09-13)和@jitl/quickjs-ng-wasmfile-release-sync(ng 0.12.1)。https://github.com/justjake/quickjs-emscripten ↩ -
roastedroot/quickjs4jgithub.com ↗Java 繫結,文中用 0.1.1:Javy 外掛(內部是 rquickjs)編成 WASM,再在構建期翻譯成 JVM 位元組碼。https://github.com/roastedroot/quickjs4j ↩
-
bellard/quickjs 10c81b1:fixed large performance regression with recent GCC versionsgithub.com ↗
JSValueUnion的int32欄位改成uint64:“avoid uninitialized data by using a 64 bit field even if only 32 bits are needed because some compilers generate slower code”。https://github.com/bellard/quickjs/commit/10c81b1989de2d2e8d482d252b160a34f215d3e2 ↩ -
tetratelabs/wazerogithub.com ↗純 Go 的 WebAssembly 執行時,amd64/arm64 預設用編譯器後端。文中版本 v1.9.0;
Module.ExportedFunction每次呼叫都會新建一個函式例項。https://github.com/tetratelabs/wazero ↩