其他
在 Node.js 中引入 Golang ，会让它更快吗？
大家好，我是 ConardLi，今天我们来看个有意思的话题，在 Node.js 中引入 Golang ，会让服务更快吗？
我们都知道，Nodejs 适合 I/O 密集型任务，但不适合 CPU 密集型任务。同时，我们有很多方式来处理此类任务（子进程/集群、工作线程）。此外，还有可能使用其他语言（C、C++、Rust、Golang）作为单独的服务/微服务或通过 WebAssembly 脚本进行调用。
这篇文章并不是一个 Node.js 和 Golang 的语言对比，而是在 Node.js 开发服务的角度，尝试在某些场景下引入 Golang（让它去执行一些 CPU 密集型操作），看看会不会更快。
之前我也写过一篇，在 React 项目中引入 Rust 的文章，感兴趣可以看：使用 Rust 编写更快的 React 组件
最近发现了一个老外做了在 Node.js 服务中引入 Golang 的性能测试（https://blog.devgenius.io/node-js-in-go-we-trust-7da6395776f2），挺有意思的，遂翻译了一下。
测试项
尝试仅使用 Node.js解决 CPU 密集型任务
创建单独使用 的Golang编写的服务，并通过发送请求或消息队列的方式将其连接到应用里面
使用 Golang构建wasm文件以运行Node.js中的某些方法
速度与金钱
我是老式意大利西部片的粉丝，尤其是《The Good, the Bad and the Ugly》。我们在本文中我们有 3 个测试项，对应电影中的 3 个英雄。
Node.js（好人）
优点：
前后端使用相同的语言
I/O操作大师 - 超快的事件循环
最大的武器库 - npm
Golang（坏人）
优点：
由 Google设计
几乎所有操作系统都支持
“Goroutines” - Golang中的特殊函数，可以与其他函数或方法同时运行（适用于CPU密集型任务）
简单 - 只有 25 个关键词
nodejs-golang/WebAssembly（丑陋的人）
优点：
随处可用
补充 JavaScript
可以用不同的语言编写代码并在 JavaScript中使用.wasm脚本
最后这个测试项我们重点聊聊：
通过将操作系统设置为 “js” 并将架构设置为 “wasm”``（所有的GOOS和GOARCH` 值列表在这里 https://go.dev/doc/install/source#environment ），可以将 Golang 代码构建为 .wasm 文件：
GOOS=js GOARCH=wasm go build -o main.wasm
要运行编译后的 Go 代码，你需要 wasm_exec.js 中的 glue code 。它在这里找到：
${GOROOT}/misc/wasm/wasm_exec.js
为了实例化，我使用了 @assemblyscript/loader 并创建了一个 nodejs-golang 模块（顺便说一句，@assemblyscript/loader 是它的唯一依赖项）。这个模块有助于创建、构建和运行可在 JavaScript 代码中使用的单独的 wasm 脚本或函数
require('./go/misc/wasm/wasm_exec');
const go = new Go();
...
const wasm = fs.readFileSync(wasmPath);
const wasmModule = await loader.instantiateStreaming(wasm, go.importObject);
go.run(wasmModule.instance);
顺便说一句，其他语言可以以相同的方式用于创建 .wasm 文件。
C: emcc hello.c -s WASM=1 -o code秘密花园.html
C++: em++ hello.cpp -s WASM=1 -o code秘密花园.html
Rust：cargo build --target wasm --release
让我们来看看谁是狂野西部最快的枪……
为此，我们需要创建 2 个服务器
1.Golang服务器
package main
import (
...
"fmt"
...
"net/http"
...
)
func main() {
...
fmt.Print("Golang: Server is running at http://localhost:8090/")
http.ListenAndServe(":8090", nil)
}
2. Node.js 服务器
const http = require('http');
...
(async () => {
...
http.createServer((req, res) => {
...
})
.listen(8080, () => {
console.log('Nodejs: Server is running at http://localhost:8080/');
});
})();
我们将测试每个任务的执行时间，注意：
对于 Golang服务器，它的延迟将是函数的直接执行时间 + 网络请求延迟而对于 Node.js和WebAssembly，它将只是函数的执行时间
最后的决斗
1.“ping”请求
只是检查一下一个请求执行将花费多少时间
Node.js
const nodejsPingHandler = (req, res) => {
console.time('Nodejs: ping');
const result = 'Pong';
console.timeEnd('Nodejs: ping');
res.statusCode = 200;
res.setHeader('Content-Type', 'application/json');
res.write(JSON.stringify({ result }));
res.end();
};
Golang
// golang/ping.js
const http = require('http');
const golangPingHandler = (req, res) => {
const options = {
hostname: 'localhost',
port: 8090,
path: '/ping',
method: 'GET',
};
let result = '';
console.time('Golang: ping');
const request = http.request(options, (response) => {
response.on('data', (data) => {
result += data;
});
response.on('end', () => {
console.timeEnd('Golang: ping');
res.statusCode = 200;
res.setHeader('Content-Type', 'application/json');
res.write(JSON.stringify({ result }));
res.end();
});
});
request.on('error', (error) => {
console.error(error);
});
request.end();
};
// main.go
func ping(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, "Pong")
}
nodejs-golang
// nodejs-golang/ping.js
const nodejsGolangPingHandler = async (req, res) => {
console.time('Nodejs-Golang: ping');
const result = global.GolangPing();
console.timeEnd('Nodejs-Golang: ping');
res.statusCode = 200;
res.setHeader('Content-Type', 'application/json');
res.write(JSON.stringify({ result }));
res.end();
};
// main.go
package main
import (
"syscall/js"
)
func GolangPing(this js.Value, p []js.Value) interface{} {
return js.ValueOf("Pong")
}
func main() {
c := make(chan struct{}, 0)
js.Global().Set("GolangPing", js.FuncOf(GolangPing))
<-c
}
结果：
两个数字的简单求和
Node.js
const result = p1 + p2;
Golang
func sum(w http.ResponseWriter, req *http.Request) {
p1, _ := strconv.Atoi(req.URL.Query().Get("p1"))
p2, _ := strconv.Atoi(req.URL.Query().Get("p2"))
sum := p1 + p2
fmt.Fprint(w, sum)
}
nodejs-golang
func GolangSum(this js.Value, p []js.Value) interface{} {
sum := p[0].Int() + p[1].Int()
return js.ValueOf(sum)
}
结果
计算斐波那契数列（第 100000 个数）
Node.js
const fibonacci = (num) => {
let a = BigInt(1),
b = BigInt(0),
temp;
while (num > 0) {
temp = a;
a = a + b;
b = temp;
num--;
}
return b;
};
Golang
func fibonacci(w http.ResponseWriter, req *http.Request) {
nValue, _ := strconv.Atoi(req.URL.Query().Get("n"))
var n = uint(nValue)
if n <= 1 {
fmt.Fprint(w, big.NewInt(int64(n)))
}
var n2, n1 = big.NewInt(0), big.NewInt(1)
for i := uint(1); i < n; i++ {
n2.Add(n2, n1)
n1, n2 = n2, n1
}
fmt.Fprint(w, n1)
}
nodejs-golang
func GolangFibonacci(this js.Value, p []js.Value) interface{} {
var n = uint(p[0].Int())
if n <= 1 {
return big.NewInt(int64(n))
}
var n2, n1 = big.NewInt(0), big.NewInt(1)
for i := uint(1); i < n; i++ {
n2.Add(n2, n1)
n1, n2 = n2, n1
}
return js.ValueOf(n1.String())
}
结果
计算 md5（10k 字符串）
Node.js
const crypto = require('crypto');
const md5 = (num) => {
for (let i = 0; i < num; i++) {
crypto.createHash('md5').update('nodejs-golang').digest('hex');
}
return num;
};
Golang
func md5Worker(c chan string, wg *sync.WaitGroup) {
hash := md5.Sum([]byte("nodejs-golang"))
c <- hex.EncodeToString(hash[:])
wg.Done()
}
func md5Array(w http.ResponseWriter, req *http.Request) {
n, _ := strconv.Atoi(req.URL.Query().Get("n"))
c := make(chan string, n)
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go md5Worker(c, &wg)
}
wg.Wait()
fmt.Fprint(w, n)
}
nodejs-golang
func md5Worker(c chan string, wg *sync.WaitGroup) {
hash := md5.Sum([]byte("nodejs-golang"))
c <- hex.EncodeToString(hash[:])
wg.Done()
}
func GolangMd5(this js.Value, p []js.Value) interface{} {
n := p[0].Int()
c := make(chan string, n)
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go md5Worker(c, &wg)
}
wg.Wait()
return js.ValueOf(n)
}
结果
计算 sha256（10k 字符串）
Node.js
const crypto = require('crypto');
const sha256 = (num) => {
for (let i = 0; i < num; i++) {
crypto.createHash('sha256').update('nodejs-golang').digest('hex');
}
return num;
};
Golang
func sha256Worker(c chan string, wg *sync.WaitGroup) {
h := sha256.New()
h.Write([]byte("nodejs-golang"))
sha256_hash := hex.EncodeToString(h.Sum(nil))
c <- sha256_hash
wg.Done()
}
func sha256Array(w http.ResponseWriter, req *http.Request) {
n, _ := strconv.Atoi(req.URL.Query().Get("n"))
c := make(chan string, n)
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go sha256Worker(c, &wg)
}
wg.Wait()
fmt.Fprint(w, n)
}
nodejs-golang
func sha256Worker(c chan string, wg *sync.WaitGroup) {
h := sha256.New()
h.Write([]byte("nodejs-golang"))
sha256_hash := hex.EncodeToString(h.Sum(nil))
c <- sha256_hash
wg.Done()
}
func GolangSha256(this js.Value, p []js.Value) interface{} {
n := p[0].Int()
c := make(chan string, n)
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go sha256Worker(c, &wg)
}
wg.Wait()
return js.ValueOf(n)
}
结果
最终结果
Node.js，能很好地完成它的工作
Golang能很好地完成它的工作
WebAssembly（现在还有我的nodejs-golang模块）能很好地完成它的工作
Golang可以用作独立应用程序，作为服务/微服务，作为wasm脚本的源，然后可以在JavaScript中被调用
Node.js和 Golang 都有现成的机制来在 JavaScript 中使用 WebAssembly结论
快是好的，但准确才是一切。- Wyatt Earp
如果有可能不用 Node.js运行CPU密集型任务 - 最好不要这样做
如果你需要在 Node.js中运行CPU密集型任务 - 可以先尝试使用Node.js执行此操作，可能性能没有你想象的那么差
在性能（使用其他语言）和可读性之间，最好选择可读性。如果你是唯一熟悉这个语言的人，则向项目添加这个新语言并不是一个好主意
对我来说，不同语言的服务最好 “保持分离”。你可以尝试为 CPU 密集型计算创建单独的服务或微服务，可以轻松扩展此类服务
首先， WebAssembly对于浏览器来说是很好的，Wasm二进制代码比JS代码更小，更容易解析，向后兼容等等，但是在 Node 服务中可能不是一个很好的选择
“一个优秀的架构师会假装还没有做出决定，并对系统进行反复的测试和优化，以便这些决定仍然可以尽可能长时间地推迟或更改。优秀的架构师会将未做决策的数量最大化。” - Robert C. Martin 的 Clean Architecture
抖音前端正急缺人才，如果你想加入我们，欢迎加我微信和我联系。另外如果你想加入高质量前端交流群，或者你有任何其他事情想和我交流也可以添加我的个人微信 ConardLi 。
文中如有错误，欢迎在留言区和我留言，如果这篇文章帮助到了你，欢迎点赞、在看和关注。你的点赞、在看和关注是对我最大的支持！