GO 語言結構

package main 
//定義了包名, 必須在原始檔中非註釋的第一行指明這個檔案屬於哪個包
//package main表示一個可獨立執行的程式，每個 Go 應用程式都包含一個名為 main 的包 

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

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

Go 語言資料型別

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 語言運算子

條件語句

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

迴圈語句

例項：

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