01. Golang变量与常量

Golang变量与常量

一、变量

1). 变量声明

1. 对于纯粹的变量声明，Go语言引入了关键字var，而类型信息放在变量名之后。

var v1 int
var v2 string
var v3 [10]int // 数组
var v4 []int   // 切片数组
var v5 struct {
    f int
}
var v6 *int  // 指针
var v7 map[string] int // map,key为string类型，value为int类型

var

var {
    v1 int
    v2 string
}

2). 变量初始化

1. 对于声明变量时需要进行初始化的场景，var关键字可以不写。

var v1 int = 10 // 完整写法
var v2 = 10     // 编译器会自动推导出v2的类型
v3 := 10        // 编译器会自动推导出v3的类型

:=

3). 变量赋值

1. 变量初始化和变量赋值是不同的概念，下面为声明一个变量之后的赋值过程。

var v10 int
v10 = 123

2. 多重赋值特性,交换两个变量的值

i, j = j, i

4). 匿名变量

_

func GetName() (firstName, lastName, nickName string) {
    return "Liu", "Cheng", "Hahadasheng"
}

// 只想获取一个返回值
_, _, nickName := GetName()

二、常量

Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。

1). 字面常量

1. 所谓字面常量(literal), 指程序中硬编码的常量。如下

-12
3.14159265358979323846  // 浮点类型的常量
3.2+12i                 // 复数类型的常量
true                    // 布尔类型的常量
"foo"                   // 字符串常量

long a = 5L

2). 常量定义

const

const Pi float64 = 3.14159265358979323846
const zero = 0.0  // 无类型浮点常量
const {
    size int64 = 1024
    eof = -1 // 无类型整形常量
}
const u, v float32 = 0, 3 // U = 0.0, V = 3.0, 常量的多重复赋值。
const a, b, c = 3, 4, "foo" // 无类型整型和字符串常量

2. Go的常量定义可以限定常量类型，但不必须，如果定义常量是没有指定类型，则与字面常量一样，是无类型的常量。

3. 常量定义的右值可以是一个在编译器预算的常量表达式。

const mask = 1 << 3

常量的赋值是一个编译期行为，所以右值不能出现任何需要运行期才能得出结果的表达式。

// 如下会报错
const Home = os.GetEnv("HOME")

3). 预定义常量

truefalseiotaconstconst

const (       // iota被重设为0
    c0 = iota // c0 == 0
    c1 = iota // c1 == 1
    c2 = iota // c2 == 2
)

const (
    a = 1 << iota // a == 1 (iota在每个const开头被重设为0)
    b = 1 << iota // b == 2
    c = 1 << iota // c == 4
)

const (
    u = iota * 42          // u == 0
    v float64 = iota * 42  // v == 42.0
    w = iota * 42          // w == 84
)

2. 如果两个const的赋值语句的表达式是一样的，可以省略后一个赋值表达式。

const (
    c0 = iota // c0 == 0
    c1 =      // c1 == 1
    c2 =      // c2 == 2
)

const (
    a = 1 << iota // a == 1
    b             // b == 2
    c = 2 << iota // c == 8
    d             // c == 16
)

4). 枚举

const(...)enum关键字，反编译其实是实现一个抽象类，定义了一系列静态实例变量

const (
    Sunday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    numberOfDays // 这个常量没有导出
)

numberOfDays

---