Go语言基础知识总结（超详细整理）

1. Go语言简介

Go语言（又称Golang）是Google于2009年发布的开源编程语言，具备简洁、高效、并发等特点，适合服务器开发、云计算、大数据等场景。

---

2. 环境安装与配置

• 下载地址：https://golang.org/dl/
• 安装后配置环境变量 GOPATH、GOROOT
• 使用命令验证：

go version
go env

---

3. 基本语法

Go语言代码文件以 .go 结尾，程序入口为 main 包下的 main() 函数。

package main

import "fmt"

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

---

4. 数据类型

Go的基本数据类型分为：

类型类别	类型示例	说明
整型	int, int8, int16, int32, int64	有符号整数
无符号整型	uint, uint8, uint16, uint32, uint64	无符号整数
浮点型	float32, float64	浮点数
字符串	string	字符串
布尔型	bool	true 或 false

---

5. 变量与常量

变量定义示例：

var a int = 10
b := 20       // 简短声明（只能在函数内）
const Pi = 3.14

---

6. 运算符

运算符类型	示例	说明
算术运算符	+, -, *, /, %	加减乘除余数
关系运算符	==, !=, <, >, <=, >=	比较大小、相等
逻辑运算符	&&, `		, !`	逻辑与、或、非
赋值运算符	=, +=, -=, *=	赋值及复合赋值

---

7. 流程控制

7.1 条件语句

if age >= 18 {
    fmt.Println("成年人")
} else {
    fmt.Println("未成年人")
}

7.2 switch语句

switch day {
case 1:
    fmt.Println("星期一")
case 2:
    fmt.Println("星期二")
default:
    fmt.Println("其他")
}

7.3 循环

Go只有一种循环：for，可用多种形式。

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

// 类似while
i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

// 无限循环
for {
    // ...
}

---

8. 函数

函数定义及调用示例：

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

func main() {
    sum := add(3, 4)
    fmt.Println(sum) // 7
}

多返回值：

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

---

9. 数组与切片

9.1 数组

固定长度的同类型元素集合。

var arr [3]int = [3]int{1, 2, 3}
fmt.Println(arr[0]) // 1

9.2 切片

动态大小的数组。

slice := []int{1, 2, 3}
slice = append(slice, 4)
fmt.Println(slice) // [1 2 3 4]

---

10. 字典（map）

键值对集合。

m := make(map[string]int)
m["age"] = 30
fmt.Println(m["age"]) // 30

---

11. 结构体与接口

11.1 结构体

自定义类型，包含多个字段。

type Person struct {
    Name string
    Age  int
}

p := Person{Name: "Tom", Age: 25}
fmt.Println(p.Name) // Tom

11.2 接口

定义一组方法的集合，实现多态。

type Speaker interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "汪汪"
}

func main() {
    var s Speaker = Dog{}
    fmt.Println(s.Speak()) // 汪汪
}

---

12. 面向对象编程基础

• Go不支持传统继承，但支持组合和接口实现多态。
• 结构体可以绑定方法。

func (p Person) Greet() {
    fmt.Println("Hello, my name is", p.Name)
}

---

13. 并发基础

Go的最大特点是内置协程goroutine和通信机制channel。

go func() {
    fmt.Println("并发执行")
}()

ch := make(chan string)
go func() {
    ch <- "消息"
}()
msg := <-ch
fmt.Println(msg)

---

14. 包与模块管理

• 代码通过包组织，默认main为程序入口。
• 使用go mod管理依赖。

go mod init example.com/mymodule
go get github.com/gin-gonic/gin

---

15. 错误处理

Go无异常机制，使用多返回值返回错误。

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为0")
    }
    return a / b, nil
}

res, err := divide(10, 0)
if err != nil {
    fmt.Println("错误:", err)
}

---

16. 标准库常用功能

• fmt：格式化输入输出
• os：操作系统接口
• net/http：HTTP客户端/服务器
• time：时间处理
• encoding/json：JSON编解码

---

17. 练习题

---

17.1 选择题（共10题，每题1分）

1. Go语言的程序入口是哪个函数？

   A. start()

   B. main()

   C. init()

   D. run()

2. 以下哪个关键字用于定义常量？

   A. var

   B. let

   C. const

   D. static

3. Go语言中下列哪个数据类型是无符号整数？

   A. int32

   B. uint

   C. float64

   D. byte

4. 下列哪个循环语句在Go语言中不存在？

   A. for

   B. while

   C. 无限循环 for {}

   D. for-range

5. 下列哪个函数声明是正确的？

   A. func add(a int, b int) int {}

   B. function add(a int, b int) int {}

   C. func add(a int, b int): int {}

   D. def add(a int, b int) int {}

6. 下列哪个语句用于创建map？

   A. m := []int{}

   B. m := make(map[string]int)

   C. m := map{}

   D. m := map()

7. Go中声明变量a的正确写法是？

   A. var a int = 10

   B. a := 10

   C. var a = 10

   D. 以上都对

8. Go语言的并发单位是？

   A. Thread

   B. Process

   C. Goroutine

   D. Coroutine

9. 在Go语言中，错误通常用什么类型返回？

   A. string

   B. error

   C. exception

   D. bool

10. 下面关于Go接口的说法，哪个是正确的？

    A. 接口必须显示实现

    B. 结构体自动实现接口中所有方法即实现接口

    C. 接口不能作为类型使用

    D. 接口中只能定义字段

---

17.2 判断题（共5题，每题1分）

11. Go语言支持继承机制。 ( )
12. Go语言中的数组长度是固定的。 ( )
13. defer语句用于延迟函数的执行直到当前函数结束。 ( )
14. Go的slice是动态数组。 ( )
15. panic和recover用于错误处理机制。 ( )

---

17.3 填空题（共5题，每题2分）

16. 用关键字___定义常量。
17. 用关键字___定义变量。
18. 切片的底层数据结构是___。
19. 结构体中绑定的方法第一个参数通常是___。
20. 使用___关键字启动一个新的goroutine。

---

17.4 简答题（共5题，每题4分）

21. 简述Go语言的变量声明方式。
22. 什么是切片？它和数组有什么区别？
23. Go语言如何实现并发？请简述goroutine和channel的作用。
24. 如何在Go语言中处理错误？
25. 介绍Go语言中接口的作用和特点。

---

17.5 编程题（共5题，每题6分）

26. 编写函数，实现两个整数的交换（交换两个变量的值）。

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

27. 编写函数，计算传入整数数组中所有元素的和。

func sum(arr []int) int {
    total := 0
    for _, v := range arr {
        total += v
    }
    return total
}

28. 编写函数，判断一个整数是否为素数。

func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

29. 定义结构体Person，包含姓名和年龄，并写一个方法打印个人信息。

type Person struct {
    Name string
    Age  int
}

func (p Person) PrintInfo() {
    fmt.Printf("姓名: %s, 年龄: %d\n", p.Name, p.Age)
}

30. 写一个函数，使用goroutine打印数字1到5，主函数等待所有goroutine完成。

import (
    "fmt"
    "sync"
)

func printNum(i int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Println(i)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go printNum(i, &wg)
    }
    wg.Wait()
}

---

练习题参考答案及简要解析

选择题

1. B --- Go程序入口函数是main()
2. C --- 常量用const声明
3. B --- uint是无符号整型
4. B --- Go没有while语句，用for实现类似功能
5. A --- Go函数用func定义，参数和返回类型明确
6. B --- make函数创建map
7. D --- 上述写法都合法
8. C --- Goroutine是Go语言轻量级并发单位
9. B --- 错误类型为error
10. B --- 结构体隐式实现接口

判断题

11. × --- Go不支持继承
12. √ --- 数组长度固定
13. √ --- defer延迟执行函数直到当前函数退出
14. √ --- slice是动态数组
15. √ --- panic和recover配合处理异常

填空题

16. const
17. var
18. 数组
19. 结构体变量（如p）
20. go

简答题

21. 变量声明可以用var声明，指定类型；函数内可以用:=简短声明。
22. 切片是基于数组的动态大小序列，长度可变。
23. Go通过goroutine实现轻量级线程，并用channel通信同步。
24. 错误通过多返回值返回，调用方判断error是否为nil处理。
25. 接口定义行为规范，结构体实现接口方法即实现接口，实现多态。

编程题

26-30题代码详见题目内容，均为标准答案。