基本组成结构

1
2
3
4
5
6
7
packge main  // 包名

import "fmt" /*  导入依赖包 */

fun main() {  /*  主函数 */
    fmt.Println("Hello, World!")
}

数据类型

基本类型

  • 布尔型: ture or false
  • 数字类型: int, float32, float64
  • 字符串类型 string

派生类型

  • 指针类型Pointer
  • 数组
  • 结构化类型struct
  • Channel
  • 切片
  • Map
  • interface

变量

变量申明

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
package main
import "fmt"
func main() {
    var a string = "Runoob"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)
    
    var aa int
    fmt.Println(aa)
    
    var bb = true
    // bb := true 
    fmt.Println(bb)
    
}
  • 指定变量类型,如无初始化则为对应类型的默认值。数值型为0,布尔型为false,字符串为””
  • 可以根据值自动判定类型
  • 可以通过:= 申明变量, 但仅能在函数中使用
  • 变量可分为局部变量和全局变量,两种变量名称可以相同,优先考虑局部变量
  • 全局变量一般使用因式分解格式
1
2
3
4
var (
    v1 t1
    v2 t2
)

引用

  • 基本类型属于值类型,变量直接指向内存中的值
  • 其他类型属于引用类型,变量指向值坐在的内存地址

其他

  • 局部变量申明后必须被使用
  • 可以使用a, b = b, a交换同类型的变量
  • 可以用空白标识符_用来抛弃值

常量

  • 格式
1
const name [type] = value
  • 只支持布尔型、数字型、字符串
  • 枚举
1
2
3
4
5
const (
    A = 0
    B = 1
    C = 2
)
  • iota: 初始值为0,每增一行增加一次计数
1
2
3
4
5
6
const (
a = iota
b
c = "Hi"
d  // 3
)

运算符优先级

运算符 级别
* / % << >> & &^ 5
+ - | ^ 4
== != < > 3
&& 2
|| 1

条件语句

  • if else
1
2
3
4
5
if a > 3 {
    ...
} else {
    ...
}
  • switch
1
2
3
4
5
6
7
8
switch var1 {
    case var0:
        ...
    case var1:
        ...
    default:
        ...
}
  • select

for循环语句

  • 基本形式: for init; condition; post {}
  • while: for condition {}
  • 无限循环: for {}
  • for-each: for i, s:= range strings {}

函数

  • 格式
1
2
3
func function_name([parameter list]) [return_types] {
    ...
}
  • 参数传递
    • 值传递
    • 引用传递

数组

  • 申明
1
var variable_name [size] variable_type
  • 初始化
1
2
var a = [5]int{1,2,3}
fmt.Println(a[1])  // 2

指针

  • 申明
1
var var_name *var_type
  • 简单示例
1
2
3
var a  int = 20
var b *int
b = &a

结构体

  • 申明
1
2
3
4
5
6
7
8
type struct_name struct {
    m1 t1
    m2 t2
}

v1 := struct_name{m1: v1, m2: v2} // struct_name{v1, v2}

fmt.Println(v1.m1)

切片Slice

  • 动态数组,长度可变
  • 定义

    • 不指定大小是数组
1
2
3
4
5
// 不指定大小是数组
var s []type

// 使用make
var s []type = make([]type, len, capacity) 
  • 初始化
1
2
3
s1 := []int{1, 2, 3, 4, 5}

s2 := s1[:2]
  • 函数len和cap分别获取切片的长度和容量
  • 函数append为切片追加一个或多个元素
  • 函数copy(dst, src)拷贝切片

集合Map - 无序键值对

  • 定义
1
2
var map_variable map[key_type]value_type =  make(map[key_type]value_type) 
// 或者 map_variable := make(map[key_type]value_type)
  • 判断元素是否存在
1
v, ok = map1[key]
  • 删除元素
1
delete(map1, "test")

接口

  • 公共方法的抽象
  • 示例
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
type interface_name1 interface {
    method_name1 return_type1
    method_name2 return_type2
}

type struct_name1 struct {
}

func (s1_m1 struct_name1) method_name1 () return_type1 {
}

func (s1_m2 struct_name1) method_name2 () return_type2 {
}

var i interface_name1
i = new(struct_name1)
fmt.Println(i.method_name1())

错误处理

  • 内置错误接口
1
2
3
type error interface {
    Error() string
}

并发

goroutine

  • 使用go关键字调用函数时会开启一个goroutine

通道channel

  • 申明
1
2
ch := make(chan int) 
// ch := make(chan int, 2) 指定缓存大小为2 
  • 发送数据
1
ch <- v
  • 接收数据
1
v := <-ch
  • 可用range遍历
  • 可关闭