Go语言零基础入门指南(下篇)（go语言入门书）

liuian 2025-05-09 20:02 34 浏览

1. 并发编程

goroutine基础

Go版本:

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world") // 启动goroutine
    say("hello")
}

对比Python线程：

import threading

def say(s):
    for i in range(3):
        time.sleep(0.1)
        print(s)

threading.Thread(target=say, args=("world",)).start()
say("hello")

对比JavaScript异步：

async function say(s) {
    for (let i = 0; i < 3; i++) {
        await new Promise(resolve => setTimeout(resolve, 100));
        console.log(s);
    }
}

say("world");
say("hello");

关键区别：

goroutine比线程更轻量（初始仅2KB栈）
Go运行时自动调度goroutine到OS线程
语法简单，只需go关键字

channel通信

Go版本:

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // 发送结果到channel
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}
    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 从channel接收
    fmt.Println(x, y, x+y)
}

对比Python多进程：

from multiprocessing import Pipe

def sum(s, conn):
    conn.send(sum(s))
    conn.close()

parent_conn, child_conn = Pipe()
p1 = Process(target=sum, args=(s[:len(s)//2], child_conn))
p2 = Process(target=sum, args=(s[len(s)//2:], child_conn))
p1.start(); p2.start()
print(parent_conn.recv(), parent_conn.recv())

关键区别：

channel是Go内置的线程安全通信机制
可以带缓冲（make(chan int, 100)）
支持关闭channel和range遍历

select多路复用

Go版本:

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

对比JavaScript Promise.race:

async function fibonacci(callback, quitSignal) {
    let x = 0, y = 1;
    while (true) {
        const result = await Promise.race([
            new Promise(res => callback(res, x)),
            quitSignal
        ]);
        if (result === 'quit') return;
        [x, y] = [y, x + y];
    }
}

关键区别：

select可以同时监控多个channel
常用于超时控制：

   select {
   case res := <-c:
       fmt.Println(res)
   case <-time.After(1 * time.Second):
       fmt.Println("timeout")
   }

2. 文件操作与IO

文件读写

Go版本:

// 读取文件
data, err := os.ReadFile("test.txt")
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))

// 写入文件
err = os.WriteFile("output.txt", []byte("Hello"), 0644)
if err != nil {
    log.Fatal(err)
}

对比Python：

with open('test.txt') as f:
    data = f.read()

with open('output.txt', 'w') as f:
    f.write("Hello")

对比JavaScript：

const fs = require('fs');
fs.readFile('test.txt', (err, data) => {
    console.log(data.toString());
});

fs.writeFile('output.txt', 'Hello', err => {});

JSON处理

Go版本:

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// 编码
p := Person{"Alice", 25}
jsonData, _ := json.Marshal(p)

// 解码
var p2 Person
json.Unmarshal(jsonData, &p2)

对比Python：

import json

data = json.dumps({"name": "Alice", "age": 25})
p = json.loads(data)

对比JavaScript：

const data = JSON.stringify({name: "Alice", age: 25});
const p = JSON.parse(data);

关键区别：

Go需要定义结构体对应JSON结构
字段标签控制JSON属性名
编解码可能返回错误需要处理

3. 测试与性能

单元测试

Go版本:

// math.go
func Add(a, b int) int {
    return a + b
}

// math_test.go
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, got %d", result)
    }
}

运行测试：

go test

对比Python unittest：

import unittest

def add(a, b):
    return a + b

class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)

基准测试

Go版本:

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(1, 2)
    }
}

运行基准测试：

go test -bench=.

4. 项目实践

简单HTTP服务

Go版本:

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}

func main() {
    http.HandleFunc("/", helloHandler)
    http.ListenAndServe(":8080", nil)
}

对比Python Flask：

from flask import Flask
app = Flask(__name__)

@app.route('/<name>')
def hello(name):
    return f"Hello, {name}!"

app.run(port=8080)

对比JavaScript Express：

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

app.get('/:name', (req, res) => {
    res.send(`Hello, ${req.params.name}!`);
});

app.listen(8080);

项目结构建议

典型Go项目布局：

myapp/
├── cmd/
│   └── myapp/
│       └── main.go
├── internal/
│   ├── handler/
│   ├── service/
│   └── repository/
├── pkg/
│   └── utils/
├── go.mod
├── go.sum
└── README.md