基础语法

声明包、导入包、主函数、作用域

package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello World")
}

基本数据类型和运算符

变量声明与赋值

var name type
var (
    name1 type1
    name2 type2
)
var a int = 1
b := 2
a, b = b, a

基础类型

int、int8、int16、int32、int64

uint、uint8、uint16、uint32、uint64

float32、float64

complex64、complex128

byte、rune

bool

字符串

len()

strings.Map()

string[start : end]

strings.Fields()

strings.Split()

strings.Index()

strings.Replace()

fmt.Sprintf()

fmt.Printf()

fmt.Println()

类型转换

显式声明类型转换

v1 := T(v)

strconv.Itoa()

strconv.Atoi()

ParseBool()

ParseInt()

ParseFloat()

FormatBool()

FormatInt()

FormatFloat()

类型别名

type newType oldType

常量

const name [type] = value

枚举 enum

没有定义枚举类型，但是可以通过const和iota联合使用

const(
    identifier 1 type = iota
    identifier 2
)

运算符

+ - * / % ++ -- == != > < >= <= && || ! & | ^ << >> += -= *= /= %= &= |= ^= <<= >>=

流程控制

// if
if expr1 {
    statement1
} else if expr2 {
    statement2
} else{
    statement3
}
 
// switch
switch var1 {
switch var1: val2 {
switch {
    case val1:
        statement1
    case val2:
        statement2
    ...
    default:
        statementn
}
 
// for
for i:=0; i<10; i++ {
}
// for-range
for key,val := range coll {
}
 
break
continue
goto

复合数据类型

数组

var array_name [SIZE] array_type{1, 2, 3}
len(array_name)
array1 == array2 // len(array1) == len(array2)
// 遍历
for i, v := range array {
}
var aa [2][3]int{
    {}
    {}
}

切片

切片是对数组的区间引用，append创建新的数组空间并引用为切片

var slice_name []slice_type{1, 2, 3}
make([]Type, size, cap)
slice_name[start:end]
len()
cap()
append(slice, val)
copy(dst, src)
nil // 空切片
// 通过append和[:]组合使用删除切片内元素

映射

var mapname map[keytype]valuetype{
    key1 : val1,
    ...
}
mapname := make(map[keytype]valuetype)
for k,v := range mapname{
}
// get
var val, isExist := mapname[key] // 如何不存在该元素则返回值类型的“零值”
// del
delete(mapname, key)

函数

函数定义

func funcname(param1 type1, param2 type2) type {
    ...
}

值传递和引用传递（指针）

func swap(a *int, b *int) {
	*a, *b = *b, *a
}

传递数组和切片

func join(array [3]string) string {
	var s string = ""
	for i := 0; i < len(array); i++ {
		s += array[i] + " "
	}
	return s
}

可变参数和可变类型参数

// 可变参数
func sum(num ...int) int {
}
// 可变类型参数
func print(a ...interface{}) {
	for i := 0; i < len(a); i++ {
		fmt.Println(a[i])
	}
}
print(1, 'a', []int{1, 2, 3})

多个返回值

func minmax(a int, b int) (int, int) {
    if a < b {
        return a, b
    } else {
        return b, a
    }
}
fmt.Println(minmax(1, 2))

函数变量

func sum(a int, b int) int {
    return a + b
}
var add func(int, int) int = sum
fmt.Println(add(1, 2))

匿名函数

func(a int, b int) {
    fmt.Println(a + b)
}(1, 2)

闭包

func main() {
    var sum = add()
    fmt.Println(sum(1))
    fmt.Println(sum(2))
}
func add() func(int) int {
    var sum int = 0
    return func(a int) int {
        sum += a
        return sum
    }
}

todo 延迟调用

指针

var ptr_name *ptr_type = &v
ptr := &v

new

var ptr *int
ptr = new(int)

空指针 nil

函数传指针修改源数据

指针数组

var ptr [length]*type

二重指针

var ptr **type

结构体

func main() {
	p1 := person{"Alice", 20}
	println(p1.name, p1.age)
	p2 := new(person)
	p2.name = "Bob"
	p2.age = 30
	p3 := &person{}
	p3.name = "Charlie"
	p3.age = 40
	println(p2.name, p2.age)
	println(p3.name, p3.age)
}
 
type person struct {
	name string
	age  int
}

todo

接口

todo

错误处理

todo

并发