二、变量、类型、类型之间的转换

1.变量

 1 package main
 2 
 3 import "fmt"
 4 
 5 //注意是()而不是{}
 6 var (
 7     x int
 8     b bool
 9 )
10 
11 func main() {
12     x = 123
13     b = true
14     fmt.Println(x, b)
15     //变量名是下划线时，任何赋给它的值都被丢弃
16     a, _ := 34, 35
17     fmt.Println(a)
18 }

输出结果如下：

123 true


34

注意：变量声明了但未使用编译会报错。

2.类型

布尔类型

bool：true或false

数字类型

支持int和uint

rune, int8, int16, int32, int64和byte, uint8, uint16, uint32, uint64。其中rune是int32的别称，byte是uint8的别称。

注意：这些类型的变量之间不允许互相赋值或操作，不然会在编译时引起编译器报错。

常量

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6     const (
 7         x = iota // x == 0
 8         y = iota // y == 1
 9         z = iota // z == 2
10         w        // 常量声明省略值时，默认和之前一个值的字面相同。这里隐式地说w = iota，
　　　　　　　　　　　 //因此w == 3。其实上面y和z可同样不用"= iota"
11     )
12     fmt.Println(x, y, z, w)
13     const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0
14     fmt.Println(x, y, z, w, v)
15 }

结果：

0 1 2 3


0 1 2 3 0

字符串

字符串是用一对双引号（""）或反引号（``）1的左边

在Go中字符串是不可变的

var s string = "hello"

s[0] ='c'

修改第一个字符为'c'时会报错

但如果真的想要修改怎么办呢？下面的代码可以实现：

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6     s := "hello"
 7     c := []byte(s) // 将字符串 s 转换为 []byte 类型
 8     c[0] = 'c'
 9     s2 := string(c) // 再转换回 string 类型
10     fmt.Printf("%s\n", s2)
11 }

結果如下：

cello

還有另一种方法

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6     //连接2个字符
 7     s := "hello,"
 8     m := " world"
 9     a := s + m
10     fmt.Printf("%s\n", a)
11     //修改字符串也可写为
12     s1 := "hello"
13     s1 = "cs" + s1[1:] // 字符串虽不能更改，但可进行切片操作
14     fmt.Printf("%s\n", s1)
15     s1 = "world" + s1[:0] // 全部替換
16     fmt.Printf("%s\n", s1)
17 }

结果：

hello, world


csello


world

复数

Go还支持复数。它的默认类型是complex128（64位实数+64位虚数）。如果需要小一些的，也有complex64(32位实数+32位虚数)。复数的形式为RE + IMi，其中RE是实数部分，IM是虚数部分，而最后的i是虚数单位。下面是一个使用复数的例子：

var c complex64 = 5+5i

output: (5+5i) 包括括号

fmt.Printf("Value is: %v", c)

错误

Go内置有一个error类型，专门用来处理错误信息，Go的package里面还专门有一个包errors来处理错误：

 1 package main
 2 
 3 import (
 4     "errors"
 5     "fmt"
 6 )
 7 
 8 func main() {
 9     err := errors.New("emit macho dwarf: elf header corrupted")
10     if err != nil {
11         fmt.Print(err)
12     }
13 }

結果：emit macho dwarf: elf header corrupted

var a error 定义了a为一个error，a的值是nil

3.类型之间的转换

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6     mystring := "hello this is string"
 7     //UTF-8编码
 8     byteslice := []byte(mystring)
 9     fmt.Println(byteslice)
10     //Unicode编码
11     runeslice := []rune(mystring)
12     fmt.Println(runeslice)
13     b := []byte{'h', 'e', 'l', 'l', 'o'}
14     s := string(b)
15     i := []rune{65, 66, 67}
16     r := string(i)
17     fmt.Println(s)
18     fmt.Println(r)
19 }

結果：

[104 101 108 108 111 32 116 104 105 115 32 105 115 32 115 116 114 105 110 103]


[104 101 108 108 111 32 116 104 105 115 32 105 115 32 115 116 114 105 110 103]


hello


ABC

 1 package main
 2 
 3 import "fmt"
 4 
 5 type foo struct{ int }
 6 type bar foo
 7 
 8 func main() {
 9     var b bar = bar{1}
10     var f foo = foo(b) //不能直接f foo = b，因为不能使用类型bar作为foo赋值
11     fmt.Println(b, f)
12 }

結果：

{1} {1}

转载于:https://www.cnblogs.com/liubiaoren/archive/2013/01/30/2882690.html