Go（又称Golang）是由Google开发的开源编程语言，以其简洁、高效和强大的并发支持著称。本文将带你完成本地开发环境的配置，并通过几个简单实例快速上手。

第一部分：配置本地Go运行环境

1. 下载与安装

访问 Go官网下载页面，根据操作系统选择对应的安装包：

Linux手动安装示例：

wget https://go.dev/dl/go1.21.5.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

2. 验证安装

打开终端（Windows下使用命令提示符或PowerShell），输入：

go version

如果输出类似 go version go1.21.5 windows/amd64，说明安装成功。

3. 设置Go模块代理（可选但推荐）

由于网络原因，国内用户建议设置七牛云代理加速依赖下载：

go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct

4. 创建第一个Go项目

Go 1.11之后推荐使用模块（Module）管理项目。创建一个目录并初始化：

mkdir hello-go
cd hello-go
go mod init example.com/hello

此时会生成 go.mod 文件，记录模块名称和依赖。

第二部分：Go语言简单实例

实例1：Hello World

这是每个语言的起点。在项目根目录创建 main.go：

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go 世界！")
}

运行：

go run main.go

输出：

Hello, Go 世界！

要点说明：

• package main 表示这是一个可执行程序。
• func main() 是程序入口。
• fmt.Println 用于打印并换行。

实例2：变量与数据类型

Go是静态类型语言，但支持类型推断。新建 variables.go：

package main

import "fmt"

func main() {
    // 显式声明
    var name string = "小明"
    var age int = 28
    
    // 类型推断（常用写法）
    height := 175.5  // float64
    isStudent := false
    
    // 多变量声明
    var x, y int = 10, 20
    
    fmt.Printf("姓名：%s，年龄：%d，身高：%.1fcm\n", name, age, height)
    fmt.Println("是否学生：", isStudent)
    fmt.Println("x+y =", x+y)
}

运行：

go run variables.go

关键点：

• := 是短变量声明，只能在函数内使用。
• 基本类型：int, float64, string, bool。
• %s、%d、%.1f 是格式化占位符。

实例3：循环与条件判断

计算1到100的和，并判断奇偶性。新建 loop.go：

package main

import "fmt"

func main() {
    sum := 0
    for i := 1; i <= 100; i++ {
        sum += i
    }
    fmt.Println("1+2+...+100 =", sum)

    // 判断奇偶数
    num := 42
    if num%2 == 0 {
        fmt.Printf("%d 是偶数\n", num)
    } else {
        fmt.Printf("%d 是奇数\n", num)
    }

    // switch 示例
    day := "Saturday"
    switch day {
    case "Saturday", "Sunday":
        fmt.Println("周末快乐！")
    default:
        fmt.Println("工作日加油！")
    }
}

特点：

• Go只有 for 关键字，没有 while；for 省略条件即无限循环。
• if 条件不需要括号，但语句体必须用大括号。
• switch 默认每个case自带break，不会向下穿透（除非使用 fallthrough）。

实例4：函数与返回值

编写一个计算斐波那契数列的函数。新建 fib.go：

package main

import "fmt"

// 递归方式
func fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return fibonacci(n-1) + fibonacci(n-2)
}

// 返回多个值（经典用法）
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

func main() {
    // 打印前10个斐波那契数
    for i := 0; i < 10; i++ {
        fmt.Printf("fib(%d)=%d ", i, fibonacci(i))
    }
    fmt.Println()

    // 多返回值
    result, err := divide(10, 3)
    if err != nil {
        fmt.Println("错误：", err)
    } else {
        fmt.Println("10/3 =", result)
    }

    // 测试除零错误
    _, err2 := divide(5, 0)
    if err2 != nil {
        fmt.Println("捕获错误：", err2)
    }
}

亮点：

• 函数可以返回多个值，常用于返回结果和错误。
• error 是内置接口，Go通过返回error来处理异常，而非try-catch。

实例5：简单的HTTP服务器

Go标准库内置了强大的net/http包，几行代码即可启动Web服务。新建 server.go：

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "你好，欢迎访问Go服务器！\n请求路径：%s", r.URL.Path)
}

func main() {
    http.HandleFunc("/", helloHandler)
    fmt.Println("服务器启动于 http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

运行：

go run server.go

然后在浏览器打开 http://localhost:8080/hello，你会看到响应内容。

核心概念：

• HandleFunc 注册路由处理函数。
• ListenAndServe 监听端口，第二个参数为nil表示使用默认路由器。

实例6：并发 goroutine 与 channel

Go的并发模型是其最大特色。下面的例子启动多个goroutine计算平方，并通过channel收集结果。新建 concurrent.go：

package main

import (
    "fmt"
    "time"
)

func square(num int, ch chan int) {
    time.Sleep(time.Millisecond * 100) // 模拟耗时
    result := num * num
    ch <- result // 发送结果到channel
}

func main() {
    numbers := []int{2, 4, 6, 8, 10}
    ch := make(chan int, len(numbers))

    for _, n := range numbers {
        go square(n, ch) // 启动goroutine
    }

    // 接收所有结果
    for i := 0; i < len(numbers); i++ {
        result := <-ch
        fmt.Println("收到结果：", result)
    }

    close(ch)
    fmt.Println("所有goroutine已完成")
}

关键理解：

• go 关键字启动轻量级线程（goroutine）。
• channel（通道）用于goroutine间安全通信。
• 缓冲channel（make(chan int, 5)）允许异步发送一定数量而不阻塞。

第三部分：编译与分发

Go程序可以编译成独立的二进制文件，无需依赖运行时环境。

# 编译当前目录下的main包
go build -o myapp main.go

# 交叉编译（在Windows上编译Linux可执行文件）
GOOS=linux GOARCH=amd64 go build -o myapp-linux main.go

编译后的文件可直接拷贝到同架构的机器上运行。

总结

通过以上六个实例，你已经掌握了：

• ✅ Go环境安装与模块初始化
• ✅ 基础语法：变量、循环、条件、函数
• ✅ HTTP服务器搭建
• ✅ 并发编程入门

下一步可以尝试阅读《The Go Programming Language》或官方文档，深入学习接口、结构体、错误处理等内容。Go的学习曲线非常平缓，相信很快你就能用它写出高效的生产级应用。

Happy coding with Go! 🚀