Golang 速成 | 变量及常量

变量

单变量声明

第一种，指定变量类型，声明后若不赋值，使用默认值 0 ：

var v_name v_type
v_name = value

package main

import "fmt"

func main() {
    var a int
    fmt.Printf(" = %d\n", a)
}

/*
$go run test.go
a = 0
*/

第二种，根据值自行判定变量类型：

var v_name = value

第三种，省略 var , 注意 := 左侧的变量必须未声明，并且该声明在函数体内，否则会导致编译错误：

v_name := value

// 例如
var a int = 10
var b = 10
c : = 10

示例：

package main


import "fmt"


func main() {
    //第一种 使用默认值
    var a int
    fmt.Printf("a = %d\n", a)


    //第二种
    var b int = 10
    fmt.Printf("b = %d\n", b)


    //第三种 省略后面的数据类型,自动匹配类型
    var c = 20
    fmt.Printf("c = %d\n", c)


    //第四种 省略var关键字
    d := 3.14
    fmt.Printf("d = %f\n", d)
}

多变量声明

package main


import "fmt"


var x, y int
var (
    //这种分解的写法,一般用于声明全局变量
    a int
    b bool
)


var c, d int = 1, 2
var e, f = 123, "liudanbing"


//这种不带声明格式的只能在函数体内声明
//g, h := 123, "需要在func函数体内实现"


func main() {
    g, h := 123, "需要在func函数体内实现"
    fmt.Println(x, y, a, b, c, d, e, f, g, h)


    //不能对g变量再次做初始化声明
    //g := 400


    _, value := 7, 5  //实际上7的赋值被废弃，变量 _  不具备读特性
    //fmt.Println(_) //_变量的是读不出来的
    fmt.Println(value) //5
}

源码

package main

/*
    四种变量的声明方式
*/

import (
    "fmt"
)

//声明全局变量 方法一、方法二、方法三是可以的
var gA int = 100
var gB = 200

//用方法四来声明全局变量
// := 只能够用在 函数体内来声明
//gC := 200

func main() {
    //方法一：声明一个变量 默认的值是0
    var a int
    fmt.Println("a = ", a)
    fmt.Printf("type of a = %T\n", a)

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

    var bb string = "abcd"
    fmt.Printf("bb = %s, type of bb = %T\n", bb, bb)

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

    var cc = "abcd"
    fmt.Printf("cc = %s, type of cc = %T\n", cc, cc)

    //方法四：(常用的方法) 省去var关键字，直接自动匹配
    e := 100
    fmt.Println("e = ", e)
    fmt.Printf("type of e = %T\n", e)

    f := "abcd"
    fmt.Println("f = ", f)
    fmt.Printf("type of f = %T\n", f)

    g := 3.14
    fmt.Println("g = ", g)
    fmt.Printf("type of g = %T\n", g)

    // =====
    fmt.Println("gA = ", gA, ", gB = ", gB)
    //fmt.Println("gC = ", gC)

    // 声明多个变量
    var xx, yy int = 100, 200
    fmt.Println("xx = ", xx, ", yy = ", yy)
    var kk, ll = 100, "Aceld"
    fmt.Println("kk = ", kk, ", ll = ", ll)

    //多行的多变量声明
    var (
       vv int  = 100
       jj bool = true
    )
    fmt.Println("vv = ", vv, ", jj = ", jj)
}

常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

const identifier [type] = value

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

//显式类型定义
const b string = "abc"

//隐式类型定义
const b = "abc"

示例：

package main


import "fmt"


func main() {
   const LENGTH int = 10
   const WIDTH int = 5
   var area int
   const a, b, c = 1, false, "str" //多重赋值


   area = LENGTH * WIDTH
   fmt.Printf("面积为 : %d\n", area)
   println(a, b, c)
}

/*
运行结果：
面积为 : 50
1 false str
*/

用作枚举：

const (
    Unknown = 0
    Female = 1
    Male = 2
)

常量可以用 len() , cap() , unsafe.Sizeof() 常量计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不通过：

package main


import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)


func main(){
    println(a, b, c)
}

输出结果为：abc, 3, 16

unsafe.Sizeof(a) 输出的结果是 16 ，因为字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度，这两部分每部分都是 8 个字节，所以字符串类型大小为 16 个字节。

优雅的常量 iota

在 golang 中，一个方便的习惯就是使用 iota 标示符，它简化了常量用于增长数字的定义，给以上相同的值以准确的分类：

const (
    CategoryBooks = iota // 0
    CategoryHealth       // 1
    CategoryClothing     // 2
)

iota 每经过一行，会增加 1 ，第一行的初始值为 0 。此外，还能对 iota 进行一些运算：

const (
    Apple, Banana = iota + 1, iota + 2
    Cherimoya, Durian
    Elderberry, Fig
)

第一行之后，下面每一行的常量也会被赋值为 iota + 1, iota + 2 ，最终结果为：

Apple: 1       // 此时 iota 为 0
Banana: 2
Cherimoya: 2   // 此时 iota 为 1
Durian: 3
Elderberry: 3  // 此时 iota 为 2
Fig: 4

源码

package main

import "fmt"

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

const (
    a, b = iota+1, iota+2 // iota = 0, a = iota + 1, b = iota + 2, a = 1, b = 2    c, d              // iota = 1, c = iota + 1, d = iota + 2, c = 2, d = 3    e, f              // iota = 2, e = iota + 1, f = iota + 2, e = 3, f = 4
    g, h = iota * 2, iota *3  // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9i, k                  // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12)

func main() {
    //常量(只读属性)
    const length int = 10

    fmt.Println("length = ", length)

    //length = 100 //常量是不允许修改的。

    fmt.Println("BEIJIGN = ", BEIJING)
    fmt.Println("SHANGHAI = ", SHANGHAI)
    fmt.Println("SHENZHEN = ", SHENZHEN)

    fmt.Println("a = ", a, "b = ", b)
    fmt.Println("c = ", c, "d = ", d)
    fmt.Println("e = ", e, "f = ", f)

    fmt.Println("g = ", g, "h = ", h)
    fmt.Println("i = ", i, "k = ", k)

    // iota 只能够配合const() 一起使用， iota只有在const进行累加效果。
    //var a int = iota
}