go基本语法

变量

基本类型

1. bool默认false
2. int以及int8、int32等
3. string用双引号或反引号括起来。反引号括起来的为raw字符串，即自动转义换行等字符
4. error错误类型

定义变量

1. var开头，后跟变量名，再跟类型：var a int var a,b,c int var a int = b var a,c int = x,y,z
2. 如果定义以后赋值可以体现类型，则可以不写类型：var a=1 var a,b = x,y
3. 此时也可以省略var：a:=1 a,b := x,y(次形式仅限用于函数体)
4. 特殊变量_。赋值给_的值会被丢弃。如_,a := 1,2会把2赋给a，同时1被丢弃
5. 声明未使用的变量会编译报错
6. iota作用域内每使用一次会自增，同一行使用时值相同

数组

1. 定义：arr:=[]int{},arr:=[10]int{1,2},arr:=[...]int{1,2,3}
2. 获取长度：len(arr)
3. 多维数组arr:=[...][...]int{[...]int{1},[1]int{2}}

slice

数组切片；引用类型，同一数组的slice指向同一数组；
1. 定义：var s []int(不指定长度)
1. arr:=[...]int{1,3}表示数组s:=arr[0:2]表示从在数组arr从0到2的切片
1. s:=arr[:2]从0到2
1. s:=arr[1:]从1到len(arr)

map

无序；引用类型；
1. 定义：var m map[string]int或m:=make(map[string]int)
1. 初始化：m:=map[String]int{"a":1,"b":2}
1. 赋值：m["key"]=1

struct

struct的组合即为面向对象中的类
1. struct组合
1. 匿名字段
1. 组合struct同名字段：优先访问外层

自定义类型

type Pair map[string]int自定义一个类型

常量

const a = 1

语句

1. 选择if
2. 循环for

函数(面向过程的函数)

定义函数

第一行 以func开头，后跟函数名，然后小括号内参数列表，以{结尾，然后是函数体，最后以}结束。

函数返回值

如果需要有返回值，则在参数列表后跟小括号，括号内写返回值类型

func get()(a int,b int){
    a=1
    b=2
    return
    // 同return 1,2
}

变长参数

func get(arg ...int){
    for n := range arg{
        // process n
    }
}

@H_671_301@传值与传指针

1. 对于基本类型，同C
2. 指针在定义时需要些*，而使用时会自动取址和指向（不用写&或*）

函数作为类型与变量

// 定义一种函数类型
type testInt func(int) bool

// 定义该项类型方法
func bigThanZero(v int) bool {
    return v > 0
}

// 定义该项类型方法
func smallThanZero(v int) bool {
    return v < 0
}

// 方法作为参数
func process(v int,f testInt) bool {
    a := 0
    return f(a)
}

func main() {
    a := 0
    // 方法作为变量
    process(a,bigThanZero)
}

方法(面向对象的方法)

带接收者的函数

// r为变量名，Receiver为接收者类型
func (r Reciever) f(){ }

方法的继承

1. 不像java或c#的方法是定义在类中的，go的方法是定义在struct之外
2. struct组合时可以继承其对应的方法

重写继承的方法

声明方法时，指定新的接受者即可

@H_998_403@interface

// 定义接口I
type I interface{
    fun1()
    fun2(arg string)
}

接口作为参数

同Java

接口定义变量

同Java

comma-ok

类似java中instanceof

func main() {
    m := map[string]Thing{"key": O{"a"}}
    // m["key"].(Thing)类似java中m.get("key") instanceof Thing
    if value,ok := m["key"].(Thing); ok {
        value.create()
    }

}

type Thing interface {
    create()
}

type O struct {
    name string
}

func (o O) create() {
    o.name = "1"
}

也支持switch-case

func main() {
    m := map[string]Thing{"key": O{"a"}}
    // m["key"].(Thing)类似java中m.get("key") instanceof Thing
    if value,ok := m["key"].(Thing); ok {
        value.create()
    }
    switch m["key"].(type) {
    case Thing:
        // process
    case O:
        //process
    }

}

type Thing interface {
    create()
}

type O struct {
    name string
}

func (o O) create() {
    o.name = "1"
}

接口继承

类似struct的继承，或者叫组合

type i interface{ anotherInterfacce }

代码分组

import "fmt"
import "os"

const i=100
const pi=3.14
const pre = "go"

var i int
var pi float
var pre string

可改写为

import(
    "fmt"
    "os"
)

const(
    i=100
    pi=3.14
    pre="go"
)
var(
    i int
    pi float
    pre string
)

规则

1. 大写字母开头变量可导出，小写字母开头变量不可导出
2. 大写字母开头函数为公有，小写字母开头变量为私有

defer

1. 作用类似java中的try-catch
2. 写法类似java中的assert
3. 执行时机为函数返回前，后写的先执行

func f(){
    file.Open("file");
    defer file.Close();
    // process
}

并发

方法前加go关键字，即可异步调用

go run()

主动让出cpu

runtime.Gosched()

通信channel

1. 定义处理int的channelc:=make(chan int)
2. 发送数据到channelc <- 2
3. 从channel接收数据i := <- c
4. 定义处理int的channel，并指定缓冲区大小为2个intcc := make(chan int,2)
5. 手动关闭close(c)
6. 判断是否打开v,ok := <-c

select

select之于channel，类似switch之于int

runtime

并发控制

Tips

if逻辑快内定义变量

//在if逻辑块内，允许声明一个变量，作用域只在块内有效
if x:= get(); x>10{

}

make、new

make返回值，new返回指针

标签

可用于goto、break、continue

for-range

m:=map[string]int{"a":1}
for k,v:=range m{
    // process k,v
}
for  _,v:=range m{
    // process v
}

switch自动break

不用手写break自动结束case
如需强制执行下一个case，则需在当前case最后加上fallthrogh

合并case

switch i{
    case 1:
    case 2,3:
}