Bob自习室

Appearance

Go 基础知识点（必会） ​

1. Go 语言基础语法 ​

  • Hello, World!：了解 Go 语言的基本结构。

    go
      // 1. 这是 Go 语言程序的入口。main 包是 Go 程序的启动点，程序运行时会从 main 包中的 main 函数开始执行。
  // 2. 每个 Go 程序必须有且只有一个 main 包，表示程序的入口。
  package main

  // 1. 这是导入 Go 标准库中的 fmt 包，fmt 包提供了格式化输入输出的功能（例如打印信息到控制台）。
  // 2. import 语句用于在程序中引入其他包，"fmt" 就是指向标准库中的 fmt 包。
  import "fmt"

  // 1. 这是一个函数定义。main 是 Go 程序的入口函数，程序会从这个函数开始执行。
  // 2. func 关键字表示定义一个函数。
  func main() {
      // 1. 这行代码调用了 fmt 包中的 Println 函数，将字符串 "Hello, World!" 输出到控制台。
      // 2. Println 会打印内容，并在末尾自动添加一个换行符。
      fmt.Println("Hello, World!")
  }

  • 注释：单行注释和多行注释。

    与 JavaScript、Java 等语言相同，不再赘述。

    go
    // This is a single line comment
/*
   This is a multi-line comment
*/

2. 变量和常量 ​

  • 变量声明：使用 var 和 := 进行变量声明。

    go
      // 1. 显式指定类型
  var x int = 10

  // 2. 隐式指定类型
  var y = 20

  // 3. 简短声明（推荐）：短变量声明，用于在函数内部声明并初始化变量。
  z := 30

  // 4. 多变量声明
  var a, b, c int = 1, 2, 3
  var d, e, f = 4, 5, "Test"

    与 Java、JavaScript 等语言的区别

    • Java：Java 是强类型语言，所有变量都需要指定类型。
      • int x = 10; // x 是 int 类型
      • double y = 20.5; // y 是 double 类型
      • char letter = 'A'; // letter 是 char 类型
      • boolean isActive = true; // isActive 是 boolean 类型
    • JavaScript：
      • let x = 10; // TypeScript 自动推导 x 为 number 类型
      • let y = "Hello"; // TypeScript 自动推导 y 为 string 类型
      • let z = [1, 2, 3]; // TypeScript 自动推导 z 为 number[] 类型
      • TS 标准写法：
        • let x: number = 10; // x 是一个 number 类型
        • let y: string = "Hello"; // y 是一个 string 类型
        • let z: boolean = true; // z 是一个 boolean 类型

  • 常量：使用 const 声明常量。

    go
    const Pi = 3.14

3. 数据类型 ​

  • 基本数据类型：

    • 整数：int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, byte, rune
    • 浮动数：float32, float64
    • 布尔值：bool
    • 字符串：string

  • 零值：Go 中所有变量都有零值（如 0，false，"" 等）。

  • 类型转换：通过显式转换进行数据类型转换。

    go
    var x int = 10
var y float64 = float64(x)

知识点汇总

  1. 带有u的表示“无符号整数”，不带u的表示“有符号整数”。无符号整数，只能表示正数（包括零）。

  2. string 类型表示字符串，Go 中的字符串是不可变的，字符串是一个字符的集合。

  3. 每个类型在声明时没有显式初始化时都会有一个“零值”，例如：

    • int 的零值是 0。
    • bool 的零值是 false。
    • string 的零值是空字符串 ""。
    • float64 的零值是 0.0。

  4. Go 中的类型转换是显式的，必须使用语法进行转换。

  5. Go 语言支持常量（constant）。常量在程序运行期间不可改变，可以是布尔值、数字、字符串等。

  6. iota：在常量声明中，iota 是一个特殊的常量，它会在每行常量的声明中自动递增，用于生成一系列常量值。

  7. 类型别名：可以使用 type 创建类型的别名。

    go
    type MyInt int  // MyInt 是 int 的别名

  8. Go 支持指针，但不支持指针运算。指针用来存储变量的内存地址。

    go
    var x int = 58
var p *int = &x  // p 存储 x 的地址
fmt.Println(*p)   // 解引用，打印 x 的值

// 备注：
// 1. &：取地址操作符，返回一个变量的内存地址。
// 2. *：解引用操作符，获取指针所指向地址的值。

4. 流程控制 ​

  • 条件语句：if, else，switch

    go
    if x > 10 {
    fmt.Println("Greater than 10")
} else {
    fmt.Println("Less than or equal to 10")
}

  • 循环：for 循环，支持 for, for ... range 循环。

    go
    for i := 0; i < 5; i++ {
    fmt.Println(i)
}
// 或者
for i, v := range arr {
    fmt.Println(i, v)
}

小贴士

与 JavaScript 相比，判断中没有小括号，这是较大的一个区别。

5. 函数 ​

  • 函数声明：定义函数时，可以指定返回类型。

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

  • 返回多个值：Go 函数支持返回多个值。

    go
    func swap(x, y int) (int, int) {
    return y, x
}

  • 匿名函数：可以定义没有名字的函数。

    go
    f := func(x int) int { return x * 2 }
fmt.Println(f(5))

小贴士

项目GoJava
参数语法func add(a int, b int) intint add(int a, int b)
区别点类型写在变量名后面类型写在变量名前面
返回值可以返回多个值，用 (type1, type2) 表示只能返回一个值，要返回多个用对象或数组等

6. 数组与切片 ​

  • 数组：固定大小的集合。

    go
    var arr [5]int
arr[0] = 1

  • 切片：动态数组，支持动态增删。

    go
    var slice = []int{1, 2, 3}
slice = append(slice, 4)

    小贴士：数组 vs 切片 对比总结

    项目数组 array切片 slice
    是否固定是否，动态增长
    是否常用较少极常用
    类型值类型引用类型
    传参方式拷贝整个数组拷贝引用，效率高
    适用场景固定长度数据结构（如缓存）任意长度数据，遍历处理，大数据集
    是否支持 append❌✅

7. Map（映射） ​

  • Map 的定义与操作：Go 中的 map 类似于其他语言的哈希表或字典。

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

    小贴士

    Go 中的 map（映射），是 Go 非常核心的数据结构之一，功能类似于 JavaScript 的对象（Object）、Python 的字典（dict）、Java 的 HashMap。

8. 结构体 ​

  • 结构体定义：用于组织不同类型的数据。

    go
    type Person struct {
    Name string
    Age  int
}
p := Person{Name: "John", Age: 30}
fmt.Println(p.Name)

  • 结构体方法：为结构体定义方法。

    go
    func (p Person) greet() {
    fmt.Println("Hello, " + p.Name)
}
p.greet()

    小贴士

    Go 的结构体（struct）是用来定义和组织一组不同类型数据的核心工具，类似于 Java 中的类（class），但它不支持继承。

9. 接口 ​

  • 定义接口：Go 通过接口来定义行为，而不是继承。

    go
    type Speaker interface {
    Speak() string
}

  • 实现接口：一个类型实现接口，只需要提供接口中的所有方法。

    go
      // 表示我们要定义一个结构体（struct），它是一组字段的集合。
  type Person struct {
      Name string
  }

  func (p Person) Speak() string {
      return "Hello, " + p.Name
  }

  func main() {
      tom := Person{Name: "Tom"}
      fmt.Println(tom.Speak()) // 输出：Hello, Tom
  }

10. 错误处理 ​

  • error 类型：Go 通过返回 error 类型来处理错误。

    go
    func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

11. 并发编程 ​

  • Goroutines：Go 通过 goroutines 来实现轻量级线程。

    go
    go func() {
    fmt.Println("This runs in a goroutine")
}()

  • Channels：Go 的 goroutine 通过 channels 进行通信。

    go
    ch := make(chan int)
go func() {
    ch <- 1
}()
fmt.Println(<-ch)  // 从 channel 中接收数据

12. 包和导入 ​

  • 包导入：Go 使用 import 语句来引入其他包。

    go
    import "fmt"
fmt.Println("Hello, Go!")

  • 自定义包：创建自定义的 Go 包，并使用 import 导入使用。

13. 延迟和恢复（Defer, Panic, Recover） ​

  • defer：在函数返回前执行代码。

    go
    func test() {
    defer fmt.Println("This will be printed last")
    fmt.Println("First")
}

  • panic：用于触发运行时错误。

    go
    panic("something went wrong")

  • recover：在 defer 中恢复 panic。

    go
    func safeFunc() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from", r)
        }
    }()
    panic("something went wrong")
}

14. Go 语言工具 ​

  • Go Modules：用于依赖管理，go.mod 和 go.sum 文件。
  • go run：运行 Go 程序。
  • go build：编译 Go 程序。
  • go fmt：自动格式化代码。
  • go test：执行单元测试。

15. 标准库 ​

  • fmt：格式化输出。
  • strings：字符串处理。
  • time：日期和时间处理。
  • math：数学函数。
  • net/http：构建 HTTP 服务。