Go語言

參考文章 菜鳥教程

　　Go 語言被設計成一門應用於搭載 Web 服務器，存儲集羣或相似用途的巨型中央服務器的系統編程語言。對於高性能分佈式系統領域而言，Go 語言無疑比大多數其它語言有着更高的開發效率。它提供了海量並行的支持，這對於遊戲服務端的開發而言是再好不過了。

1、環境安裝

　　安裝包下載地址爲 https://golang.org/dl/， 解壓後將bin目錄添加到環境變量，便可執行腳本 go run test.go

2、基礎語法

Go 標記： Go 程序能夠由多個標記組成，能夠是關鍵字，標識符，常量，字符串，符號

包：package main表示一個可獨立執行的程序，每一個 Go 應用程序都包含一個名爲 main 的包。

行分隔符：一行表明一個語句結束，若是你打算將多個語句寫在同一行，它們則必須使用 ; 區分，但在實際開發中咱們並不鼓勵這種作法。

標識符：標識符用來命名變量、類型等程序實體。一個標識符實際上就是一個或是多個字母、數字、下劃線組成的序列，並且標識符不能是關鍵字，以數字開頭或包含運算符。有效的標識符： _temp、 a_123，無效的標識符：1ab、case、a+b

3、變量

1. 變量聲明：

var a int = 10 // var a int; a=10; 指定變量類型，聲明後若不賦值，使用默認值。
var a = 10 // 根據值自行斷定變量類型。
a : = 10 // 省略var, 注意 :=左側的變量若已經聲明過會致使編譯錯誤。這是使用變量的首選形式，可是它只能被用在函數體內，而不能用於全局變量的聲明與賦值

若是你聲明瞭一個局部變量卻沒有在相同的代碼塊中使用它，會獲得編譯錯誤。可是全局變量是容許聲明但不使用。

2. 多變量聲明

var a, b, c= 1, 2, 3

並行賦值也被用於當一個函數返回多個返回值時，如調用 Func1 函數獲得val和err：val, err = Func1(var1)。

3. 值類型和引用類型：

　　像 int、float、bool 和 string 這些基本類型都屬於值類型

 　　一個引用類型的變量存儲的是其值所在的內存地址，這個內存地址稱爲指針。* 表示指針變量，& 返回變量存儲地址

var a int = 4
var ptr *int
ptr = &a    // ptr賦值爲a變量的地址
fmt.Printf("a = %d\n", a);
fmt.Printf("*ptr = %d\n", *ptr);
fmt.Println("is null:", ptr == nil); // 判斷是否爲空指針

變量做用域

Go 語言中變量能夠在三個地方聲明：

• 局部變量：函數內定義的變量，返回值變量也是局部變量。
• 全局變量：函數外定義的變量，能夠在整個包甚至外部包（被導出後）使用。
• 形式參數：函數定義中的變量，函數參數

package main
import "fmt"

var g int = 20  // 聲明全局變量
func main() {
   var g int = 10  // 聲明局部變量 
   fmt.Printf ("g = %d\n",  g)  // g = 10, 全局變量與局部變量名稱能夠相同，可是函數內的局部變量會被優先考慮
}

4、常量

常量是一個簡單值的標識符，在程序運行時，不會被修改的量。常量中的數據類型只能夠是布爾型、數字型（整數型、浮點型和複數）和字符串型。

　　顯式類型定義： const b string = "abc"
　　隱式類型定義： const b = "abc"　 // 能夠省略 變量類型[type]，編譯器能夠根據變量的值來推斷其類型。

多個相同類型的聲明能夠簡寫爲：const a, b= 1, 2

常量還能夠用做枚舉：

const (
    Unknown = 0
    Female = 1
    Male = 2
)

常量能夠用len(), cap(), unsafe.Sizeof()函數計算表達式的值。常量表達式中，函數必須是內置函數，不然編譯不過：println(len(a),unsafe.Sizeof(a))

iota

　　iota是go語言的常量計數器，只能在常量的表達式中使用。iota在const關鍵字出現時將被重置爲0(const內部的第一行以前)，const中每新增一行常量聲明將使iota計數一次(iota可理解爲const語句塊中的行索引)。

const a = iota // a=0 
const ( 
  b = iota     // b=0 每次 const 出現時，都會讓 iota 初始化爲0.
  c            // c=1 
  d = 3<<iota  // d=3<<2=12
  e            // e=3<<3=24
  d = "ha"     // d="ha", iota=4
  e            // e="ha", iota=5
  f = iota     // f=6
)

5、條件和循環語句

6、數組

1. 聲明格式：var variable_name [SIZE] variable_type   

2. 數組初始化：
　　var numbers = [3]int{1, 2, 3}
　　var numbers = [] int{1, 2, 3}  //不設置數組大小，根據元素的個數來設置大小

3. 二維數組：

var a [3][4]int
a = [3][4]int{  
    {0, 1, 2, 3},   
    {4, 5, 6, 7},   
    {8, 9, 10, 11},  
}

4. 向函數傳遞數組

func main() {
   var numbers = []int {1, 2, 3, 4, 5}
   var avg float32
   avg = getAverage(numbers, 5);
   fmt.Printf("Average: %f ", avg);
}
func getAverage(arr []int, size int) float32 {
   var i,sum int
   var avg float32  
   for i = 0; i < size;i++ {
      sum += arr[i]
   }
   avg = float32(sum / size)  //類型轉換 return avg;
}

切片（slice）

　　Go 語言切片是對數組的抽象。Go 數組的長度不可改變，Go提供了一種功能強悍的內置類型切片("動態數組"),與數組相比切片的長度是不固定的，能夠追加元素，在追加時可能使切片的容量增大。

切片定義：

聲明一個未指定大小的數組: var identifier []type
或使用make()函數來建立切片: var slice1 []type = make([]type, len), 也能夠簡寫爲slice1 := make([]type, len)
也能夠指定容量，其中capacity爲可選參數。make([]T, length, capacity),這裏 len 是數組的長度而且也是切片的初始長度。

切片初始化：

s :=[] int {1,2,3 }
s := arr[:]  // 切片s爲數組arr的引用。 切片截取：經過設置下限及上限來設置截取切片 s := arr[startIndex:endIndex] ， s := arr[startIndex:] ，s := arr[:endIndex]

　　s :=make([]int,len,cap) //經過內置函數make()初始化切片s

func main() {
    var x []int           // len=0 cap=0, slice=[], 一個切片在未初始化以前默認爲 nil，長度爲 0  
    x = make([]int,2,5)   // len=2 cap=5, slice=[0 0]
    x = append(x, 10)     // len=3 cap=5, slice=[0 0 10], 向切片添加一個元素    
    x = append(x, 11, 12) // len=5 cap=5, slice=[0 0 10 11 12], 向切片添加多個元素    
    x1 := make([]int, len(x), (cap(x))*2) //  建立切片x1是以前切片的兩倍容量
    copy(x1, x)              // len=5 cap=10, slice=[0 0 10 11 12]
}
func printSlice(x []int) {
   fmt.Printf("len=%d cap=%d, slice=%v\n", len(x), cap(x), x)
}

7、Map(集合)

8、結構體

結構體是由一系列具備相同類型或不一樣類型的數據構成的數據集合。數組能夠存儲同一類型的數據，但在結構體中咱們能夠爲不一樣項定義不一樣的數據類型。

 

package main
import "fmt"

type Book struct { // 結構體定義
    title string
    author string
}
func main() {
    var book1 Book
    book1.title = "Java"  // 訪問結構體成員
    book1.author = "Thomas"
    printBook(book1)      // Java {Java Thomas}
    printBook_ptr(&book1) // Java &{Java Thomas}
}
func printBook(b Book) {  // 結構體做爲函數參數
   fmt.Println(b.title, b)
}
func printBook_ptr(b *Book) { // 結構體指針
   fmt.Println(b.title, b)
}

 

9、範圍(Range)

10、函數

　　每個可執行程序必須包含main() 函數，一般它是啓動後第一個執行的函數（若是有 init() 函數則會先執行該函數）。

func main() {
    a, b := 1, 2
    c,d := swap(a, b)
    e := getValue(a)
    fmt.Println(c, d, e)
}
func swap(a int, b int) (int, int){ // 多個返回值
   return b, a
}
func getValue(a int) int { // 一個返回值
   return a
}

函數參數

 

package main
import "fmt"

func main() {
    x, y := 1, 2
    val_swap(x, y)   // 值傳遞 x=1 y=2
    print(x, y)       
    ref_swap(&x, &y) // 引用傳遞 x=2 y=1
    print(x, y)
}
func val_swap(x int, y int) { 
   var temp int
   temp = x
   x = y
   y = temp
}
func ref_swap(x *int, y *int){
    var temp int
    temp = *x
    *x = *y
    *y = temp
}
func print(x int, y int) { 
   fmt.Printf("x=%d y=%d\n", x, y)
}

 

 

函數做爲值

 

 

遞歸函數

11、接口

12、錯誤處理