变量常量其实都是内存地址或者内存地址集合的抽象表现形式。

Go 语言变量名由字母、数字、下划线组成,其中首个字符不能为数字。

Go语言中变量的定义有多种形式:

1,var关键字明确定义变量:var identifier type

 package main
import "fmt"
// 全局变量
var a string = "Hello"
func main() {
    fmt.Println(a)
// 局部变量
    var b, c int = 1, 2
    fmt.Println(b, c)
}

// 变量的默认值

package main
import "fmt"
func main() {

    // 声明一个变量并初始化
    var a = "Hello"
    fmt.Println(a)

    // 没有初始化就为零值
    var b int
    fmt.Println(b)

    // bool 零值为 false
    var c bool
    fmt.Println(c)
}  
  • 数值类型(包括complex64/128)为 0
  • 布尔类型为 false
  • 字符串为 “” (空字符串)
  • 以下几种类型为 nil
  •  var a *int  // 指针
    var a []int // 数组
    var a map[string] int  // 列表
    var a chan int  //通道
    var a func(string) int //空函数
    var a error // error 是接口  

    2,根据值自行判定变量类型

     package main
    import "fmt"
    func main() {
      // 局部变量可以省略关键字使用 := 操作符
        d := true  // var d bool = true
        fmt.Println(d)
    }  

    3,常量的定义与常量特性

     const identifier [type] = value  

    你可以省略类型说明符 [type],因为编译器可以根据变量的值来推断其类型。

    • 显式类型定义: const b string = “abc”
    • 隐式类型定义: const b = “abc”

    多个相同类型的声明可以简写为:

     const c_name1, c_name2 = value1, value2  

    iota

    iota,特殊常量,可以认为是一个可以被编译器修改的常量。

    iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前),const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

    iota 可以被用作枚举值:

     const (
        a = iota
        b = iota
        c = iota
    )  

    第一个 iota 等于 0,每当 iota 在新的一行被使用时,它的值都会自动加 1;所以 a=0, b=1, c=2 可以简写为如下形式:

     const (
        a = iota
        b
        c
    )  

    用法

     package main
    
    import "fmt"
    
    func main() {
        const (
                a = iota   //0
                b          //1
                c          //2
                d = "ha"   //独立值,iota += 1
                e          //"ha"   iota += 1
                f = 100    //iota +=1
                g          //100  iota +=1
                h = iota   //7,恢复计数
                i          //8
        )
        fmt.Println(a,b,c,d,e,f,g,h,i)
    }  

    以上实例运行结果为:

     0 1 2 ha ha 100 100 7 8