//今天第一次看Golang，作为初学者总结一下

为什么是GO

年轻，它的诞生必然有他的意义，根据大家对他的介绍，总结下来如下：
Go 语言对于高性能分布式系统领域而言，无疑比大多数其它语言有着更高的开发效率，Go语言具有很强的表达能力，它简洁、清晰而高效。得益于其并发机制，用它编写的程序能够非常有效地利用多核与联网的计算机，其新颖的类型系统则使程序结构变得灵活而模块化。 Go代码编译成机器码不仅非常迅速，还具有方便的垃圾回收机制和强大的运行时反射机制。它是一个快速的、静态类型的编译型语言。
以上是对他的介绍，那么我就感兴趣了，我打算研究一番，学习学习

//今天简单了解了基础语法

基础组成

package main

import "fmt"

func main() {
    fmt.Println("hello")
}

可以看到

• package main 声明包
• import “fmt” 告诉编译器这个程序需要使用 fmt 包，fmt 包实现了格式化 IO（输入/输出）的函数。
• func main() 是程序的开始。main函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
• fmt.Println(…)可以将字符串输出到控制台，并在最后自动增加换行字符 \n。

基本语法结构

行分隔符

Go并不像C那样每条语句以;结尾，在go的世界里，一行代表一条语句结束。当然，如果要将多个语句写在同一行，那么则必须要以;分隔。剩下的交给编译器完成

注释

单行注释以//开头即可，多行注释用/* ... */包裹

标识符

标识符第一个字符必须是字母或下划线。不可用关键字

数据类型

1. 数字类型。支持整形int和浮点型float32、float64，定义时无需指定，编译器识别。
2. 字符串类型。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本。
3. 布尔类型。布尔型的值只可以是常量 true 或者 false。
4. 派生类型。包括 指针类型（Pointer）、数组类型、结构化类型(struct)、Channel 类型、函数类型、切片类型、接口类型（interface）、Map 类型。

变量声明

由字母、数字、下划线组成，不能以数字开头。
声明一般使用var关键字。

1. 指定变量类型，声明后若不赋值，使用默认值。

   var v_name v_type
   v_name = value

2. 根据值自行判定变量类型 var v_name = value。
3. 省略var, 注意 := 左侧的变量不应该是已经声明过的，否则会导致编译错误。

多变量声明

var vname1, vname2, vname3 = v1, v2, v3 

vname1, vname2, vname3 := v1, v2, v3

• 还有个很有意思，声明了没用的变量，编译报错

常量

const identifier [type] = value

运算符

算术运算符

+ - * / % ++ --

关系运算符

== != > < >= <=

逻辑运算符

&& || !

位运算符

& | ^ << >>

赋值运算符

= += -= *= /= %= <<= >>= &= |= ^=

特殊运算符

& //&a 返回变量a的地址
* //*a 是一个指针变量

条件语句

除了if else switch外还有select ，之后单独研究select

循环语句

for a := 0; a < 10; a++ {
    fmt.Printf("a 的值为: %d\n", a)
}

//像while一样
var a, b int = 1, 3
for a < b {
    a++
    fmt.Printf("a 的值为: %d\n", a)
}

//也能这么用...有意思
numbers := [6]int{1, 2, 3, 5}
for i, x := range numbers {
    fmt.Printf("第 %d 位 x 的值 = %d\n", i, x)
}

//还有goto

//明天接着看

2018.1.29 接着熟悉语法

函数

Go 语言最少有个 main() 函数。

函数定义

func fname( [params list] ) [return_types] {
   //函数体
}

比如：

func max(num1 int, num2 int) int {
    if num1 > num2 {
        return num1
    }
    return num2
}
// num1和num2都是int类型
func max(num1, num2 int) int {
    if num1 > num2 {
        return num1
    }
    return num2
}
// 返回多个值
func test(num1, num2 int) (int, int) {
    return num2, num1
}
//需注意参数值传递和引用传递，可传递指针
func test(x int, y int) {
    var tmp = x
    x = y
    y = tmp
}
//可传递指针
func test(x *int, y *int) {
    var tmp = *x
    *x = *y
    *y = tmp
}

变量作用域

• 局部变量的作用域只在函数体内，参数和返回值变量也是局部变量
• 全局变量可以在整个包甚至外部包（被导出后）使用
• 全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑
• 形式参数会作为函数的局部变量来使用
• 注意，初始化的pointer类型为nil

数组

• 定义：数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。

var v_name [SIZE] v_type
var balance [10] int

初始化

//初始化数组中 {} 中的元素个数不能大于 [] 中的数字
var nums = [5]int{1, 2, 3, 4, 5}
//如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小
var nums = [...]int{1, 2, 3}
//exp
func main() {
    var nums = [3]int{1, 2, 3}
    fmt.Println(nums)
    var y [10]int
    for i := 0; i < 10; i++ {
        y[i] = i + 1
    }
    fmt.Println(y)
}

指针

Go 语言的取地址符是 &

var x = 3
fmt.Println(&x) //0xc4200160b8

//声明指针
var x *int

//在指针类型前面加上 * 号（前缀）来获取指针所指向的内容
var x = 3
var pt = &x    //0xc4200160b8
fmt.Println(*pt) //3

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

var x *int //nil

2018.2.1继续

Struct结构体

• 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

例如：

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

如果要访问结构体成员，需要使用点号 (.) 操作符，格式为：”结构体.成员名”

var book1 Books
book1.id = 1
book1.author = "go"
printStructAttr(book1)

func printStructAttr(book Books) {
    fmt.Println(book.author)
}

//指针 var struct_pointer *Books
var book1Pt *Books
book1Pt = &book1
fmt.Println(book1Pt.author)

Slice切片

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

• 定义：var identifier []type //切片不需要说明长度

var slice []int
slice = append(slice, 3)
slice = append(slice, 3, 5, 6)
fmt.Println(slice)

//Exp.
var arr = [3]int{1, 2, 3}
s := arr[:]
fmt.Println(s) //[1 2 3]
s = append(s, 5)
fmt.Println(s) //[1 2 3 5]
t := s[1:3]
fmt.Println(t) //[2 3]
//使用make()函数来创建切片
var slice1 []type = make([]type, len, capacity)

//len() cap()
var numbers = make([]int, 3, 7)
fmt.Println(numbers) //[0 0 0]
fmt.Println(len(numbers)) //3
fmt.Println(cap(numbers)) //7
//下面这个很有意思
numbers = append(numbers, 6, 7, 8, 9, 10)
fmt.Println(numbers) //[0 0 0 6 7 8 9 10]
fmt.Println(len(numbers)) //8
fmt.Println(cap(numbers)) //14 有待研究

Map

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

//声明
var map_name map[key_type]val_type //默认 map 是 nil 
//使用make()初始化
map_name = make(map[string]string)
//直接使用make()
map_name := make(map[string]string)

//赋值
var countryCapitalMap map[string]string
countryCapitalMap = make(map[string]string)
countryCapitalMap["France"] = "Paris"
captial, ok := countryCapitalMap["France"]
fmt.Println(captial)
fmt.Println(ok)

//遍历
for country := range countryCapitalMap {
    fmt.Println("Capital of", country, "is", countryCapitalMap[country])
}

//delete()
delete(countryCapitalMap, "France")

接口

把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

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] {
   /* 方法实现 */
}

Exp.
type Phone interface {
    call(int) string
}

type IPhone struct {
}
func (iPhone IPhone) call(nums int) string {
    fmt.Println("iphone call", nums)
    return "iphone"
}

func main() {
    var phone Phone
    phone = new(IPhone)
    var phoneName = phone.call(123)
    fmt.Println(phoneName)
}