Go 关键字全面汇总

目录

Go 关键字全面汇总

一、基础数据类型相关关键字

二、流程控制相关关键字

三、函数和方法相关关键字

四、类型和接口相关关键字

五、并发编程相关关键字

六、其他关键字

---

在 Go 语言编程中，关键字是被语言保留的具有特殊含义的标识符，不能用作自定义的变量名、函数名、类型名等。以下是对 Go 中所有关键字的全面介绍。

一、基础数据类型相关关键字

1. bool：用于表示布尔类型，其值只能是 true 或 false，常用于逻辑判断。例如：

var isOk bool = true

1. byte：本质上是 uint8 的别名，用于存储字节数据，常用来处理字符的 ASCII 码等。例如：

var b byte = 'a'

1. rune：等价于 int32，用于表示 Unicode 码点，主要用于处理包含非 ASCII 字符的字符串。例如：

var r rune = '中'

1. int、int8、int16、int32、int64：不同精度的整数类型，int 的大小通常取决于运行环境（32 位或 64 位），其他几种明确指定了位数。例如：

var num1 int = 10
var num2 int8 = 8

1. uint、uint8、uint16、uint32、uint64：无符号整数类型，与对应的有符号整数类型类似，只是只能表示非负数值。例如：

var uNum uint = 100

1. float32、float64：用于表示浮点数，float32 精度较低，float64 精度较高，是常用的浮点数类型。例如：

var f1 float32 = 3.14
var f2 float64 = 2.71828

1. complex64、complex128：用于表示复数，complex64 的实部和虚部为 32 位浮点数，complex128 的实部和虚部为 64 位浮点数。例如：

var c complex64 = complex(1, 2)

1. string：表示字符串类型，用于存储文本数据。例如：

var str string = "Hello, World!"

二、流程控制相关关键字

1. if：用于条件判断语句，根据条件表达式的真假决定是否执行相应的代码块。可以带有可选的 else 和 else if 分支。例如：

num := 10
if num > 5 {
    println("大于 5")
} else if num == 5 {
    println("等于 5")
} else {
    println("小于 5")
}

1. for：Go 语言中唯一的循环关键字，可用于实现各种循环结构，包括类似于 C 语言的 for 循环、while 循环和 do-while 循环。例如：

// 类似 C 语言的 for 循环
for i := 0; i < 5; i++ {
    println(i)
}

// 类似 while 循环
j := 0
for j < 5 {
    println(j)
    j++
}

// 无限循环
for {
    println("无限循环")
}

1. switch：用于多分支选择结构，比一系列的 if-else 语句更简洁。switch 后面的表达式可以省略，此时会匹配 true。例如：

num := 3
switch num {
case 1:
    println("1")
case 2:
    println("2")
case 3:
    println("3")
default:
    println("其他")
}

// 省略表达式的 switch
value := 10
switch {
case value > 5:
    println("大于 5")
case value == 5:
    println("等于 5")
default:
    println("小于 5")
}

1. case：在 switch 语句中定义具体的分支条件和相应的代码块。
2. default：switch 语句中的默认分支，当没有 case 匹配时执行。
3. break：用于跳出当前的 for、switch 或 select 语句。例如：

for i := 0; i < 5; i++ {
    if i == 3 {
        break
    }
    println(i)
}

1. continue：用于跳过本次循环中剩余的代码，直接开始下一次循环。例如：

for i := 0; i < 5; i++ {
    if i == 2 {
        continue
    }
    println(i)
}

三、函数和方法相关关键字

1. func：用于定义函数或方法。函数是一段独立的代码块，方法是与特定类型关联的函数。例如：

// 定义函数
func add(a, b int) int {
    return a + b
}

// 定义方法
type Person struct {
    Name string
}

func (p Person) SayHello() {
    println("Hello, my name is", p.Name)
}

1. return：用于从函数中返回值，可以返回一个或多个值。例如：

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

四、类型和接口相关关键字

1. type：用于定义新的类型，可以是结构体、联合体、接口、函数类型等。例如：

// 定义结构体类型
type Point struct {
    X, Y int
}

// 定义接口类型
type Shape interface {
    Area() float64
}

1. interface：用于定义接口，接口是一组方法签名的集合，实现接口的类型必须提供接口中定义的所有方法。例如：

type Animal interface {
    Speak() string
}

type Dog struct{}

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

1. struct：用于定义结构体类型，结构体是一种聚合类型，可以包含多个不同类型的字段。例如：

type Student struct {
    Name    string
    Age     int
    Gender  string
}

五、并发编程相关关键字

1. go：用于启动一个新的 goroutine（轻量级线程），实现并发编程。例如：

func printNumbers() {
    for i := 0; i < 5; i++ {
        println(i)
    }
}

func main() {
    go printNumbers()
    // 主 goroutine 继续执行其他任务
    // 为了让程序不立即退出，可以添加一些等待逻辑
    time.Sleep(time.Second)
}

1. select：用于在多个通信操作（如通道操作）之间进行选择，实现多路复用。例如：

ch1 := make(chan int)
ch2 := make(chan int)

go func() {
    ch1 <- 1
}()

go func() {
    ch2 <- 2
}()

select {
case num1 := <-ch1:
    println("从 ch1 接收:", num1)
case num2 := <-ch2:
    println("从 ch2 接收:", num2)
}

1. chan：用于定义通道类型，通道是 goroutine 之间进行通信和同步的重要工具。例如：

ch := make(chan int)
go func() {
    ch <- 10
}()
num := <-ch
println(num)

六、其他关键字

1. import：用于导入包，使当前代码可以使用包中导出的函数、类型和变量等。例如：

import (
    "fmt"
    "math"
)

1. package：用于声明当前代码所属的包，每个 Go 源文件都必须有一个 package 声明。例如：

package main

1. defer：用于延迟执行一个函数或方法调用，在函数返回前会按照先进后出的顺序执行 defer 语句。例如：

func main() {
    defer println("这是最后执行的")
    println("这是先执行的")
}

1. fallthrough：在 switch 语句中使用，用于强制执行下一个 case 块的代码，即使不满足下一个 case 的条件。例如：

num := 2
switch num {
case 1:
    println("1")
    fallthrough
case 2:
    println("2")
    fallthrough
case 3:
    println("3")
}

1. range：用于遍历数组、切片、字符串、映射和通道等集合类型。例如：

// 遍历切片
nums := []int{1, 2, 3}
for index, value := range nums {
    println(index, value)
}

// 遍历映射
m := map[string]int{"a": 1, "b": 2}
for key, value := range m {
    println(key, value)
}

Go 语言的这些关键字构成了其语法的核心部分，熟练掌握它们对于编写高效、简洁的 Go 程序至关重要。通过合理运用这些关键字，可以实现各种复杂的功能，从基础的数据处理到并发编程等。