Go语言学习笔记 － 类型

序

一直在关注Golang的发展，最近Go 1.7也发布了，于是下定决心学习Golang。本文是《Go 学习笔记》摘录，同时加深对Golang理解。

变量

Golang是静态类型语言，因此不能在运行期改变变更的类型。

变量的定义采用　var　关键字，自动初始化为零值（如string的零值为空字符串，bool的零值为false，int的零值为０）。如果提供初始化值，则可省略变量类型，由编译器进行类型自动推断。

var x int
var f float32 = 1.6
var s = "abc"

在函数的内部，可用更简略的　“:=”　方式定义变量

func main(){
    x := 123
}

可以一次性定义多个变量。

var x, y, x int
var s, n = "abc", 123
var (
    a int
    b float
)

func main() {
    n, s := 0x1234, "Hello, World!"
    println(x, s, n)
}

多变量赋值时,先计算所有相关值,然后再从左到右依次赋值。

data, i := [3]int{0, 1, 2}, 0
i, data[i] = 2, 100  // (i = 0) -> (i = 2), (data[0] = 100)

特殊只写变量 "_",用用于忽略值占位。

func test() (int, string) {
    return 1, "abc"
}
func main() {
    _, s := test()
    println(s)
}

编译器会将未使用用的局部变量当做错误。

注意重新赋值与定义新同名变量的区别。

s := "abc"
println(&s)
s, y := "hello", 20 // 重新赋值: 与前 s 在同一一层次的代码块中,且有新的变量被定义。
println(&s, y) // 通常函数多返回值 err 会被重复使用用。
{
    s, z := 1000, 30    // 定义新同名变量: 不在同一一层次代码块。
    println(&s, z)
}

常量

常量值必须是编译期可确定的数字、字符串、布尔值。在常量组中,如不提供类型和初始化值,那么视作与上一常量相同。常量值还可以是 len、cap、unsafe.Sizeof 等编译期可确定结果的函数返回值。

const x, y int = 1, 2 // 多常量初始化
const s = "Hello, World!" // 类型推断
const ( // 常量组
    a, b = 10, 100
    c bool = false
)
func main() {
    const x = "xxx"// 未使用局部常量不会引发编译错误。
}
const (
    s = "abc"
    x    // x = "abc"
)
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(b)
)

枚举

关键字 iota 定义常量组中从 0 开始按行计数的自增枚举值。

const (
    Sunday = iota // 0
    Monday // 1,通常省略后续行行表达式。
    Tuesday // 2
    Wednesday // 3
    Thursday // 4
    Friday // 5
    Saturday // 6
)

引用类型

引用用类型包括 slice、map 和 channel。它们有复杂的内部结构,除了申请内存外,还需要初始化相关属性。

a := []int{0, 0, 0}  // 提供初始化表达式。
a[1] = 10

类型转换

不支持隐式类型转换,即便是从窄向宽转换也不行。使用用括号避免优先级错误。不能将其他类型当 bool 值使用用。

var b byte = 100
// var n int = b // Error: cannot use b (type byte) as type int in assignment
var n int = int(b) // 显式转换
*Point(p)  // 相当于 *(Point(p))
(*Point)(p)
<-chan int(c)  // 相当于 <-(chan int(c))
(<-chan int)(c)

字符串

字符串是不可变值类型,内部用用指针指向 UTF-8 字节数组。使用用 "`" 定义不做转义处理的原始字符串,支持跨行。连接跨行字符串时,"+" 必须在上一行末尾,否则导致编译错误。要修改字符串,可先将其转换成 []rune 或 []byte,完成后再转换为 string。无论哪种转换,都会重新分配内存,并复制字节数组。
• 默认值是空字符串 ""。
• 用用索引号访问某字节,如 s[i]。
• 不能用用序号获取字节元素指针,&s[i] 非非法。
• 不可变类型,无无法修改字节数组。
• 字节数组尾部不包含 NULL。

指针

支持指针类型 *T,指针的指针 **T,以及包含包名前缀的 .T。
• 默认值 nil,没有 NULL 常量。
• 操作符 "&" 取变量地址,"" 透过指针访问目标对象。
• 不支持指针运算,不支持 "->" 运算符,直接用用 "." 访问目标成员。

func main() {
    type data struct{ a int }
    var d = data{1234}
    var p *data
    p = &d
    fmt.Printf("%p, %v\n", p, p.a)    // 直接用用指针访问⺫目目标对象成员,无无须转换。
}
//输出：0x2101ef018, 1234

自定义类型

可将类型分为命名和未命名两大大类。命名类型包括 bool、int、string 等,而 array、slice、map 等和具体元素类型、长度等有关,属于未命名类型。
　　具有相同声明的未命名类型被视为同一一类型。
• 具有相同基类型的指针。
• 具有相同元素类型和⻓长度的 array。
• 具有相同元素类型的 slice。
• 具有相同键值类型的 map。
• 具有相同元素类型和传送方方向的 channel。
• 具有相同字段序列 (字段名、类型、标签、顺序) 的匿名 struct。
• 签名相同 (参数和返回值,不包括参数名称) 的 function。
• 方方法集相同 (方方法名、方方法签名相同,和次序无无关) 的 interface。
　　可用 type 在全局或函数内定义新类型。新类型不是原类型的别名,除拥有相同数据存储结构外,它们之间没有任何关系,不会持有原类型任何信息。除非目标类型是未命名类型,否则必须显式转换。

x := 1234
var b bigint = bigint(x)  // 必须显式转换,除非非是常量。
var b2 int64 = int64(b)
var s myslice = []int{1, 2, 3}  // 未命名类型,隐式转换。
var s2 []int = s

package main

import "fmt"

type MyInt int

func (i MyInt) Set(n MyInt) {
    i = n
}

func main() {
    var i MyInt = 2
    i.Set(18)
    fmt.Println(i)
}

// 命名类型采用值传递，要改变值需采用指针类型处理
func (i *MyInt) Set(n MyInt) {
    *i = n
}