GO 語言 新手教程（一） 基礎語法

GO 語言結構

package main 
//定義了包名, 必須在源文件中非註釋的第一行指明這個文件屬於哪個包
//package main表示一個可獨立執行的程序，每個 Go 應用程序都包含一個名爲 main 的包 

import "fmt" 
//使用 fmt 包（的函數，或其他元素），fmt 包實現了格式化 IO（輸入/輸出）的函數

func main() { 
//程序開始執行的函數。main 函數是每一個可執行程序所必須包含的
   /* 這是我的第一個簡單的程序 */
   fmt.Println("Hello, World!") //將字符串輸出到控制檯， 
}

Go 語言數據類型

序號	類型	描述
1	uint8	無符號 8 位整型 (0 到 255)
2	uint16	無符號 16 位整型 (0 到 65535)
3	uint32	無符號 32 位整型 (0 到 4294967295)
4	uint64	無符號 64 位整型 (0 到 18446744073709551615)
5	int8	有符號 8 位整型 (-128 到 127)
6	int16	有符號 16 位整型 (-32768 到 32767)
7	int32	有符號 32 位整型 (-2147483648 到 2147483647)
8	int64	有符號 64 位整型 (-9223372036854775808 到 9223372036854775807)
1	float32	IEEE-754 32位浮點型數
2	float64	IEEE-754 64位浮點型數
3	complex64	32 位實數和虛數
4	complex128	64 位實數和虛數
1	byte	類似 uint8
2	rune	類似 int32
3	uint	32 或 64 位
4	int	與 uint 一樣大小
5	uintptr	無符號整型，用於存放一個指針

Go 語言變量

聲明變量的一般形式是使用 var 關鍵字：

var identifier type

第一種，指定變量類型，聲明後若不賦值，使用默認值。

var v_name v_type
v_name = value

第二種，根據值自行判定變量類型。

var v_name = value

第三種，省略var, 注意 :=左側的變量不應該是已經聲明過的，否則會導致編譯錯誤。

v_name := value

// 例如
var a int = 10
var b = 10
c := 10

實例

package main
var a = "菜鳥教程"
var b string = "runoob.com"
var c bool

func main(){
    println(a, b, c)
}

多變量聲明實例

package main

var x, y int
var (  // 這種因式分解關鍵字的寫法一般用於聲明全局變量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//這種不帶聲明格式的只能在函數體中出現
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

賦值使用技巧

1.  同一類型的多個變量可以聲明在同一行
var a, b, c int
2. 多變量可以在同一行進行賦值
var a, b int
var c string
a, b, c = 5, 7, "abc"

3.假設了變量 a，b 和 c 都已經被聲明，否則的話應該這樣使用
a, b, c := 5, 7, "abc"
4.交換兩個變量的值
a, b = b, a
空白標識符 _ 也被用於拋棄值，如值 5 在：_, b = 5, 7 中被拋棄
5.一個函數返回多個返回值
val, err = Func1(var1)。 

GO語言常量

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

常量的定義格式

常量的定義格式：

const identifier [type] = value

    顯式類型定義： const b string = "abc"
    隱式類型定義： const b = "abc"


const c_name1, c_name2 = value1, value2

常量還可以用作枚舉：

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

iota 特殊常量

在每一個const關鍵字出現時，被重置爲0，然後再下一個const出現之前，每出現一次iota，其所代表的數字會自動增加1。

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //獨立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢復計數
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

以上實例運行結果爲：

0 1 2 ha ha 100 100 7 8
感覺很奇怪```

Go 語言運算符

同C語言完全一致。
http://www.runoob.com/go/go-operators.html

條件語句

語句	描述
if 語句	if 語句 由一個布爾表達式後緊跟一個或多個語句組成。
if…else 語句	if 語句 後可以使用可選的 else 語句, else 語句中的表達式在布爾表達式爲 false 時執行。
if 嵌套語句	你可以在 if 或 else if 語句中嵌入一個或多個 if 或 else if 語句。
switch 語句	switch 語句用於基於不同條件執行不同動作。
select 語句	select 語句類似於 switch 語句，但是select會隨機執行一個可運行的case。如果沒有case可運行，它將阻塞，直到有case可運行。

package main

import "fmt"

func main() {
   /* 定義局部變量 */
   var a int = 10

   /* 使用 if 語句判斷布爾表達式 */
   if a < 20 {
       /* 如果條件爲 true 則執行以下語句 */
       fmt.Printf("a 小於 20\n" )
   }
   fmt.Printf("a 的值爲 : %d\n", a)
}

循環語句

語句	描述
for 循環	重複執行語句塊
循環嵌套	在 for 循環中嵌套一個或多個 for 循環
break 語句	經常用於中斷當前 for 循環或跳出 switch 語句
continue 語句	跳過當前循環的剩餘語句，然後繼續進行下一輪循環。
goto 語句	將控制轉移到被標記的語句。

實例：

package main

import "fmt"

func main() {

   var b int = 15
   var a int

   numbers := [6]int{1, 2, 3, 5} 

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

   for a < b {
      a++
      fmt.Printf("a 的值爲: %d\n", a)
   }

   for i,x:= range numbers {
      fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
   }   
}

GO語言函數

    func function_name( [parameter list] ) [return_types] {
   函數體
}
函數定義解析：

func：函數由 func 開始聲明
function_name：函數名稱，函數名和參數列表一起構成了函數簽名。
parameter list：參數列表，參數就像一個佔位符，當函數被調用時，你可以將值傳遞給參數，這個值被稱爲實際參數。參數列表指定的是參數類型、順序、及參數個數。參數是可選的，也就是說函數也可以不包含參數。
return_types：返回類型，函數返回一列值。return_types 是該列值的數據類型。有些功能不需要返回值，這種情況下 return_types 不是必須的。
函數體：函數定義的代碼集合。

/* 函數返回兩個數的最大值 */
func max(num1, num2 int) int {
   /* 聲明局部變量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

函數返回多個值

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}

Go 語言函數閉包

Go 語言支持匿名函數，可作爲閉包。匿名函數是一個”內聯”語句或表達式。匿名函數的優越性在於可以直接使用函數內的變量，不必申明。

package main

import "fmt"

func getSequence() func() int {
   i:=0
   return func() int {
      i+=1
     return i  
   }
}

func main(){
   /* nextNumber 爲一個函數，函數 i 爲 0 */
   nextNumber := getSequence()  

   /* 調用 nextNumber 函數，i 變量自增 1 並返回 */
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())

   /* 創建新的函數 nextNumber1，並查看結果 */
   nextNumber1 := getSequence()  
   fmt.Println(nextNumber1())
   fmt.Println(nextNumber1())
}

1
2
3
1
2