GO基础学习笔记

未分类

第一部分 语言

第一章 类型

1.1 变量

Go是静态类型的语言，不能在运行期间改变变量类型。

使用var定义变量，自动初始化为零值。若提供初始值，可以省略变量类型，由编译器自动判断。

var x int
var f float = 1.5
var s = "abc"

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

func main(){
    x := 123    //这里要注意是定义新的局部变量，还是修改全局变量。该方式容易出错。
}

可以一次定义多个变量

var x, y, z 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) 先计算了i的值为0，而非 data[2] = 100

特殊只写变量“_”， 用于忽略值占位。

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

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

func main(){
    s := "abc"
    println(&s)
    s, y := "hello", 20     // 重新赋值：与前s在同一命名空间，且有变量定义。
    {
        s, z := 1000, 30
        println(&s, z)      // 定义新的同名变量，与前s不在同一命名空间
    }
}

1.2 常量

常量值必须是编译器可确定的数字、字符串、布尔值。

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

不支持1UL（无符号长整型）、2LL(??)这样的类型后缀。

常量组中，如不提供类型和初值，则视作与上一常量相同。

const (
    s = "abc"
    x       // x = "abc"
)

常量值还可以是len, cap (返回切片分配空间的大小), unsafe.Sizeof等编译器即可确定结果的函数返回值。

const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(b)
)

如果常量类型足以存储初值，则不会引发溢出错误。

const (
    a byte = 100    // int to byte
    b int = 1e20    // float64 to int , overflows
)

枚举

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

const (
    Sunday = iota   // 0
    Monday          // 1 即 Monday = iota 
    Tuesday         // 2
    Wednesday       // 3
    Thursday        // 4
    Friday          // 5
    Satauday        // 6
)
const (
    _ = iota                        // iota = 0
    KB int64 = 1 << (10 * iota)     // iota = 1 1左移10位 即 2^10 1024 
    MB                              // 与KB表达式一样,  但iota = 2 1左移20位 即 2^20 
    GB
    TB
)

在同一常量组中，可以提供多个iota, 它们各自增长。

const (
    A, B = iota, iota << 10     // 0, 0 << 10
    C, D                        // 1, 1 << 10
)

如果iota自增被打断，须显式恢复。

const (
    A = iota        // 0
    B               // 1
    C = "c"         // c
    D               // c, 与上一行相同
    E = iota        // 4, 显式恢复。 注意计数包含了 C、D 两行。
    F               // 5
)

可通过自定义类型来实现枚举类型限制。

type Color int
const (
    Black Color = iota  // 枚举类型为Color
    Red
    Blue
)
func test(c Color) {}
func main() {
    c := Black
    test(c)
    x := 1
    test(x)     // Error: cannot use x (type int) as type Color in function argument
    test(1)     // 常量会被编译器自动替换。
}

1.3 基本类型

更明确的数字类型命名，支持Unicode, 支持常用的数据结构。

支持八进制、十六进制，以及科学计数法。标准库math定义了各数字类型取值范围。

a, b, c, d := 071, 0xF, 1e9, math.MinInt16  // 0开头 八进制 0x开头 十六进制

空指针值nil, 而非NULL。

1.4 引用类型

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

内置函数new计算类型大小，为起分配零值内存，返回指针。
而make会被编译器翻译为具体的创建函数，由其分配内存和初始化成员结构，返回对象而非指针。

a := []int{0, 0, 0}     // 提供初始化表达式
a[1] = 10
b := make([]int, 3)     // makeslice
b[1] = 10
c := new([]int)
c[1] = 10               // Error: invalid operation: c[1] (index of type *[]int)

1.5 类型转换

不支持隐式类型转换，即便是从窄转宽（不丢失精度）也不行。

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))   将p地址先转为Point类型，再取Point指向的值
(*Point)(p)     // 将p转化为*Point指向的东西
<-chan int(c)   // 相当于 <-(chan int(c))
(<-chan int)(c)

同样不能将其他类型当bool值使用。

a := 100
if a {      // Error: non-bool a (type int) used as if condition
    println("true")
}

1.6 字符串

字符串是不可变值类型，内部用指针指向UTF-8字节数组。

• 默认值是字符串""。
• 用索引号访问某字节s[i]。
• 不能用序号获取字节元素指针，&s[i]非法。
• 不可变类型、无法修改字节数组。
• 字节数组尾部不包含NULL。

runtime.h

struct String{
    byte*   str;    // 指向byte类型数据的指针
    intgo   len;
}

使用索引号访问字符(byte)

s := "abc"
println(s[0] == '\x61', s[1] == 'b', s[2] == 0x63)      // true, true, true

使用“`”定义不做转义处理的原始字符串，支持跨行。

s := `a
b\r\n\x00
c`
println(s)  

输出

a
b\r\n\x00
c

连接跨行字符串时，“+”必须在上一行的末尾，否则引发编译错误。

s := "Hello," + 
     "World!"
s2 := "Hello,"
        + "World!"  //Error: invalid operaion: + untyped string

支持用两个索引号返回子串。子串依然指向原字节数组，仅修改了指针和长度属性。

s := "Hello, world!"
s1 := s[:5]     // Hello
s2 := s[7:]     // world!
s3 := s[1:5]    // ello

单引号字符常量表示 Unicode Code Point, 支持 \uFFFF、\U7FFFFFFF、\xFF 格式。对应 rune 类型， UCS-4。

func main(){
    fmt.Printf("%T\n", 'a')     // %T 类型
    var c1, c2 rune = '\u6211', '们'
    println(c1 == '我', string(c2) == "\xe4\xbb\xac")
}

输出

int32       // rune 是 int32的别名
true true

要修改字符串，可先将其转换为[]rune或[]byte, 完成后再转换为string。无论哪种方式，都会重新分配内存，并复制字节数组。

func main(){
    s := "abcd"
    bs := []byte(s)
    bs[1] = 'B'
    println(string(bs))
    u := "电脑"
    us := []rune(u)
    usp[1] = '话'
    println(string(us))
}

输出：

aBcd
电话

用for 循环遍历字符串时，也支持 byte 和 rune 两种方式。

func main(){
    s := "abc汉字"
    for i := 0; i < len(s); i++ {       //byte
        fmt.Printf("%c", s[i])
    }
    fmt.Println
    for _, r := range s {               //rune
        fmt.Printf("%c", r)
    }
}

输出：

a,b,c,,æ,±,,å,-,,
a,b,c,汉,字

1.7 指针

支持指针类型 *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

不能对指针做加减法运算。

x := 1234
p := &x
p++         // Error: invalid operation: p += 1 (mismatched types *int and int)

可以在 unsafe.Pointer 和任何类型指针间进行转换。

func main(){
    x := 0x12345678
    p := unsafe.Pointer(&x)         // *int -> Pointer
    n := (*[4]byte)(p)              // Pointer -> *[4]byte
    for i := 0; i < len(n); i++ {
    }
}