初識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(…)可以將字串輸出到控制檯，並在最後自動增加換行字元
。

基本語法結構

行分隔符

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
", a)
}

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

//也能這麼用...有意思
numbers := [6]int{1, 2, 3, 5}
for i, x := range numbers {
    fmt.Printf("第 %d 位 x 的值 = %d
", 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)
}