第 4 章 变量与常量

4.1 变量

作用:给一段指定的内存空间起名,方便操作这段内存。

声明变量的一般形式是使用 var 关键字。

  • 方法一:声明一个变量, 默认的值是 0

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package main

    import "fmt"

    func main(){
    // 方法一:声明一个变量, 默认的值是0
    var a int
    fmt.Println("a = ", a)
    fmt.Printf("a的类型是: %T\n", a)
    }
  • 方法二:声明一个变量, 并初始化一个值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    package main

    import "fmt"

    func main(){
    // 方法二:声明一个变量, 初始化一个值
    var b int = 100
    fmt.Printf("b = %d, type of b = %T\n", b, b)

    var bb string = "从0到Go语言微服务架构师"
    fmt.Printf("bb = %s, bb的类型是: %T\n", bb, bb)
    }
  • 方法三:在初始化的时候,可以省去数据类型,通过值去自动匹配当前变量的数据类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package main

    import "fmt"

    func main(){

    // 方法三:在初始化的时候,可以省去数据类型,通过值去自动匹配当前变量的数据类型
    var c = 100
    fmt.Printf("c = %d, type of c = %T\n", c, c)

    var cc = "Go语言微服务架构师核心22讲"
    fmt.Printf("cc = %s, cc的类型是: %T\n", cc, cc)
    }
  • 短声明,只能在函数内

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package main

    import "fmt"

    func main(){

    // 方法四:(常用的方法) 省去var关键字,使用:=,既推导数据类型又赋值
    // 注: 短声明是在函数或方法内部使用, 不支持全局变量声明!!!!
    e := 100
    fmt.Printf("e = %d, e的类型是: %T\n", e, e)

    f := "Go语言极简一本通"
    fmt.Printf("f = %s, f的类型是: %T\n", f, f)
    }
  • 多变量声明

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package main

    import "fmt"

    func main(){
    // 声明多个变量
    var xx, yy int = 100, 200
    var kk, wx = 300, "write_code_666(欢喜哥)"

    var (
    nn int = 100
    mm bool = true
    )
    }

4.2 常量

常量(constant)表示固定的值。在计算机程序运行时,不会被程序修改的。

  • 定义一个常量,使用 const 关键字。常量定义的时候就要赋值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package main

    import "fmt"

    func main(){
    // 常量(只读属性)
    const length int = 10
    // length = 100 // 常量是不允许被修改的
    fmt.Println("length = ", length)
    }
  • 使用 const 来定义枚举类型

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    package main

    import "fmt"

    // const来定义枚举类型
    const (
    BEIJING = 0
    SHANGHAI = 1
    SHENZHEN = 2
    )

    func main() {
    fmt.Println("BEIJING = ", BEIJING) // 0
    fmt.Println("SHANGHAI = ", SHANGHAI) // 1
    fmt.Println("SHENZHEN = ", SHENZHEN) // 2
    }
  • iota

    iota 是 Go 语言的常量计数器,只能在常量的表达式中使用。
    iota 在 const 关键字出现时将被重置为 0(const 内部的第一行之前),const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。使用 iota 能简化定义,在定义枚举时很有用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    package main

    import "fmt"

    // const来定义枚举类型
    const (
    // 可以在const()中添加一个关键字iota, 每行的iota都会累加1, 第一行的iota默认是0
    BEIJING = 10 * iota // iota = 0
    SHANGHAI // iota = 1
    SHENZHEN // iota = 2
    )

    func main() {
    fmt.Println("BEIJING = ", BEIJING) // 0
    fmt.Println("SHANGHAI = ", SHANGHAI) // 10
    fmt.Println("SHENZHEN = ", SHENZHEN) // 20
    }

4.3 关键字

关键字是 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语言微服务,快速步入架构师

从0到Go语言微服务架构师-海报 从0到Go语言微服务架构师
添加微信 公众号更多内容
wechat gzh