Go语言基础

简介

初始化

image-20190412160342216

规则：

  • 每个package 只会被初始化一次；
  • 同一个 package，不同文件是按照文件名的顺序来初始化；
  • 不能循环 import , 例如：A import B ,然后又 B import A；
  • 任何 package , 都可以存在一个以上的 init() , 执行顺序由上而下；
  • main() 只能存在于 package main；
  • 属于 package main 的文件 , 都将会初始化；

变量

  • golang变量声明即初始化；

1
2

//声明
var v VAR_TYPE

基础语法

类型别名

  • 类型别名是go 1.9中增加的语法，用于给已有类型设置一个另外的名称；

  • 语法：type TypeAllias = OldType;

  • 类型别名除了名称和原类型不同外，其他完全一样，可以直接用在原类型用的所有属性，无须转换；

  • 类型别名不允许循环定义；

  • 大写字母开头的别名支持导出；

1
2
3
4
5
6
7

// 类型别名
type identifier = Type
// 类型定义
type newType Type
// 
type byte = uint8 //
type rune = int32 //

类型嵌入

golang中的类型不支持继承，但提供了嵌合机制；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

type Wheel struct {
    Size int
}
type Engine struct {
    Power int    // 功率
    Type  string // 类型
}
type Car struct {
    Wheel
    Engine
}
func main() {
    c := Car{
        Wheel: Wheel{
            Size: 18,
        },
        Engine: Engine{
            Type:  "1.4T",
            Power: 143,
        },
    }
    fmt.Printf("%+v\n", c)
}

基本数据结构

数组(array)

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

// 初始化
var arr1 [5]int
arr2 := [5]int{1,2,3,4,5}
arr3 := [...]int{1,2,3,4,5}
arr4 := [5]int{1:1, 2:2}

//指针数组
arr5 := [5]*int{0: new(int), 1: new(int)}
*arr5[0] = 10

//数组复制: 元素个数和类型相同时才能复制

//多维数组
var arr10 [4][5]int
arr10 :=
array := [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}

切片(slice)

1
2
3
4
5

//初始化
var slice1 []int //nil slice
slice2 := []int{1,2,3,4,5}
slice3 := []int{} //空切片
slice4 := make([]string, 5)

映射(map)

1
2

dict1 := make(map[string]int)
dict2 := map[string]string{"Red", "Yellow", "Blue"}

gc

goroutine

channel

Interface

sync

  • WaitGroup

defer

defer 是后进先出。

panic 需要等defer 结束后才会向上传递。 出现panic恐慌时候，会先按照defer的后入先出的顺序执行，最后才会执行panic。

关键字

  • defer

值语义和引用语义

Go语言中的大多数类型都基于值语义，包括：

  • 基本类型，如byte、int、bool、float32、string等；
  • 复合类型，如arry、struct、pointer等；

字符类型

golang中有两种字符类型：

  • byte：uint8 类型， 代表一个ASCII 字符;
  • rune： int32 类型，代表一个unicode字符；

注意事项

  1. for-range 的k,v变量在整个遍历过程中共用，不能直接进行引用传递。

包管理

GOPATH

go-mod

闭包

  • Go语言支持闭包；

  • Go语言能通过escape analyze识别出变量的作用域，自动将变量在堆上分配；

  • 返回闭包时并不是单纯返回一个函数，而是返回了一个结构体，记录下函数返回地址和引用的环境中的变量地址；

1
2
3
4
5
6

func f(i int) func() int {
    return func() int {
        i++
        return i
    }
}

参考

  1. 图解golang内存分配
  2. 了解 Go 1.9 的类型别名