Go语言基础之变量和常量

Go语言中有25个关键字

复制代码

break    default   func     interface  select  case     defer    go      map     struct  chan     else     goto     package   switch  const    fallthrough if      range    type  continue   for     import    return    var

Go语言中还有37个保留字

Constants: true false iota nil

Types: int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error

Functions: make len cap new append copy close delete complex real imag panic recover

变量

1、标准声明

go 复制代码

var name string
var age int
var isOk bool

2、批量声明

go 复制代码

var (
    name string
    age  int
    isOk bool
)

3、变量的初始化

go 复制代码

var name = "Alice"  // 自动推断为string
var age = 30        // 自动推断为int

go 复制代码

name, age := "Q1mi", 20   // 一次性初始化多个变量

4、短变量声明

go 复制代码

name := "Bob"
age := 25
isOk := true

5、匿名变量

如果想要忽略某个值，可以使用匿名变量（anonymous variable）； 匿名变量用一个下划线_表示

go 复制代码

value, _ := someFunction() // 忽略第二个返回值

注意事项：

函数外的所有语句（全局作用域）必须以关键字开头，例如 var、const、func 等。直接赋值操作

:= 不能在函数外使用，因为它属于短变量声明，仅限函数内局部作用域。

go 复制代码

var globalVar int = 10 // 合法：使用 var 关键字
const globalConst = "hello" // 合法：使用 const 关键字

// illegal := 10 // 错误：函数外不能使用 :=

常量

1、常量声明

javascript 复制代码

const pi = 3.1415
const e = 2.7182

go 复制代码

const (
    Monday = 1
    Tuesday = 2
    Wednesday = 3
)

2、多常量声明规则

在 Go 语言中，使用 const 声明多个常量时，如果某一行省略了值，则该常量会继承上一行常量的值。这种语法设计可以减少重复代码，提高可读性。

go 复制代码

const (
    a = 1
    b
    c = 2
    d
)

常量 a 被显式赋值为 1
常量 b 省略了值，因此继承 a 的值，同样为 1
常量 c 被显式赋值为 2
常量 d 省略了值，因此继承 c 的值，同样为 2

使用场景：

特别适合声明一组相关常量，其中部分常量具有相同值的情况，例如定义错误码或状态码时

3、iota

iota 是 Go 语言中的一个特殊常量计数器，仅在常量声明（const）中使用。其行为规则如下：

在 const 关键字出现时，iota 被重置为 0。
每新增一行常量声明（包括空行和注释行），iota 的值自动加 1。
iota 的值可以用于表达式，生成一组有规律的常量。

1、iota简单示例

go 复制代码

const (
    A = iota // 0
    B        // 1 (隐式重复上一行的表达式，即 B = iota)
    C        // 2
)

2、跳过某些值

go 复制代码

const (
    A = iota // 0
    _        // 1 (跳过)
    B        // 2
)

3、iota声明中间插队问题

go 复制代码

const (
    A = iota // 0
    B        // 1
    C = 42   // 42（插队）
    D = iota // 3（iota继续递增）
    E        // 4
)

4、表达式中的 iota

go 复制代码

const (
    A = iota * 2 // 0 (0 * 2)
    B            // 2 (1 * 2)
    C            // 4 (2 * 2)
)

5、自定义枚举类型

go 复制代码

type Status int

const (
    Pending Status = iota // 0
    Approved              // 1
    Rejected              // 2
)

6、多常量声明中的iota

go 复制代码

const (
    A, B = iota, iota + 1 // A=0, B=1
    C, D                  // C=1, D=2
)

核心规则：

iota 是行索引计数器：在 const 括号内， iota 的值从 0 开始，每新增一行常量声明， iota 的值就会自动加 1 。
表达式隐式继承：在 const 块中，如果某一行没有写赋值表达式，它会自动抄写（继承）上一行的表达式。

go 复制代码

const (
    X = iota     // X=0
    Y            // Y=1
    Z = iota + 2 // Z=2 + 2 = 4
    W            // W=3 + 2 = 5
)

可以把这种写法理解为一种"公式向下填充"的操作，每一行都套用同一个公式（变量1, 变量2 = iota, iota + 1 ），唯一的变量就是随着行数递增的 iota 。

iota 就是当前在第几行（从0开始数），如果后面没写等号，就照抄上一行的计算方式，然后把新的行号代进去算！