Go Const 常量

1/25/2019 go

# Go_Const(常量)

# 常量

常量是一个简单值的标识符,在程序运行时,不会被修改的量。 常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型。

常量的定义格式: const identifier [type] = value

[type]类型可以省略,编译器可以根据变量的值来推断其类型.
显示类型 const b string = "abc"
隐式类型 const b = "abc"
1
2
3
多个相同类型的声明可以简写为:
const name1 , name2  = value1 , value2

1
2
3
例如:
package main

import "fmt"

func main()  {
    //长度 int  3
    const LENGTH int = 3
    //宽度 int 2
    const  WIDTH int = 2
    //面积 int
    var AREA int
    //多重赋值 int ,bool,字符串
    const  a,b,c = 1 , true , "str"
    //求面积
    AREA = LENGTH * WIDTH
    //输出面积
    fmt.Printf("面积为 : %d\n" ,AREA)
    //输出a,b,c
    fmt.Println(a,b,c)
}

运行结果:
面积为 : 6
1 true str
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 常量还可以用作枚举:

const {
    zero = 0
    one  = 1
    two = 2
}

例如:
package main

import "unsafe"

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

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

运行结果:
123 3 16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# iota

iota,特殊常量,可以认为是一个可以被编译器修改的常量。 在每一个const关键字出现时,被重置为0,然后再下一个const出现之前,每出现一次iota,其所代表的数字会自动 增加1。

iota 可以被用作枚举值:
const (
    a = iota
    b = iota
    c = iota
)
简写如下:
const (
    a = iota
    b
    c
)
1
2
3
4
5
6
7
8
9
10
11
12
例如:
package main

import "fmt"

func main()  {

    const (
        a = iota //0
        b        //1
        c        //2
        d = "hello" // 3
        e           // 4
        f = 100     // 5
        g           // 6
        h = iota    // 7
        i           // 8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

运行结果:
0 1 2 hello hello 100 100 7 8

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
例如:
package main
import (
    "fmt"
)
const (
       //左移0位
    i = 1 << iota
      //左移1位
    j = 8 << iota
      //左移2位
    k
      //左移3位
    l
)
func main()  {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

运行结果:
i= 1
j= 16
k= 32
l= 64

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28