初识Golang

//今天第一次看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)
}