Go 语言快速入门教程，包含基础语法、核心特性、并发模型和实战示例，帮助您快速掌握 Go 编程。

原创已于 2025-05-15 18:28:03 修改 · 979 阅读

12 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

于 2025-05-15 18:27:13 首次发布

更多资源关注文末公众号👇

以下是 Go 语言快速入门教程，包含 基础语法、核心特性、并发模型和实战示例，帮助您快速掌握 Go 编程。

📌 目录

Go 语言简介
安装与环境配置
基础语法
函数与方法
结构体与接口
并发编程（Goroutine & Channel）
文件操作与网络编程
实战示例
学习资源推荐

1. Go 语言简介

Go（又称 Golang）是 Google 开发的一种 静态强类型、编译型、并发型 编程语言。 ✅ 特点：

简洁高效：语法类似 C，但更现代化
内置并发：Goroutine + Channel 轻松实现高并发
高性能：编译为机器码，执行速度快
跨平台：支持 Windows、Linux、macOS

2. 安装与环境配置

（1）安装 Go

Windows：下载官方安装包
Mac/Linux：使用 brew install go 或 apt install golang

（2）验证安装

go version  # 查看版本
go env      # 查看环境变量

（3）配置 GOPATH

Go 1.11+ 默认使用 Go Modules（推荐），但了解 GOPATH 仍然重要：

export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin

3. 基础语法

（1）Hello World

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

✅ 运行：

go run hello.go

（2）变量与常量

var name string = "Alice"  // 显式声明
age := 25                  // 类型推断（短变量声明）
const PI = 3.14            // 常量

（3）数据类型

类型	示例
`int`	`var num int = 42`
`float64`	`var price float64 = 19.99`
`bool`	`var isActive bool = true`
`string`	`var name string = "Bob"`

（4）条件语句

if age >= 18 {
    fmt.Println("Adult")
} else {
    fmt.Println("Child")
}

（5）循环

Go 只有 for 循环：

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// 类似 while 循环
for age < 30 {
    age++
}

（6）数组与切片

// 数组（固定长度）
arr := [3]int{1, 2, 3}

// 切片（动态数组）
slice := []int{1, 2, 3}
slice = append(slice, 4)  // 追加元素

（7）Map（字典）

user := map[string]string{
    "name": "Alice",
    "age":  "25",
}
fmt.Println(user["name"])  // 输出 "Alice"

4. 函数与方法

（1）函数

func add(a int, b int) int {
    return a + b
}

result := add(3, 5)  // 8

（2）多返回值

func swap(a, b int) (int, int) {
    return b, a
}

x, y := swap(1, 2)  // x=2, y=1

（3）方法（面向对象）

type Person struct {
    Name string
    Age  int
}

// 定义方法
func (p Person) SayHello() {
    fmt.Printf("Hello, I'm %s\n", p.Name)
}

// 调用
p := Person{"Alice", 25}
p.SayHello()  // 输出 "Hello, I'm Alice"

5. 结构体与接口

（1）结构体

type User struct {
    Name string
    Age  int
}

user := User{"Bob", 30}
fmt.Println(user.Name)  // "Bob"

（2）接口

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

var a Animal = Dog{}
fmt.Println(a.Speak())  // "Woof!"

6. 并发编程（Goroutine & Channel）

（1）Goroutine（轻量级线程）

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

func main() {
    go say("Hello")  // 启动 Goroutine
    say("World")     // 主线程
}

（2）Channel（通信）

ch := make(chan string)

go func() {
    ch <- "Hello from Goroutine!"
}()

msg := <-ch  // 接收消息
fmt.Println(msg)  // "Hello from Goroutine!"

（3）Select（多路复用）

select {
case msg1 := <-ch1:
    fmt.Println(msg1)
case msg2 := <-ch2:
    fmt.Println(msg2)
default:
    fmt.Println("No message")
}

7. 文件操作与网络编程

（1）文件读写

// 写入文件
data := []byte("Hello, Go!")
err := os.WriteFile("test.txt", data, 0644)

// 读取文件
content, err := os.ReadFile("test.txt")
fmt.Println(string(content))  // "Hello, Go!"

（2）HTTP 服务器

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, Go Web!")
}

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

8. 实战示例

（1）命令行计算器

package main

import (
    "fmt"
    "os"
    "strconv"
)

func main() {
    if len(os.Args) != 3 {
        fmt.Println("Usage: calc <num1> <num2>")
        return
    }

    a, _ := strconv.Atoi(os.Args[1])
    b, _ := strconv.Atoi(os.Args[2])
    fmt.Printf("%d + %d = %d\n", a, b, a+b)
}

✅ 运行：

go run calc.go 10 20  # 输出 "10 + 20 = 30"

（2）并发爬虫

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func fetch(url string, wg *sync.WaitGroup) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Printf("%s: %d\n", url, resp.StatusCode)
}

func main() {
    var wg sync.WaitGroup
    urls := []string{
        "https://google.com",
        "https://github.com",
    }

    for _, url := range urls {
        wg.Add(1)
        go fetch(url, &wg)
    }

    wg.Wait()
    fmt.Println("All requests done!")
}