go语言入门

发布：2020年3月16日更新：2020年5月13日 # go

go语法学习

hollo world

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

编译

1	go build hello.go

运行

1
2
3

go run hello.go 
或
./hello

go基本语法

go标记：关键字、标识符、常量、字符串、符号
标识符：字母或下划线开始的命名
行分割符：推荐省略分号
注释：单行// 多行/**/
字符串连接： +
关键字： 25个关键字，36个预定义标识符。 break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var
空格： var age int;

go语言类型

布尔型 : bool
数字类型 : byte(8) rune(32) int(32或64) uint uintptr(无符号整型，用于存放一个指针) float32 float64 complex64 complex128 uint8 uint16 uint32 uint64 int8 int16 int32 int64
字符串类型 : UTF-8 编码标识 Unicode 文本
派生类型 : 指针（Pointer）数组结构化(struct) Channel 函数切片接口(interface) Map
类型转换 type_name(expression)

go变量

1
2
3

var identifier type
var v_name = value
v_name := value

零值：变量没有初始化的默认值
:= 声明语句
值类型和引用类型： &i(i变量的内存地址)

go 常量

const identifier [type] = value

const b string = "abc"
const b = "abc"
 
枚举
const (
  a
  b = 1
  c ="ss"
)

特殊常量 iota ： const 后每一行自动+1

go 运算符

同其他语言
特别的有

&：返回变量存储地址
*：指针变量
自增自减运算不能用做赋值表达式

go 条件运算

if else
switch

select : 用来监听和channel有关的IO操作

//select基本用法
select {
  case <- chan1:
  // 如果chan1成功读到数据，则进行该case处理语句
  case chan2 <- 1:
  // 如果成功向chan2写入数据，则进行该case处理语句
  default:
  // 如果上面都没有成功，则进入default处理流程
}

go 循环语句

for

for key, value := range oldMap { }

for init; condition; post { }

for condition { }

for { }

goto

goto label;
..
.
label: statement;

go 函数

支持引用传值和值传值，默认值传值
支持闭包

支持类型方法

1
2
3

func function_name( [parameter list] ) [return_types] {
   函数体
}

go 变量作用域

局部变量：函数内部
全局变量：函数外
形式参数：函数的局部变量

go 数组

声明：

1	var variable_name [SIZE] variable_type

初始化

1
2
3

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
balance[4] = 50.0

多维数组

1	var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

go 指针

指针使用流程：

定义指针变量。 var var_name *var-type
为指针变量赋值。 var_name = &a
访问指针变量中指向地址的值。 *var_name

空指针
当一个指针被定义后没有分配到任何变量时，它的值为 nil。

Go 支持指向指针的指针

go 结构体

跟java的modal一个意思
定义

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

结构体用于用于变量的声明

1
2
3

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

访问：结构体.成员名”

go 切片

Go 语言切片是对数组的抽象。与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

切片定义[]

var identifier []type
var slice1 []type = make([]type, len)
slice1 := make([]type, len)
make([]T, length, capacity)

初始化类似python

s :=[] int {1,2,3 }
s := arr[:]
s := arr[startIndex:endIndex]
s := arr[startIndex:]
s := arr[:endIndex]
s1 := s[startIndex:endIndex]
s :=make([]int,len,cap)

函数

make() 初始化
len() 测量长度
cap() 最大容量
append() 添加
copy() 复制

一个切片在未初始化之前默认为 nil，长度为 0

go 范围（Range）

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。
类似迭代

for k, v := range kvs

go 集合

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

go 接口

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

go 错误处理

抛出错误： errors.New(“math: square root of negative number”)

go 并发

goroutine 是轻量级线程： go 函数名( 参数列表 )
通道（channel）：两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。

ch := make(chan int) // 声明通道

v := <- ch  // 从ch 接收数据

ch <- v //发送给通道

ch := make(chan int, 100) // 设置通道缓冲区

v, ok := <-ch // 遍历通道 如没有数据后ok为false