初識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)
}