go语言渐入佳境[3]-变量声明与赋值

变量

变量是内存当中一段空间的抽象描述。变量的类型明确了空间的大小以及空间如何解析。

Go中的变量类型

1
bool byte complex64 complex128 error float32 float64 int int8 int16 int32 int64 rune string uint uint8 uint16 uint32 uint64 uintptr

变量的声明与赋值

方式1

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
var x string
x = "Hello World"
fmt.Println(x)
}

方式2

注意,x := “Hello World” 等价于 var x = “Hello World”
自动推断类型,并且必须在函数体内部

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
x := 1
fmt.Println(x)
}

多样的赋值

1
2
3
4
5
6
7
8
9
10
11
12
var i int
var U, V, W float64
var k = 0
var x, y float32 = -1, -2
var (
i int
u, v, s = 2.0, 3.0, "bar"

)

//一组变量也可以通过调用一个函数,由函数返回的多个返回值初始化:
var f, err = os.Open(name) // os.Open returns a file and an error

例子:

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"

func main(){

var a,b string= "jonson","jackson"

c,d := true,false

e,f,g := "jonson",true,123
fmt.Println("a:",a)
fmt.Println("b:",b)

fmt.Println("c:",c)
fmt.Println("d:",d)

fmt.Println("e:",e)
fmt.Println("f:",f)
fmt.Println("g:",g)

//和普通var形式的变量声明语句一样,简短变量声明语句也可以用函数的返回值来声明和初始化变量,像下面的os.Open函数调用将返回两个值:
//f, err := os.Open(name)
}

元祖赋值

元组赋值是另一种形式的赋值语句,它允许同时更新多个变量的值。在赋值之前,赋值语句右边的所有表达式将会先进行求值,然后再统一更新左边对应变量的值。这对于处理有些同时出现在元组赋值语句左右两边的变量很有帮助,例如我们可以这样交换两个变量的值:
x, y = y, x

a[i], a[j] = a[j], a[i]
或者是计算两个整数值的的最大公约数(GCD)(译注:GCD不是那个敏感字,而是greatest common divisor的缩写,欧几里德的GCD是最早的非平凡算法):

1
2
3
4
5
6
func gcd(x, y int) int {
for y != 0 {
x, y = y, x%y
}
return x
}

或者是计算斐波纳契数列(Fibonacci)的第N个数:

1
2
3
4
5
6
7
func fib(n int) int {
x, y := 0, 1
for i := 0; i < n; i++ {
x, y = y, x+y
}
return x
}

零值问题

变量初始化不赋值的情况,默认为空。

例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package main
import "fmt"
func main() {
var a int
var b string
var c float64
var d bool

fmt.Printf("%v \n", a)
fmt.Printf("%v \n", b)
fmt.Printf("%v \n", c)
fmt.Printf("%v \n", d)
fmt.Println()
}

常量

常量一旦声明不能改变,并且常量必须赋予初始值。此代码无效func main() {const x int}

有效:

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


const (
m = 1
n = 2
)
func main(){

const k = 8
}

常量表达式的值在编译期计算,而不是在运行期。每种常量的潜在类型都是基础类型:boolean、string或数字。

一个常量的声明语句定义了常量的名字,和变量的声明语法类似,常量的值不可修改,这样可以防止在运行期被意外或恶意的修改。例如,常量比变量更适合用于表达像π之类的数学常数,因为它们的值不会发生变化:
const pi = 3.14159 // approximately; math.Pi is a better approximation
和变量声明一样,可以批量声明多个常量;这比较适合声明一组相关的常量:
const (
e = 2.71828182845904523536028747135266249775724709369995957496696763
pi = 3.14159265358979323846264338327950288419716939937510582097494459
)
所有常量的运算都可以在编译期完成,这样可以减少运行时的工作,也方便其他编译优化。当操作数是常量时,一些运行时的错误也可以在编译时被发现,例如整数除零、字符串索引越界、任何导致无效浮点数的操作等。
常量间的所有算术运算、逻辑运算和比较运算的结果也是常量,对常量的类型转换操作或以下函数调用都是返回常量结果:len、cap、real、imag、complex和unsafe.Sizeof。
因为它们的值是在编译期就确定的,因此常量可以是构成类型的一部分,例如用于指定数组类型的长度:
const IPv4Len = 4

// parseIPv4 parses an IPv4 address (d.d.d.d).
func parseIPv4(s string) IP {
var p [IPv4Len]byte
// …
}
一个常量的声明也可以包含一个类型和一个值,但是如果没有显式指明类型,那么将从右边的表达式推断类型。在下面的代码中,time.Duration是一个命名类型,底层类型是int64,time.Minute是对应类型的常量。下面声明的两个常量都是time.Duration类型,可以通过%T参数打印类型信息:
const noDelay time.Duration = 0
const timeout = 5 * time.Minute
fmt.Printf("%T %[1]v\n", noDelay) // “time.Duration 0”
fmt.Printf("%T %[1]v\n", timeout) // “time.Duration 5m0s”
fmt.Printf("%T %[1]v\n", time.Minute) // “time.Duration 1m0s”
如果是批量声明的常量,除了第一个外其它的常量右边的初始化表达式都可以省略,如果省略初始化表达式则表示使用前面常量的初始化表达式写法,对应的常量类型也一样的。例如:
const (
a = 1
b
c = 2
d
)

fmt.Println(a, b, c, d) // “1 1 2 2”
如果只是简单地复制右边的常量表达式,其实并没有太实用的价值。但是它可以带来其它的特性,那就是iota常量生成器语法。

iota 使用

常量声明可以使用iota常量生成器初始化,它用于生成一组以相似规则初始化的常量,但是不用每行都写一遍初始化表达式。在一个const声明语句中,在第一个声明的常量所在的行,iota将会被置为0,然后在每一个有常量声明的行加一。
下面是来自time包的例子,它首先定义了一个Weekday命名类型,然后为一周的每天定义了一个常量,从周日0开始。在其它编程语言中,这种类型一般被称为枚举类型。
type Weekday int

const (
Sunday Weekday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
)
周一将对应0,周一为1,如此等等。
我们也可以在复杂的常量表达式中使用iota,下面是来自net包的例子,用于给一个无符号整数的最低5bit的每个bit指定一个名字:
type Flags uint

const (
FlagUp Flags = 1 << iota // is up
FlagBroadcast // supports broadcast access capability
FlagLoopback // is a loopback interface
FlagPointToPoint // belongs to a point-to-point link
FlagMulticast // supports multicast access capability
)
随着iota的递增,每个常量对应表达式1 << iota,是连续的2的幂,分别对应一个bit位置。使用这些常量可以用于测试、设置或清除对应的bit位的值:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func IsUp(v Flags) bool     { return v&FlagUp == FlagUp }
func TurnDown(v *Flags) { *v &^= FlagUp }
func SetBroadcast(v *Flags) { *v |= FlagBroadcast }
func IsCast(v Flags) bool { return v&(FlagBroadcast|FlagMulticast) != 0 }

func main() {
var v Flags = FlagMulticast | FlagUp
fmt.Printf("%b %t\n", v, IsUp(v)) // "10001 true"
TurnDown(&v)
fmt.Printf("%b %t\n", v, IsUp(v)) // "10000 false"
SetBroadcast(&v)
fmt.Printf("%b %t\n", v, IsUp(v)) // "10010 false"
fmt.Printf("%b %t\n", v, IsCast(v)) // "10010 true"
}

下面是一个更复杂的例子,每个常量都是1024的幂:
const (
_ = 1 << (10 * iota)
KiB // 1024
MiB // 1048576
GiB // 1073741824
TiB // 1099511627776 (exceeds 1 << 32)
PiB // 1125899906842624
EiB // 1152921504606846976
ZiB // 1180591620717411303424 (exceeds 1 << 64)
YiB // 1208925819614629174706176
)
不过iota常量生成规则也有其局限性。例如,它并不能用于产生1000的幂(KB、MB等),因为Go语言并没有计算幂的运算符。

iota从0开始循环

1
2
3
4
5
6
7
8
9
10
11
12
13
const (
a = iota
b = iota
c = iota
d = iota
)
等价于:
const (
a = iota
b
c
d
)

使用案例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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)
}

变态iota

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

import "fmt"
const (
i=1<<iota
j=3<<iota
k
l
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

结果:

1
2
3
4
i= 1
j= 6
k= 12
l= 24

iota表示从0开始自动加1,所以 i=1<<0, j=3<<1(<<表示左移的意思),即:i=1,j=6,这没问题,关键在k和l,从输出结果看 k=3<<2,l=3<<3。
简单表述:
• i=1:左移 0 位,不变仍为 1;
• j=3:左移 1 位,变为二进制 110, 即 6;
• k=3:左移 2 位,变为二进制 1100, 即 12;
• l=3:左移 3 位,变为二进制 11000,即 24。

Go语言中的byte和rune

Go语言中byte和rune实质上就是uint8和int32类型。byte用来强调数据是raw data,而不是数字;而rune用来表示Unicode的code point。参考规范:

uint8 the set of all unsigned 8-bit integers (0 to 255)
int32 the set of all signed 32-bit integers (-2147483648 to 2147483647)

byte alias for uint8
rune alias for int32
可以通过下面程序验证:

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
package main

import "fmt"

func byteSlice(b []byte) []byte {
return b
}

func runeSlice(r []rune) []rune {
return r
}

func main() {
b := []byte{0, 1}
u8 := []uint8{2, 3}
fmt.Printf("%T %T \n", b, u8)
fmt.Println(byteSlice(b))
fmt.Println(byteSlice(u8))

r := []rune{4, 5}
i32 := []int32{6, 7}
fmt.Printf("%T %T \n", r, i32)
fmt.Println(runeSlice(r))
fmt.Println(runeSlice(i32))
}

执行结果如下:

1
2
3
4
5
6
[]uint8 []uint8
[0 1]
[2 3]
[]int32 []int32
[4 5]
[6 7]

特殊

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

import (
"fmt"
)

func main() {
type newstring = string
var a newstring = "hello"
fmt.Println(a)
}