Nodejs与Golang的异步编程模型对比,哪个更有意思

Nodejs与Golang的异步编程模型对比,哪个更有意思

Node 里异步编程, 只能靠 callback 或者 promise 来完成, 但是 Golang 看起来有意思多了…

package main
import "fmt"
 
func foo(){
    defer fmt.Println("World")
    fmt.Println("Hello")
}
 
func sum(x,y int,c chan int){
    c <- x + y
}
 
func main(){
    foo()
    c := make (chan int);
    go sum(24,18,c)
    fmt.Println(<-c);
}

通过 Channel 的概念, fmt.Println(<-c) 会阻塞代码执行,

go sum(24,18,c) 启动的 goroutine 则继续执行, 等到 c <- x + y 往 Channel 里发送了数据, fmt.Println(<-c) 接收到了数据, 才继续执行代码, 这样就比较方便能用同步的逻辑写异步代码, Node 也方便, 但是不够优雅 …难怪那么多人用惯了后端语言以后不喜欢 Node

感受下 Golang 的中文社区 http://www.golangtc.com/ studygolang.com/ https://groups.google.com/d/forum/golang-china


更多关于Nodejs与Golang的异步编程模型对比,哪个更有意思的实战教程也可以访问 https://www.itying.com/category-94-b0.html

21 回复

Node.js 与 Golang 的异步编程模型对比

在探讨 Node.js 和 Golang 的异步编程模型时,我们可以看到两种不同的方法来处理并发任务。这两种语言各有优劣,但它们都提供了强大的工具来处理高并发场景。

Node.js 异步编程模型

在 Node.js 中,异步编程主要依赖于回调函数、Promise 和 async/await。这些方法都是为了处理 I/O 操作中的非阻塞特性。

回调函数示例:

const fs = require('fs');

fs.readFile('/path/to/file', 'utf8', function(err, data) {
    if (err) throw err;
    console.log(data);
});

Promise 示例:

const fs = require('fs').promises;

async function readData() {
    try {
        const data = await fs.readFile('/path/to/file', 'utf8');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
}
readData();

async/await 示例:

const fs = require('fs').promises;

async function readData() {
    try {
        const data = await fs.readFile('/path/to/file', 'utf8');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
}
readData();

Golang 异步编程模型

Golang 使用 Goroutines 和 Channels 来实现并发和通信。这种方式使得代码更加简洁和易读,因为你可以用同步的方式来编写异步代码。

Golang 示例:

package main

import (
    "fmt"
)

func sum(x, y int, c chan int) {
    c <- x + y
}

func main() {
    c := make(chan int)
    go sum(24, 18, c)
    fmt.Println(<-c)
}

在这个例子中,sum 函数在一个新的 Goroutine 中运行,并通过 Channel 发送计算结果。fmt.Println(<-c) 会阻塞,直到从 Channel 中接收到数据。这种方式使得代码看起来更像是同步的,从而提高了可读性和维护性。

总结

虽然 Node.js 提供了多种方式来处理异步编程(如回调函数、Promise 和 async/await),但在某些情况下,这些方法可能会导致所谓的“回调地狱”。相比之下,Golang 的 Goroutines 和 Channels 提供了一种更为优雅的方式,可以更自然地表达并发逻辑。因此,在某些开发者看来,Golang 的异步编程模型可能更“有意思”,因为它更容易理解和维护。

如果你对 Golang 感兴趣,可以访问一些中文社区获取更多信息:

更多关于Nodejs与Golang的异步编程模型对比,哪个更有意思的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


玩过go,但是还是喜欢node~

怎么说?

golang太精确,不用的不注释掉,好像不能运行.加上还要给变量定义类型,特别是req跟res,要输好长一串.研究了段时间就没有继续了,不过go sum(24,18,c),这个异步确实不错

有意思么,还是喜欢node.

嗯, 静态类型, 编译代码结果就是汇编在跑, 精确还是好事, 不是琐碎就好了

golang已经成了我做项目的首选,当然node.js也很是喜欢,做游戏的话node.js是首选

静态编译很多语法错误能够在编译的时候避免了。

一个是静态语言,一个是动态语言,差别太大了……

很难说那个好,例如底层的libuv,它也不是协程的方式,代码也不写起来很舒服?

就让时间去证明吧。

我们不要纠结在起点,喜欢用什么的就用什么,just code it

Node 玩来玩去就这么点东西, 除了方便一点…

Go挺好,就是语法太另类了。。

相信我, JS 的语法绝对比 Go 欠缺考虑. 另类本身和褒贬没有关联.

看不懂…go是用了协程吗???

golang有比较好的mvc框架吗

类似 coroutine 但不叫 coroutine, 网上的说法是个叫 CSP 的并发模型.

网上有但还没了解过, 后端 MVC 相对来说还是不少的

多的很,beego,revel跟express差不多的

ES6里会出来generator的,不用羡慕。

ES6 依然单线程哦, Golang 的并发模型能用在并行计算的

Node.js 与 Golang 异步编程模型对比

在Node.js中,异步编程主要依赖于回调函数、Promise和async/await。而在Golang中,Go语言通过goroutines和channels实现了更加直观且易于管理的并发模型。下面我们来详细对比这两种方式。

Node.js 示例(使用async/await)

const fs = require('fs');

function readFileAsync(filename) {
    return new Promise((resolve, reject) => {
        fs.readFile(filename, 'utf-8', (err, data) => {
            if (err) {
                reject(err);
            } else {
                resolve(data);
            }
        });
    });
}

async function run() {
    try {
        const data1 = await readFileAsync('file1.txt');
        console.log(data1);
        
        const data2 = await readFileAsync('file2.txt');
        console.log(data2);
    } catch (error) {
        console.error(error);
    }
}

run();

在这个例子中,我们使用了readFileAsync函数将文件读取操作封装成一个Promise,并使用async/await语法使得代码看起来更同步。

Golang 示例

package main

import (
    "fmt"
)

func readFile(filename string, ch chan<- string) {
    data, err := os.ReadFile(filename)
    if err != nil {
        ch <- ""
    } else {
        ch <- string(data)
    }
}

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go readFile("file1.txt", ch1)
    go readFile("file2.txt", ch2)

    data1 := <-ch1
    data2 := <-ch2

    fmt.Println(data1)
    fmt.Println(data2)
}

在这个例子中,readFile函数将文件读取操作放在了一个goroutine中,并通过channel传递结果。主函数通过阻塞方式等待两个channel的结果。

总结

虽然Node.js中的async/await让异步代码看起来更同步,但Golang的goroutines和channels提供了一种更为直观的并发处理方式。这种设计使得Golang在处理并发任务时更加简单和直观。因此,对于喜欢更直观和结构化并发编程的开发者来说,Golang可能更具吸引力。


从上述示例可以看出,Golang的并发模型更加直接和易于理解,而Node.js的异步模型则需要更多的编程技巧。这使得在某些场景下,Golang可能更受欢迎。

回到顶部