Go语法

Go语言的这些地方都做的还不错：拥有自动垃圾回收、一个包系统、函数作为一等公民、词法作用域、系统调用接口、只读的UTF8字符串等。但是Go语言本身只有很少的特性，也不太可能添加太多的特性。例如，它没有隐式的数值转换，没有构造函数和析构函数，没有运算符重载，没有默认参数，也没有继承，没有泛型，没有异常，没有宏，没有函数修饰，更没有线程局部存储。但是，语言本身是成熟和稳定的，而且承诺保证向后兼容：用之前的Go语言编写程序可以用新版本的Go语言编译器和标准库直接构建而不需要修改代码。

我们还可以使用 go build 命令来生成二进制文件：

行分隔符
在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。

注释
单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾。如：

字符串连接
Go 语言的字符串可以通过 + 实现：

格式化字符串
Go 语言中使用 fmt.Sprintf 格式化字符串并赋值给新串：

其他运算符
& 返回变量存储地址 例如 &a; 将给出变量的实际地址;

• 指针变量 例如 *a,是一个指针变量;

条件语句
Go 没有三目运算符，所以不支持 ?: 形式的条件判断。

循环语句
break语句:跳出for或switch;
contonue:跳过下面的for从下一轮开始;
goto:跳到某一行

函数
Go 语言最少有个 main() 函数。有且只能有一个

函数定义
func function_name( [parameter list] ) [return_types] {
函数体
}
如返回输入值的2倍
func func_test(a int) int {
return a*=2;
}
如求最大值
func getMax(a,b int) int{
if(a > b) {
return a
} else{
return b
}
}

函数用法

1. 闭包 闭包是匿名函数,可在动态编程中使用;
2. 函数作为另外一个函数的实参
3. 方法

变量作用域

1. 局部;2.全局3.形参
   全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑,即就近原则

初始化局部和全局变量
int:0
float:32
pointer:nil

数组
Go语言数组需要指定元素类型及元素个数
格式如下:
var variable_name [SIZE] variable_type
如 var array_init [10] float32

更多例子
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
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 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：
// 将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

访问数组元素
var value float32 = balance[9]

指针
我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
package main
import "fmt"
func main() {
var a int = 10
fmt.Printf("变量的地址: %x\n", &a )
}

什么是指针
一个指针变量指向了一个值的内存地址。

类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：
var var_name *var-type
例如:
var ip *int
var fp *float32

如何使用指针
指针使用流程：
1.定义指针变量。
2.为指针变量赋值。
3.访问指针变量中指向地址的值。

当一个指针被定义后没有分配到任何变量时，它的值为 nil。
nil 指针也称为空指针。
nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。
一个指针变量通常缩写为 ptr。

结构体
Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
结构体表示一项记录，比如保存图书馆的书籍记录，每本书有以下属性：
在Java中叫集合,但是比集合更强大,更像是实体bean,对象,只是没有方法而已
包括成员的访问都是和java是一样的

package main

import "fmt"

type Books struct {
title string
author string
subject string
book_id int
}

func main() {
var Book1 Books /* 声明 Book1 为 Books 类型 /
var Book2 Books / 声明 Book2 为 Books 类型 */

/* book 1 描述 */
Book1.title = "Go 语言"
Book1.author = "www.runoob.com"
Book1.subject = "Go 语言教程"
Book1.book_id = 6495407

/* book 2 描述 */
Book2.title = "Python 教程"
Book2.author = "www.runoob.com"
Book2.subject = "Python 语言教程"
Book2.book_id = 6495700

/* 打印 Book1 信息 */
printBook(&Book1)

/* 打印 Book2 信息 */
printBook(&Book2)
}
func printBook( book *Books ) {
fmt.Printf( "Book title : %s\n", book.title)
fmt.Printf( "Book author : %s\n", book.author)
fmt.Printf( "Book subject : %s\n", book.subject)
fmt.Printf( "Book book_id : %d\n", book.book_id)
}

Go 语言切片(Slice)
Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
强!!!
切片声明时不需要指定长度

范围(Range)
Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。没看太懂
package main
import "fmt"
func main() {
//这是我们使用range去求一个slice的和。使用数组跟这个很类似
nums := []int{2, 3, 4}
sum := 0
for , num := range nums {
sum += num
}
fmt.Println("sum:", sum)
//在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符""省略了。有时侯我们确实需要知道它的索引。
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
//range也可以用在map的键值对上。
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
}
//range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
for i, c := range "go" {
fmt.Println(i, c)
}
}

Map集合
Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

2种声明方式
/* 声明变量，默认 map 是 nil /
var map_variable map[key_data_type]value_data_type
// 为啥搞个[] 感觉乖乖的 也体现不了 key-value呀
/ 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对

delete函数

递归函数

类型转换
type_name(expression) 与java顺序一致
此外go不支持隐式类型转换 如
var a int32
var b int 64
a = b
会报类型转换错误
a = int32(b)

接口
使用实例
/* 定义接口 */
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] {
/ 方法实现*/
}

可以看到 struct方法并不是在struct里实现的,而是通过在参数里传递具体的struct以及变量
如下所示
package main

import (
"fmt"
)

type Phone interface {
call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
fmt.Println("I am iPhone, I can call you!")
}

func main() {
var phone Phone

phone = new(NokiaPhone)
phone.call()

phone = new(IPhone)
phone.call()

}

错误处理
Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
error类型是一个接口类型，这是它的定义：

type error interface {
Error() string
}
我们可以在编码中通过实现 error 接口类型来生成错误信息。

函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息：

Go并发
Go语言支持并发,只需要通过go关键字来开启goroutine
goroutine是轻量级线程 什么叫轻量级线程 和普通的线程有什么区别

goroutone语法格式
go 函数名(参数列表)

go f(x,y,z)
开启一个新的goroutine线程
func main() {
go say("world")
say("hello")
}
Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goroutine 共享同一个地址空间。
啥叫运行期线程? 运行完就结束这个意思? 共享同一个地址空间? 这么轻量?那不是相当于一个线程分成了多个线程来用?

通道 channel
通道（channel）用于两个 goroutine 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。
ch <- v // 把 v 发送到通道 ch
v := <-ch // 从 ch 接收数据
// 并把值赋给 v

声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：