Golang 快速参考指南

有用的 Go 语言命令和结构

目录

以下是基本的Go程序结构、错误处理模式以及通道与goroutine的比较。

bunnies around golang sign

Go语言速查表

基本语法

包声明

package main

导入包

import "fmt"
import (
    "fmt"
    "math"
)

主函数

func main() {
    // 你的代码在这里
}

变量和类型

变量声明

var name string
var age int = 25
x := 10 // 简短声明

基本类型

  • bool
  • string
  • int, int8, int16, int32, int64
  • uint, uint8, uint16, uint32, uint64
  • float32, float64
  • complex64, complex128

控制结构

if语句

if x > 0 {
    // 代码
} else if x < 0 {
    // 代码
} else {
    // 代码
}

for循环

for i := 0; i < 10; i++ {
    // 代码
}

range循环

for index, value := range collection {
    // 代码
}

switch语句

switch variable {
case value1:
    // 代码
case value2:
    // 代码
default:
    // 代码
}

函数

函数声明

func functionName(param1 type1, param2 type2) returnType {
    // 代码
    return value
}

多返回值

func divideAndRemainder(x, y int) (int, int) {
    return x / y, x % y
}

数据结构

数组

var numbers int
numbers := int{1, 2, 3, 4, 5}

切片

slice := []int{1, 2, 3}
slice := make([]int, 3, 5)

映射

m := make(map[string]int)
m["key"] = value

结构体

type Person struct {
    Name string
    Age  int
}
p := Person{Name: "Alice", Age: 30}

方法

方法声明

func (r Rectangle) Area() float64 {
    return r.width * r.height
}

接口

接口声明

type Shape interface {
    Area() float64
}

并发

Goroutines

go functionName()

通道

ch := make(chan int)
ch <- value  // 发送
value := <-ch  // 接收

错误处理

错误检查

if err != nil {
    // 处理错误
}

defer

defer file.Close()

测试

测试函数

func TestFunction(t *testing.T) {
    // 测试代码
}

这个速查表涵盖了Go语言中最基本的构造和命令。它包括基本语法、控制结构、函数、数据结构、方法、接口、并发原语和错误处理。请记住，Go强调简洁和可读性，因此这些构造构成了编写高效且清晰Go代码的基础。

Go中的错误处理

Go中的错误处理是直接且明确的，强调清晰性和健壮性。以下是Go中处理错误的关键技术：

  1. 返回错误值：可能失败的函数应将其最后一个返回值设为错误。例如：
func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("empty name")
    }
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message, nil
}
  1. 始终检查错误：调用返回错误的函数后，立即检查错误是否非空。例如：
result, err := SomeFunction()
if err != nil {
    // 处理错误
    log.Fatal(err)
}
  1. 使用错误包装：在将错误传递给调用栈时，使用fmt.Errorf()和%w动词来包装错误以添加上下文。例如：
f, err := os.Open(path)
if err != nil {
    return nil, fmt.Errorf("open failed: %w", err)
}

  1. 使用defer进行清理：使用defer确保即使发生错误，资源也能被正确关闭或清理。

  2. 创建自定义错误类型：为自定义错误类型实现error接口，以提供更详细的错误信息。

  3. 使用errors包：利用errors.New()创建简单的错误消息，并使用errors.Is()或errors.As()进行错误类型检查和转换。

  4. 避免使用panic：将panic保留给真正无法恢复的情况。正常的错误处理应使用返回值。

  5. 提供明确的错误信息：使错误信息清晰且具有信息性，以帮助调试和解决问题。

遵循这些实践，你可以创建健壮的Go程序，有效处理错误并保持代码清晰。

Go中Goroutines和Channels的最佳实践

Goroutines的高效使用

  1. 避免创建过多的Goroutines：谨慎创建Goroutines，考虑任务的性质以及是否能从并行执行中受益。

  2. 适当的同步：使用同步机制如通道或等待组来有效管理Goroutines，防止资源浪费。

  3. 考虑任务性质：在使用Goroutines之前，评估任务是否真正受益于并发执行。

通道的有效使用

  1. 选择适当的通道类型：使用无缓冲通道进行同步，使用缓冲通道以解耦发送和接收操作。

  2. 缓冲容量：在使用缓冲通道时，仔细考虑缓冲区大小，以平衡性能和资源使用。

  3. 正确关闭通道：确保在不再发送数据时关闭通道，以防止死锁和资源泄漏。

并发模式

  1. 工作池模式：使用Goroutines和通道实现工作池，以高效分配任务和收集结果。

  2. 生产者-消费者模式：使用Goroutines作为生产者和消费者，通道在它们之间促进数据流动。

错误处理和资源管理

  1. 使用defer进行清理：使用defer语句确保即使发生错误，资源也能被正确清理。

  2. 处理panic：在长时间运行的Goroutines中实现recover()，以防止由于单个Goroutine中的panic导致整个程序崩溃。

通信和同步

  1. 优先使用通道而非共享内存：使用通道在Goroutines之间进行通信，以避免竞态条件并简化同步。

  2. 使用select处理多个通道：使用select语句同时处理多个通道操作。

性能考虑

  1. 限制并发操作：使用信号量或工作池限制并发操作的数量，以防止资源耗尽。

  2. 避免过早优化：通过分析代码识别瓶颈，再应用并发优化。

测试和调试

  1. 使用竞态检测器：定期使用-race标志运行测试，以检测数据竞态。

  2. 编写并发测试：创建专门测试并发代码路径的测试，以确保可靠性。

通过遵循这些最佳实践，你可以有效利用Go的并发模型，使你的程序更高效、更易于维护，并减少常见的并发相关问题。

参见其他技术博客文章。

在Linux上升级golang

  1. 前往并下载新版本：https://go.dev/doc/install
  2. 删除旧版本：
sudo rm -rf /usr/local/go
  1. 安装新版本：
cd Downloads
sudo tar -C /usr/local -xzf go1.24.3.linux-amd64.tar.gz

有用的链接