Go语言基础之变量与常量

  |     |   本文总阅读量:

【基础篇】Go语言基础之变量与常量

几乎在所有编程语言中, 变量和常量是必不可少的存在。它们方便了我们对数据的存储和处理

标识符与关键字

变量

常量


标识符与关键字

  • 标识符

    所谓的标识符是指:在程序中定义的具有特殊含义的单词或符号等等,比如比较常见的:变量名、常量名、函数名等等。

    Go语言中的标识符主要由字母数字_(下划线)组成,但是不能以数字开头

  • 关键字

    关键字是语言本身预先定义好的特殊标识符,而关键字不能在程序中用作变量名。 比如:varconst等等

    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 complex64  complex128
                bool    byte    rune    string  error
    
    Functions:  make  len  cap  new  append  copy  close  delete
                complex  real  imag
                panic    recover

变量

  • 变量的声明

    • Go语言变量的标准声明格式:

      1
      var 变量名 变量类型
    • 示例代码:

      1
      2
      3
      var name string
      var age int
      var isTrue bool
    • Go语言变量的批量声明格式:

      1
      2
      3
      4
      5
      6
      var (
      变量名 变量类型
      变量名 变量类型
      变量名 变量类型
      ……
      )
    • 示例代码:

      1
      2
      3
      4
      5
      var (
      a string
      b int
      c bool
      )
  • 变量的初始化

    Go语言在声明变量时,会默认为对应的变量在内存区域进行初始化操作,每一个变量会被初始化为其对应类型的默认值。例如:整型和浮点型变量的默认值为 0,字符串变量的初始值为 空字符串,布尔值的默认值为 false,切片、函数、指针变量的默认值为 nil

    我们也可以在变量初始化时,手动指定其初始值

    • 变量初始化标准格式
      1
      2
      3
      4
      5
      6
      7
      // 基本格式
      var 变量名 变量类型 = 初始值/表达式
      var name string = "Golang"

      // 同时定义多个
      var 变量名, 变量名, …… = 变量值, 变量值, ……
      var name, age = "Golang", 10
    • 变量初始化类型推导

      Go语言中的类型推导是在定义变量时不进行手动的类型声明,而通过编译器自动根据等号右边的值来推导变量的类型

      1
      2
      3
      var 变量名 = 变量值
      var name = "Golang"
      var age = 10
    • 变量初始化短声明方式

      Go语言中可以通过使用 := 来声明并初始化变量,这种方式称为短变量声明法

      注意:此方式只适合在函数内部使用在Go语言的函数中,变量声明后必须使用,否则编译无法通过,全局变量无此限制

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

      import "fmt"

      // 声明全局变量
      var y = 100

      func main() {
      x := 10
      // 声明局部变量
      y := 200
      fmt.Println("x = ", x, "y = ", y) // 10 200
      }
    • 匿名变量

      在Go语言中使用多重赋值时,如果想要忽略某个值,可以使用 匿名变量(anonymous variable)。匿名变量用一个下划线(_)表示

      匿名变量不占用命名空间,不会分配内存,所以匿名变量之间不存在重复声明

      注意事项:

      • 函数外的每个语句必须以关键字开始(var、const、func等)
      • := 不能使用在函数外
      • _ 多用于占位,表示忽略值

常量

相对于变量,常量是恒定不变的值。在Go语言中常量使用 const 关键字来定义。常量多用于定义程序运行期间不会改变的那些值;常在声明时必须赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
> const PI = 3.1415926
> const successCode = 2000
>
> const (
> successCode = 2000
> errorCode = 5000
> )
>
> // 以下常量 x、y、z 都是100
> const (
> x = 100
> y
> z
> )
>
  • iota

    • iota 是Go语言的常量计数器,只能在常量的表达式中使用
    • iotaconst 关键字出现时将被重置为 0。const中每新增一行常量声明将会使iota计数一次
      1
      2
      3
      4
      5
      6
      7
      8
      const (
      x = iota // 0
      y // 1
      z // 2
      l // 3
      m // 4
      n // 5
      )
  • 常见的iota示例

    • 使用 _ 跳过某些值

      1
      2
      3
      4
      5
      6
      const (
      x = iota // 0
      y // 1
      _
      z // 3
      )
    • iota 声明中间插队

      1
      2
      3
      4
      5
      6
      7
      const (
      a = iota // 0
      b = 100 // 100
      c = iota // 2
      d // 3
      )
      const f = iota // 0
    • 多个 iota 定义在一行

      1
      2
      3
      4
      5
      const (
      a, b = iota + 1, iota + 2 // 1, 2
      c, d // 2, 3
      e, f // 3, 4
      )

赏作者一颗糖吧, 您的支持将鼓励我继续创作!



文章目录
  1. 1. 【基础篇】Go语言基础之变量与常量
    1. 1.0.1. 标识符与关键字
    2. 1.0.2. 变量
    3. 1.0.3. 常量
您是第 位小伙伴 | 本站总访问量 | 已经写了 18.8k 字啦

载入天数...载入时分秒...