【go语言基础知识总结】 | 青训营

一个奋起直追的菜鸟
70 阅读11分钟 
//本篇总结了go语言中需要掌握的基础知识，具体内容还需要细致的学习
  1. 语法结构：了解 Go 语言的基本语法结构，如变量声明、函数定义、条件语句、循环语句等。

  • 包（Package）：Go 语言的代码是以包的形式组织的，每个 Go 文件都属于一个包。使用关键字 package 来声明一个包，例如 package main。main 包是可执行程序的入口包。

  • 导入（Import）：通过关键字 import 导入其他包，例如 import "fmt"。导入的包可以使用其中的函数和类型。

  • 函数（Function）：使用关键字 func 定义函数，例如 func add(a, b int) int { return a + b }。函数可以有参数和返回值，函数名首字母大小写决定了其可见性。

  • 变量（Variable）：使用关键字 var 声明变量，例如 var name string。也可以使用简化的变量声明方式 name := "John" 来自动推导变量类型。

  • 常量（Constant）：使用关键字 const 声明常量，例如 const pi = 3.14。常量在声明时必须进行初始化，并且不能修改。

  • 控制流程：Go 语言提供了条件语句（if、else）、循环语句（for）和选择语句（switch）来实现控制流程。例如：

    • 条件语句：使用 if 和 else 来实现基本的条件判断。
    • 循环语句：使用 for 循环来重复执行一段代码块，可以使用 break 和 continue 控制循环的流程。
    • 选择语句：使用 switch 和 case 实现多分支选择，可以使用 default 来处理没有匹配的情况。
  1. 数据类型：Go 语言具有基本数据类型（如整数、浮点数、布尔值、字符串）和复合数据类型（如数组、切片、映射、结构体、接口）。可以使用关键字 var 或 := 声明变量并指定其类型。

    1. 基本数据类型：

      • 布尔类型（bool）：表示逻辑值，只有两个取值 true 和 false。
      • 数值类型：
        • 整数类型：包括有符号整数类型（int8、int16、int32、int64）和无符号整数类型（uint8、uint16、uint32、uint64）。
        • 浮点数类型：包括浮点数（float32、float64）和复数类型（complex64、complex128）。
      • 字符串类型（string）：表示字符序列，使用双引号或反引号括起来。
      • 字符类型（rune）：表示 Unicode 字符，类似于整数类型，用单引号括起来。
      • 错误类型（error）：用于表示错误信息的类型。

    2. 复合数据类型：

      • 数组（Array）：具有固定长度和类型的数据集合，用于存储相同类型的元素。
      • 切片（Slice）：是对数组的一个连续片段的引用，比数组更灵活，长度可变。
      • 映射（Map）：键值对的集合，用于存储具有唯一键和对应值的数据。
      • 结构体（Struct）：可以自定义的复合数据类型，由多个字段组成，每个字段可以是不同类型的数据。
      • 接口（Interface）：用于定义对象的行为，它是一组方法的集合，实现了这组方法的类型就属于该接口。
      • 函数类型（Function）：可以将函数作为参数或返回值的类型。

    3. 指针类型（Pointer）：表示变量的内存地址，通过指针可以直接操作变量的值。

    除了上述的内置数据类型，Go 语言还支持用户自定义类型，可以使用 type 关键字创建新的类型。

    在 Go 语言中，类型推导是一项强大的特性，可以根据上下文自动推导出变量的类型。这样可以简化代码，并提高可读性。

    为了提高代码的性能和可读性，Go 语言还引入了零值的概念。在变量声明但未显式初始化时，其会被赋予该类型的零值。例如，数值类型的零值为 0，布尔类型的零值为 false，字符串类型的零值为空字符串。

  1. 结构体（Struct）：使用 type 和 struct 关键字定义结构体，结构体是一种自定义的复合数据类型，可以包含多个字段。

在 Go 语言中，结构体（Struct）是一种复合数据类型，用于组织和存储多个相关字段的集合。结构体的字段可以是不同类型的数据，通过字段名可以访问和修改结构体中的数据。

结构体的定义使用 type 和 struct 关键字，下面是一个示例：

type Person struct {
    Name string
    Age  int
}

在上面的例子中，我们定义了一个名为 Person 的结构体，它有两个字段：Name 和 Age，分别表示人的姓名和年龄。字段的类型可以是任意合法的 Go 类型。

使用结构体可以创建自定义的数据类型，并实例化该类型的对象。下面是一个示例：

func main() {
    // 创建一个 Person 结构体对象
    person := Person{
        Name: "Alice",
        Age:  25,
    }

    // 访问和修改字段的值
    fmt.Println(person.Name) // 输出："Alice"
    person.Age = 26
    fmt.Println(person.Age)  // 输出：26
}

结构体对象可以通过点操作符 . 来访问和修改字段。在上面的例子中，我们创建了一个 Person 结构体对象，并分别输出了 Name 和 Age 字段的值。

除了字段，结构体还可以拥有方法，这些方法可以通过接收者（Receiver）来关联到结构体类型上。通过在方法定义前面加上接收者类型，可以将方法与结构体绑定，并可以通过结构体实例来调用该方法。这种方式可以实现对结构体的行为进行封装和扩展。以下是一个示例：

func (p Person) SayHello() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}

func main() {
    person := Person{
        Name: "Alice",
        Age:  25,
    }

    person.SayHello() // 输出："Hello, my name is Alice"
}

在上述代码中，我们定义了一个名为 SayHello 的方法，它与 Person 结构体关联。通过调用 person.SayHello()，可以输出该人的姓名。

结构体是 Go 语言中重要的数据结构之一，它提供了一种灵活的方式来组织数据，并可以在程序中进行传递、修改和操作。通过结构体，可以更好地描述和抽象现实世界中的对象和实体。

  1. 并发编程：Go 语言天生支持并发编程，使用协程（goroutine）和通道（channel）来实现并发操作。协程是轻量级的线程，可以通过关键字 go 启动，通道用于协程之间的通信。

    1. Goroutines（协程）：Goroutines 是 Go 语言中轻量级的并发执行单位。它们与传统的线程相比，具有更小的栈内存消耗（默认为 2KB），可以高效地创建和销毁，并可以并发执行大量的 Goroutines。

    2. Channels（通道）：Channels 是 Goroutines 之间通信和同步的机制。它是一种类型安全的、阻塞的并发数据结构，可以用于在 Goroutines 之间传递数据。通过使用通道，可以避免共享内存导致的并发访问问题，确保多个 Goroutines 之间的安全访问和同步。

    3. Select 语句：Select 语句用于在多个通道上进行非阻塞的接收操作，从而实现多路复用。它允许 Goroutines 同时等待多个通道的操作，并在其中一个通道就绪时执行相应的操作。

    4. Mutex（互斥锁）和 RWMutex（读写互斥锁）：这些是用于实现互斥访问共享资源的同步原语。Mutex 提供了基本的互斥操作，用于保护临界区的访问。RWMutex 允许多个 Goroutines 并发地读取共享资源，但只能有一个 Goroutine 写入共享资源。

    5. WaitGroup（等待组）：WaitGroup 是一种用于等待 Goroutines 完成的机制。通过在主 Goroutine 中添加 Goroutines 到 WaitGroup，然后使用 WaitGroup 的 Wait 方法等待所有 Goroutines 完成，可以实现阻塞主 Goroutine 直到所有 Goroutines 执行完毕。

    6. Atomic（原子操作）：Go 语言提供了 atomic 包，其中包含一些原子操作函数，用于对共享变量进行原子操作，避免了并发访问时的竞态条件。

    7. Context（上下文）：Context 包提供了在 Goroutines 之间传递请求范围数据、取消 Goroutines 执行以及处理超时的机制。它在编写长时间运行的并发程序时非常有用。

  1. 控制流程：掌握条件语句（if、switch）和循环语句（for）的使用方式，以及如何处理错误和异常。

条件语句（if-else）：条件语句用于根据给定条件来选择性地执行某个代码块。在 Go 语言中，if-else 语句的语法结构如下：

if condition {
    // 当条件为真时执行的代码块
} else {
    // 当条件为假时执行的代码块
}

  • 函数和方法：了解如何定义和调用函数，包括函数的参数和返回值。同时，理解方法的概念和使用方式。

  • 在 Go 语言中，函数（Function）和方法（Method）是组织和封装可重用代码的关键元素。下面我将为你介绍 Go 语言中的函数和方法的概念以及它们之间的区别。

    函数（Function）是一段具有特定功能的独立代码块，它接受零个或多个参数，并返回一个或多个值。在 Go 语言中，函数有以下特点：

定义函数的语法如下：

func functionName(parameter1 type1, parameter2 type2, ...) returnType {
    // 函数体
    return value
}
  • functionName：函数的名称，遵循标识符命名规则。
  • parameter1, parameter2：函数的参数列表，每个参数都包含一个名称和类型。
  • returnType：函数返回值的类型，在函数执行完毕后可以通过 return 语句返回相应的值。

  1. Go 语言支持多返回值，一个函数可以返回多个值，用逗号分隔。

  2. 函数可以作为一种类型，可以被赋值给变量、作为参数传递给其他函数或作为返回值。

  3. 可以使用可变参数的函数，在参数列表中使用 ... 表示。

方法（Method）是与某个特定对象相关联的函数，它在面向对象编程中起到了重要的作用。在 Go 语言中，方法是定义在结构体（Struct）或任意类型（除指针类型之外）上的函数，它有以下特点：

  1. 方法是通过将接收者作为函数的首个参数来定义的。

  2. 接收者可以是结构体类型或非结构体类型。

  3. 方法在定义时需要指定接收者的类型。

  4. 调用方法时，接收者会成为方法的主体，可以通过接收者访问字段和调用其他方法。

  5. 方法可以具有值接收者或指针接收者。值接收者使用值的副本进行操作，而指针接收者使用指针来操作原始值。

方法的定义如下：

func (receiverType) methodName(parameter1 type1, parameter2 type2, ...) returnType {
    // 方法体
    return value
}
  • receiverType：接收者的类型。
  • methodName：方法的名称，遵循标识符命名规则。
  • parameter1, parameter2：方法的参数列表，每个参数都包含一个名称和类型。
  • returnType：方法返回值的类型，在方法执行完毕后可以通过 return 语句返回相应的值。
  1. 包和模块：了解包的概念，学习如何创建自定义的包，并理解如何导入和使用其他包。

  • 包（Package）是一组相关的 Go 源代码文件的集合，通常包含了一组函数、方法、结构体和变量等。包的作用是提供命名空间、代码复用和模块化等特性，便于代码的组织和管理。在 Go 语言中，每个源文件都必须属于一个包，通过在文件的开头使用 package 关键字来声明包的名称。

    例如，一个名为 math 的包可以包含一些数学相关的函数和常量，可以在其他代码文件中引用该包中的函数和常量。

  •   package math
  
  import "fmt"
  
  func Add(a, b int) int {
      return a + b
  }
  
  const Pi = 3.14159

  • 在另一个代码文件中可以引用 math 包中的函数和常量：

    package main

    import ( "fmt" "path/to/math" )

    func main() { sum := math.Add(2, 3) fmt.Println(sum) // 输出：5 fmt.Println(math.Pi) // 输出：3.14159 }

模块（Module）是引入自 Go 1.11 版本的模块化管理工具。一个模块是由一个或多个相关包组成的集合，它们被放置在一个特定的目录中。模块有一个唯一的模块名称（通常是包含目录的路径），并且具有自己的版本号。

模块使用 Go Modules 工具来管理包和版本。通过在项目的根目录中初始化模块，并定义所需的依赖项，Go Modules 会自动下载依赖的包，并确保使用正确的版本。模块的版本信息会记录在项目的 go.mod 文件中。

module github.com/user/myproject

go 1.16

require (
    github.com/somepackage v1.2.3
    github.com/anotherpackage v0.1.0
)

模块的名称可以是本地路径，也可以是远程代码托管平台上的 URL。模块的版本号遵循语义化版本规范，可以确保版本之间的向后兼容性。

使用模块可以更好地管理和控制项目的依赖关系，同时提供了更好的代码复用和版本管理的能力。

avatar
文章
阅读
粉丝