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

1.变量

package main

import "fmt"

//注意是()而不是{}
var (
    x int
    b bool
)

func main() {
    x = 123
    b = true
    fmt.Println(x, b)
    //变量名是下划线时，任何赋给它的值都被丢弃
    a, _ := 34, 35
    fmt.Println(a)
}

输出结果如下：

123 true


34

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

2.类型

布尔类型

bool：true或false

数字类型

支持int和uint

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

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

常量

package main

import "fmt"

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

结果：

0 1 2 3


0 1 2 3 0

字符串

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

在Go中字符串是不可变的

var s string = "hello"

s[0] ='c'

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

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

package main

import "fmt"

func main() {
    s := "hello"
    c := []byte(s) // 将字符串 s 转换为 []byte 类型
    c[0] = 'c'
    s2 := string(c) // 再转换回 string 类型
    fmt.Printf("%s\n", s2)
}

結果如下：

cello

還有另一种方法

package main

import "fmt"

func main() {
    //连接2个字符
    s := "hello,"
    m := " world"
    a := s + m
    fmt.Printf("%s\n", a)
    //修改字符串也可写为
    s1 := "hello"
    s1 = "cs" + s1[1:] // 字符串虽不能更改，但可进行切片操作
    fmt.Printf("%s\n", s1)
    s1 = "world" + s1[:0] // 全部替換
    fmt.Printf("%s\n", s1)
}

结果：

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来处理错误：

package main

import (
    "errors"
    "fmt"
)

func main() {
    err := errors.New("emit macho dwarf: elf header corrupted")
    if err != nil {
        fmt.Print(err)
    }
}

結果：emit macho dwarf: elf header corrupted

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

3.类型之间的转换

package main

import "fmt"

func main() {
    mystring := "hello this is string"
    //UTF-8编码
    byteslice := []byte(mystring)
    fmt.Println(byteslice)
    //Unicode编码
    runeslice := []rune(mystring)
    fmt.Println(runeslice)
    b := []byte{'h', 'e', 'l', 'l', 'o'}
    s := string(b)
    i := []rune{65, 66, 67}
    r := string(i)
    fmt.Println(s)
    fmt.Println(r)
}

結果：

[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

package main

import "fmt"

type foo struct{ int }
type bar foo

func main() {
    var b bar = bar{1}
    var f foo = foo(b) //不能直接f foo = b，因为不能使用类型bar作为foo赋值
    fmt.Println(b, f)
}

結果：

{1} {1}