跳至主要內容

Golang 编程基础

SiYue2025/12/3大约 10 分钟Go

为什么选择Go？

Go语言（Golang）由Google开发，因其简洁的语法、高效的性能和强大的并发支持，成为现代软件开发中的热门选择。Go语言特别适合构建网络服务、分布式系统和云原生应用。

Go语言的优势

语法极其简洁

Go语言的语法非常简洁，关键字仅有25个，学习时间成本极低

Go 语言的“Hello, World!”

package main
import "fmt"

func main() {
    name := "World"
    fmt.Printf("Hello, %s!\n", name)    
}

编译速度极快

Go语言的编译器设计注重速度，能够在几秒钟内完成大型项目的编译，大大提升了开发效率。

内置并发支持

现代计算机多核处理器的普及使得并发编程变得尤为重要。Go语言通过goroutine和channel提供了简单而强大的并发编程模型，使得开发高性能并发应用变得轻松。

你只需要go关键字就可以轻松启动一个goroutine

go func() {
    fmt.Println("这是一个 goroutine!")
}()

垃圾回收机制

Go内置GC垃圾回收机制，自动管理内存，减少内存泄漏和悬挂指针等问题，Go的垃圾回收器经过多年的优化，能够在保持高性能的同时有效管理内存。

静态类型但有类型推断

Go语言是静态类型语言，这意味着编译器可以在编译时发现很多错误，提高了程序的可靠性。同时，Go语言支持类型推断，你不需要显式声明每个变量的类型:

var a int = 10      // 显式声明类型
b := 20             // 类型推断为 int   
c := "Hello, Go!"  // 类型推断为 string

标准库丰富

Go语言自带了丰富且高质量的标准库，涵盖了网络编程、文件操作、加密、压缩等众多领域，极大地方便了开发者的工作。

Go语言的应用领域

云计算与容器技术

Go语言在云计算和容器技术中占据重要地位。Docker和Kubernetes等知名项目均采用Go语言开发，充分利用了Go的高性能和并发特性。

微服务

Go语言因其高效的性能和简洁的语法，成为构建微服务架构的理想选择。许多大型互联网公司如Google、Uber、Dropbox等都在使用Go语言开发微服务。

Web开发

Go语言在Web开发领域表现优异，许多知名的开源Web框架如Beego、Gin等都是用Go语言编写的。Go的并发特性使得它非常适合构建高性能的Web服务。

// 使用 Gin 框架创建一个简单的 Web 服务器
package main

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    r.Run() // listen and serve on 0.0.0.0:8080
}

开发环境搭建

安装Go

  1. 安装Go语言
  • 访问Go语言官方网站 https://golang.org/dl/ 下载适合你操作系统的安装包，并按照提示完成安装。
  1. 配置环境变量
  • 安装完成后，需要配置环境变量。将Go的安装路径添加到系统的PATH变量中。
  1. 验证安装
  • 打开终端或命令提示符，输入go version，如果显示Go的版本信息，则表示安装成功。

开发工具

  1. VS Code
  • Visual Studio Code 是一款免费开源的代码编辑器，支持多种编程语言，包括Go语言。它提供了丰富的插件和扩展，可以极大地提升开发效率。
  1. GoLand
  • JetBrains出品的GoLand是一款专为Go语言设计的集成开发环境（IDE），提供了代码自动完成、代码导航、调试、测试等功能，是Go语言开发者的首选工具。

GOPATH

虽然Go Modules已经成为管理依赖的主流方式，但了解GOPATH的概念仍然很重要。GOPATH是Go语言的工作目录，默认情况下，GOPATH指向用户主目录下的go文件夹。你可以通过设置环境变量GOPATH来指定自己的工作目录。

GOPATH/
├── bin/     # 存放编译后的可执行文件
├── pkg/     # 存放编译后的包文件
└── src/     # 存放源代码
    ├── github.com/
    ├── gitlab.com/
    └── 其他代码托管平台的域名/

Go Modules包管理系统

Go Modules是Go语言现代化的包管理系统，它允许你轻松地管理项目的依赖关系。使用Go Modules，你可以避免依赖冲突，并且可以轻松地升级或降级依赖版本。

什么是Go Modules？

Go Modules是Go语言1.11版本引入的一种依赖管理工具，它允许你轻松地管理项目的依赖关系。Go Modules使用go.mod文件来记录项目的依赖关系，并且可以通过go get命令来安装和更新依赖。

创建一个Go Modules项目

  1. 创建一个新的文件夹，并在该文件夹中初始化Go Modules项目：
# 创建项目目录
mkdir myproject
cd myproject

# 初始化Go Module
go mod init myproject

这会创建一个名为go.mod的文件，其中包含了项目的模块名称和Go的版本。类似：

module myproject

go 1.16
  1. 添加依赖
    当在代码中使用第三方包时，Go Modules会自动下载并管理这些依赖。
    如果你想在项目中使用github.com/gin-gonic/gin包，你可以在代码中导入它:
package main

import (
    "fmt"
    "github.com/gin-gonic/gin
)

func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    r.Run() // listen and serve on 0.0.0.0:8080
}

运行go mod tidy命令：

go mod tidy

这会自动下载并安装github.com/gin-gonic/gin包，并更新go.mod文件,最后生成go.sum文件，记录依赖的具体版本和校验和，以确保依赖的一致性。

Hello World!

在项目文件夹中，创建一个名为main.go的文件

package main

import "fmt"

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

来简单分析一下这个程序

  • package main：声明了程序的包名，每个Go程序都必须包含一个main包。
  • import "fmt"：导入了一个名为fmt的包，该包提供了格式化I/O函数。
  • func main()：定义了一个名为main的函数，这是程序的入口点。
  • fmt.Println("Hello, World!")：调用fmt包中的Println函数，打印出字符串"Hello, World!"。

运行程序：

go run main.go

你将会看见输出：

Hello, World!

编译程序

你可以使用go build命令来编译程序：

go build main.go

这将在当前目录下生成一个名为main的可执行文件（在Windows上是main.exe）。

编译后的程序可以直接运行，无需Go环境。

交叉编译
Go语言支持交叉编译，你可以使用GOOS和GOARCH环境变量来指定目标操作系统和架构。例如，要在Windows上编译一个Linux可执行文件，你可以运行以下命令：

GOOS=linux GOARCH=amd64 go build main.go

Go命令行工具

Go语言提供了一套强大的命令行工具，可以帮助你管理项目、编译代码、运行测试等。

基础命令

  • go run：运行Go程序。
  • go build：编译Go程序。
  • go install：安装Go程序。
  • go test：运行Go测试。(-v 显示详细信息。)

包管理命令

  • go mod init：初始化Go Modules项目。
  • go mod tidy：更新缺少的依赖，并删除不再需要的依赖。
  • go get：下载并安装依赖。(-u 更新依赖到最新版本。)
  • go mod download：下载依赖到本地缓存。

代码质量命令

  • go fmt：格式化Go代码。
  • go vet：检查Go代码中的常见错误。
  • go lint：检查Go代码中的风格问题。

其他常用命令

  • go doc：查看Go包的文档。
  • go env：查看环境配置。
  • go list：列出项目中的包和模块。
  • go clean：清理编译生成的文件。

实用的脚本程序

// tools.go
package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("用法: go run tools.go <命令>")
        fmt.Println("支持的命令: format, vet, test, build")
        return
    }

    command := os.Args[1]
    
    switch command {
    case "format":
        runCommand("go", "fmt", "./...")
    case "vet":
        runCommand("go", "vet", "./...")
    case "test":
        runCommand("go", "test", "-v", "./...")
    case "build":
        runCommand("go", "build", ".")
    default:
        fmt.Printf("未知命令: %s\n", command)
    }
}

func runCommand(name string, args ...string) {
    cmd := exec.Command(name, args...)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    
    fmt.Printf("执行命令: %s %v\n", name, args)
    
    if err := cmd.Run(); err != nil {
        fmt.Printf("命令执行失败: %v\n", err)
    }
}

这个脚本可以帮你快速执行常用的Go命令。

go run tools.go format  # 格式化代码
go run tools.go vet     # 检查代码
go run tools.go test    # 运行测试
go run tools.go build   # 编译程序

Go语言基础

数据类型

Go语言的数据类型包括基本数据类型和复合数据类型。

基本数据类型

  • 整型：int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64、uintptr
  • 浮点型：float32、float64
  • 复数型：complex64、complex128

Golang 编程基础

Go程序的基本结构如下：

// 这是一个简单的 Go 程序
package main

import (
    "fmt"
    "math"
)

// 这是一个全局常量
const PI = 3.14159

// 这是一个全局变量
var appName = "我的第一个Go程序"

// 这是 main 函数，程序的入口点
func main() {
    // 这是局部变量
    radius := 5.0
    
    // 计算圆的面积
    area := PI * math.Pow(radius, 2)
    
    // 输出结果
    fmt.Printf("%s\n", appName)
    fmt.Printf("半径为 %.1f 的圆的面积是 %.2f\n", radius, area)
}

Go程序的执行流程如下：

  1. 包初始化：Go程序首先会执行包的初始化代码，包括全局变量的初始化和常量的赋值。
  2. 全局变量初始化：Go程序会按照声明顺序初始化全局变量。
  3. init函数：如果包中定义了init函数，Go程序会在包初始化完成后执行init函数。
  4. main函数：Go程序会执行main函数，这是程序的入口点。

包(package)的概念和使用

在Go语言中，包是组织代码的基本单位。每个Go程序都是由一个或多个包组成的，包可以包含函数、变量、常量、类型等。

包的声明

在Go程序中，包的声明使用package关键字，后面跟着包的名称。例如：

package main

这表示该文件属于main包。

包的导入

在Go程序中，可以使用import关键字导入其他包。例如：

import (
    "fmt"
    "math"
)

Go语言特性

Go语言具有以下特性：

1. 基本语法

1.1 变量

// 声明变量
var a int
var b string
var c []float64
var d map[string]int
var e bool

// 声明并初始化变量
var a int = 1
var b string = "hello"
var c []float64 = []float64{1.0, 2.0, 3.0}
var d map[string]int = map[string]int{"one": 1, "two": 2}
var e bool = true

// 简短声明
a := 1
b := "hello"
c := []float64{1.0, 2.0, 3.0}
d := map[string]int{"one": 1, "two": 2}
e := true

1.2 常量

const pi = 3.14
const (
    a = 1
    b = 2
    c = 3
)

1.3 条件语句

if condition {
    // do something
} else if condition {
    // do something else
} else {
    // do something else
}

1.4 循环语句

for i := 0; i < 10; i++ {
    // do something
}
for key, value := range mapVar {
    // do something
}
for _, value := range sliceVar {
    // do something
}

1.5 函数

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

1.6 结构体

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Alice", Age: 20}
    fmt.Println(p.Name, p.Age)
}

1.7 接口

type Animal interface {
    Speak() string
}

type Dog struct{}

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

func main() {
    var a Animal
    a = Dog{}
    fmt.Println(a.Speak())

}

1.8 错误处理

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}
func main() {
    result, err := divide(4, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

1.9 并发

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}
func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }
    wg.Wait()
}

2. 标准库

2.1 字符串处理

s := "hello, world"
fmt.Println(s)
fmt.Println(len(s))
fmt.Println(s[0])
fmt.Println(s[1])
fmt.Println(s[2])
fmt.Println(s[3])
fmt.Println(s[4])
fmt.Println(s[5])
fmt.Println(s[6])
fmt.Println(s[7])
fmt.Println(s[8])
fmt.Println(s[9])
fmt.Println(s[10])

2.2 文件操作

f, err := os.Open("file.txt")
if err != nil {
    log.Fatal(err)
}
defer f.Close()

b := make([]byte, 1024)
n, err := f.Read(b)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(b[:n]))
Built with VuePress By SiYue
Copyright © 2026 SiYue