Go 笔记

## Go 语言特性

- 自动垃圾回收机制

- 跟踪记录内存分配，阶段性地回收无任何人使用的内存。
   - 无需delete 关键字和free()方法
   - 系统自动判断，在合适的时候 如cpu空闲的时候进行垃圾回收，降低回收导致的损耗

- 丰富的内置类型  
   - 经典 整型 浮点型 数组 字符串 
   - 字典类型 map 
   - 数组切片slice
 
 - 函数多返回值  
   - 在go之前其他语言除了python 之外基本不支持多返回值
   - 其他语言需要多返回值时，多定义一个结构体用于返回
   - fn, mn, ln, nn := getName()
   - _, _, lastName, _ := getName() 避免声明不必要的变量
   
 - 错误处理 
   - defer、panic和recover
   
 - 匿名函数和闭包  
 
 - 类型和接口 
   - 不支持继承和重载
   - 接口和类型可以直接转换，甚至接口的定义都不用在类型定义之前，这种比较松散的对应关系可以大幅降低因为接口调整而导致的大量代码调整工作。
```
#我们在实现Bird类型时完全没有任何IFly的信息。我们可以在另外一个地方定义这个IFly
接口：
type IFly interface { 
 Fly() 
} 
#这两者目前看起来完全没有关系，现在看看我们如何使用它们：
func main() { 
 var fly IFly = new(Bird) 
 fly.Fly() 
}

```
 - 并发编程
   - goroutine
   - 通过使用goroutine而不是裸用操作系统的并发机制，以及使用消息传递来共享内存而不是使用共享内存来通信，Go语言让并发编程变得更加轻盈和安全。通过在函数调用前使用关键字go，我们即可让该函数以goroutine方式执行。goroutine是一种比线程更加轻盈、更省资源的协程。Go语言通过系统的线程来多路派遣这些函数的执行，使得每个用go关键字执行的函数可以运行成为一个单位协程。
   - CSP/channel
   - 在CSP模型中，一个并发系统由若干并行运行的顺序进程组成，每个进程不能对其他进程的变量赋值。进程之间只能通过一对通信原语实现协作。Go语言用channel（通道）这个概念来轻巧地实现了CSP模型。channel的使用方式比较接近Unix系统中的管道（pipe）概念，可以方便地进行跨goroutine的通信。
   - sync 包 续写锁
  
 - 反射  
   - 反射最常见的使用场景是做对象的序列化（serialization，有时候也叫Marshal & Unmarshal）。例如，Go语言标准库的encoding/json、encoding/xml、encoding/gob、encoding/binary等包就大量依赖于反射功能来实现。
  
 - 语言交互性
   - 重用C模块，Cgo

## 基本规范
```
package main 
import "fmt"// 我们需要使用fmt包中的Println()函数
func main() { 
 fmt.Println("Hello, world. 你好，世界！") 
}
```
 - package : 本go程序所包含的函数所在的包 
 - import : 本go程序所用的函数所依赖的包 以上，main 里面用到的println 依赖于fmt 包
 - main : main包的main()函数是Go可执行程序的执行起点，Go语言的main()函数不能带参数，也不能定义返回值。
 - 所有函数以 func 开头，func 函数名(参数列表)(返回值列表) 
 - 注释  行注释//   块/*  */
 - 没有分号
 - 左花括号不能另起一行 ｛

## 安装
https://golang.org/dl/
下载二进制，根据官网进行安装

## 环境变量
```
# /etc/profile
export GOROOT=/usr/local/go
export GOPATH=/vob/go ## 可以用多个路径用分号隔开
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
```
GOROOT是go软件安装路径
GOPATH是个人项目代码路径
效验环境配置是否生效
```
go version
go env
```

## 编译和运行

#### go build
```
#只生成可执行程序 hello
go build hello.go
#运行该程序
./hello
```
#### go run
```
# 编译 链接 运行一体，直接运行出结果，不生成中间文件和可执行程序
go run hello.go
```
![title](https://leanote.com/api/file/getImage?fileId=5ee19cddab64416aa700048e)

#### GOPATH/src

如果把包裹go源码的文件夹放在上面设置的 GOPATH/src 下，如            GOPATH/src/example/hello.go
那么可以在任意地方直接build $GOPATH/src 下的文件夹，会直接编译文件夹下的go 文件
```
cd /vob/go/bin #或进入任何需要存放example 可执行程序的路径
go build example #会自动去$GOPATH/src下找example文件夹目标源码
ll `pwd`/example #生成
```
![title](https://leanote.com/api/file/getImage?fileId=5ee1afaeab644168ab0005be)

## 变量
#### 关键字 声明和初始化
关键字var , 非必要元素
:=  表示同时进行声明和初始化，编译器会自动推导出类型，左边如果是已经声明过的，会报错
以下相等：
```
var v1 int = 10 // 正确的使用方式1 
var v2 = 10 // 正确的使用方式2，编译器可以自动推导出v2的类型
v3 := 10 // 正确的使用方式3，编译器可以自动推导出v3的类型
```

#### 变量赋值
```
var v10 int
v10 = 123
Go语言的变量赋值与多数语言一致，但Go语言中提供了C/C++程序员期盼多年的多重赋值功
能，比如下面这个交换i和j变量的语句：
i, j = j, i
```
#### 匿名变量
```
_, _, nickName := GetName()
```
## 常量
#### 字面常量
Go语言的字面常量更接近我们自然语言中的常量概念，它是无类型的。只要这个常量在相应类型的值域范围内，就可以作为该类型的常量，比如上面的常量12，它可以赋值给int、uint、int32、int64、float32、float64、complex64、complex128等类型的变量。

#### 常量定义
关键这const
Go的常量定义可以限定常量类型，但不是必需的。如果定义常量时没有指定类型，那么它
与字面常量一样，是无类型常量。
常量定义的右值也可以是一个在编译期运算的常量表达式，但不能是运行期得到结果的表达式

#### 预定义常量
Go语言预定义了这些常量：true、false和iota。

iota比较特殊，可以被认为是一个可被编译器修改的常量，在每一个const关键字出现时被
重置为0，然后在下一个const出现之前，每出现一次iota，其所代表的数字会自动增1。

#### 枚举
一系列相关的常量，比如一星期每天的定义
```
const ( 
 Sunday = iota
 Monday 
 Tuesday 
 Wednesday 
 Thursday 
 Friday 
 Saturday 
 numberOfDays // 这个常量没有导出 
) 
同Go语言的其他符号（symbol）一样，以大写字母开头的常量在包外可见。
以上例子中numberOfDays为包内私有，其他符号则可被其他包访问。
```

## 类型
#### 布尔
关键字 bool 
值 true false
### 整型
类型不一时，编译器也不会帮你自动做类型转换有编译错误：使用强制类型转换可以解决这个类型不匹配编译错误，但是需要注意数据精度损失
##### 整数运算
常规整数运算：+、-、*、/和%。加减乘除就不详细解释了，% 和在C语言中一样是求余运算，比如：
```
5 % 3 // 结果为：2
```
##### 比较运算
运算符：>、<、==、>=、<=和!=
两个不同类型的整型数不能直接比较，比如int8类型的数和int类型的数不能直接比较，但
各种类型的整型变量都可以直接与字面常量（literal）进行比较
#### 位运算
|运算 |含义| 样例 |
| :--- | :----: | :---: |
|x << y  |左移| 124 << 2|
|x >> y  |右移| 124 >> 2|
|x ^ y   |异或| 124 ^ 2 |
|x & y   |与  | 124 & 2 |
|x \| y   |或 | 124 | 2 |
|^x     |取反|  ^2      |

### 浮点型
##### 浮点表示
```
var fvalue1 float32
fvalue1 = 12 
fvalue2 := 12.0 // 如果不加小数点，fvalue2会被推导为整型而不是浮点型
//类型被自动推导的fvalue2，需要注意的是其类型将被自动设为float64
```
##### 浮点比较
因为浮点数不是一种精确的表达方式，所以像整型那样直接用==来判断两个浮点数是否相等
是不可行的，这可能会导致不稳定的结果。
下面是一种推荐的替代方案：
```
import "math" 
// p为用户自定义的比较精度，比如0.00001 
func IsEqual(f1, f2, p float64) bool { 
 return math.Fdim(f1, f2) < p
}
```

### 复数类型
对于一个复数z = complex(x, y)，就可以通过Go语言内置函数real(z)获得该复数的实
部，也就是x，通过imag(z)获得该复数的虚部，也就是y。

### 字符串

var str string // 声明一个字符串变量
字符串的内容可以用类似于数组下标的方式获取，但与数组不同，字符串的内容不能在初始
化后被修改。

##### 字符串操作
x+y
len(x)
x[i]

##### 字符类型
字符类型
在Go语言中支持两个字符类型，一个是byte（实际上是uint8的别名），代表UTF-8字符串的单个字节的值；另一个是rune，代表单个Unicode字符。

### 数组
##### 元素访问

##### 值类型

Navigation

Recent Posts

Friend Links