Go基礎文法（二）

函數

Go 語言中，函數聲明通用文法如下：

func functionname(parametername type) returntype {  
    // 函數體（具體實作的功能）
}

函數的參數清單定義在 ( 和 ) 之間，傳回值的類型則定義在之後的 returntype (傳回值類型) 處。
聲明一個參數的文法采用 參數名參數類型 的方式，任意多個參數采用類似 (參數1 參數1的類型,參數2 參數2的類型) 的形式指定，或者 (參數1，參數2，參數類型) 。
函數中的參數清單和傳回值并非是必須的。

示例代碼：

package main
import "fmt"

func main()  {
    s := price(20, 30)
    fmt.Println(s)
}
//如果有連續個參數，它們的類型一緻，無須一一羅列，隻需在最後一個參數後添加該類型。
func price(apple, banana int) int  {
    sum := apple + banana
    return sum
}

多傳回值

Go 語言支援一個函數可以有多個傳回值。

func main()  {
    name, sum := price("蘋果", 30)
    fmt.Println(name, sum)
}

func price(apple string, banana int) (string, int)  {

    return apple, banana
}

命名傳回值

函數的傳回值第一行就被聲明為變量了。

func price(apple string, banana int)(a string, b int)  {
    a = apple + "demo"
    b = banana + 20
    return
}

函數中的 return 語句沒有顯式傳回任何值。由于 area 和 perimeter 在函數聲明中指定為傳回值, 是以當遇到 return 語句時, 它們将自動從函數傳回。

空白符

在 Go 中被用作空白符，可以用作表示任何類型的任何值。

func main()  {
    var sum, _ = demo(4, 5)
    fmt.Println(sum)
}

func demo(a, b int)(int, int)  {
    var sum = a*b
    var cum =(a+b)*2
    return sum, cum
}

在程式的 var sum, _ = demo(4, 5) 這一行，空白符

用來跳過不要的計算結果。

包

包用于組織 Go 源代碼，提供了更好的可重用性與可讀性。

main 函數和 main 包

所有可執行的 Go 程式都必須包含一個 main 函數。這個函數是程式運作的入口。main 函數應該放置于 main 包中。

package packagename

這行代碼指定了某一源檔案屬于一個包。它應該放在每一個源檔案的第一行。

建立自定義的包

src檔案夾下建立test_one檔案夾，test_one下建立test_1.go檔案，在test_one檔案夾下建立demo檔案夾，demo檔案夾中建立demo1.go，目錄如下：

src
   test_one
       test_1.go
       demo
          demo1.go

在demo1.go中編輯兩個測試函數：

package demo

import "fmt"

func A_demo()  {
    fmt.Println("This A_demo func")
}

func B_demo()  {
    fmt.Println("This B_demo func")
}

在test_1.go中導入demo包：

package main

import (
    "fmt"
    "test_one/demo"
)

func main()  {
    fmt.Print()
    demo.A_demo()
    demo.B_demo()
}

運作可以看到結果。

導出名字（Exported Names）

我們将 demo1 包中的函數 A 和 B 首字母大寫。在 Go 中這具有特殊意義。在 Go 中，任何以大寫字母開頭的變量或者函數都是可被導出的名字。換句話說就是外部包可以使用這些變量或函數，小寫字母的變量或函數不能被外部包使用。

其它包隻能通路被導出的函數和變量

。在這裡，我們需要在 main 包中通路 A和 B函數，是以會将它們的首字母大寫。

init函數

所有包都可以包含一個 init 函數。init 函數不應該有任何傳回值類型和參數，在我們的代碼中也不能顯式地調用它。

func init() {  
}

init 函數可用于執行初始化任務，也可用于在開始執行之前驗證程式的正确性。

包的初始化順序如下：

首先初始化包級别（Package Level）的變量
緊接着調用 init 函數。包可以有多個 init 函數（在一個檔案或分布于多個檔案中），它們按照編譯器解析它們的順序進行調用。
如果一個包導入了另一個包，會先初始化被導入的包。
盡管一個包可能會被導入多次，但是它隻會被初始化一次。

測試init函數：給test_1.go和demo1.go中增加init函數并列印test_one和demo

func init()  {
    fmt.Println("This is test_one package init")
}

func init()  {
    fmt.Println("This is demo package init")
}

main 包的初始化順序為：

首先初始化被導入的包。是以，首先初始化了 rectangle 包。
接着初始化了包級别的變量 rectLen 和 rectWidth。
調用 init 函數。
最後調用 main 函數。

使用空白辨別符（Blank Identifier）

導入了包，卻不在代碼中使用它，這在 Go 中是非法的。當這麼做時，編譯器是會報錯的。其原因是為了避免導入過多未使用的包，進而導緻編譯時間顯著增加。

然而，在程式開發的活躍階段，又常常會先導入包，而暫不使用它。遇到這種情況就可以使用空白辨別符 _。

import (
    "fmt"
    "test_one/demo"
)

func init()  {
    fmt.Println("This is test_one package init")
}
var _ = demo.A_demo
func main()  {
    fmt.Print()

}

有時候我們導入一個包，隻是為了確定它進行了初始化，而無需使用包中的任何函數或變量，可以這樣寫：

package main 

import (
    _ "test_one/demo" 
)
func main() {

}

運作代碼後可以看到還是在demo1.go中運作了init函數。

if-else語句

if statement; condition {  
}

示例：

package main

import (  
    "fmt"
)

func main() {  
    if num := 10; num % 2 == 0 { //checks if number is even
        fmt.Println(num,"y") 
    }  else {
        fmt.Println(num,"n")
    }
}

在上面的程式中，num 在 if 語句中進行初始化，num 隻能從 if 和 else 中通路。也就是說 num 的範圍僅限于 if else 代碼塊。如果我們試圖從其他外部的 if 或者 else 通路 num,編譯器會不通過。

if語句中，else必須跟在

後邊，不能換行，因為Go 語言的分号是自動插入。

在 Go 語言規則中，它指定在

之後插入一個分号，如果這是該行的最終标記。是以，在if語句後面的

會自動插入一個分号。

由于 if{…} else {…} 是一個單獨的語句，它的中間不應該出現分号。

package main

import (  
    "fmt"
)

func main() {  
    num := 99
    if num <= 50 {
        fmt.Println("number is less than or equal to 50")
    } else if num >= 51 && num <= 100 {
        fmt.Println("number is between 51 and 100")
    } else {
        fmt.Println("number is greater than 100")
    }

}

for 循環文法

for initialisation; condition; post {  
}

簡寫：

package main

import (  
    "fmt"
)

func main() {  
    i := 0
    for i <= 10 { //semicolons are ommitted and only condition is present
        fmt.Printf("%d ", i)
        i += 2
    }
}

break，continue：

package main

import (
    "fmt"
)

func main() {
    for i := 1; i <= 20; i++ {
        if i > 10 {
            break //loop is terminated if i > 5
        }

        if i % 2 ==0{
            continue
        }
        fmt.Printf("%d ", i)
    }
    fmt.Printf("\nline after for loop")


    for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 { //multiple initialisation and increment
        fmt.Printf("%d * %d = %d\n", no, i, no*i)
    }


}

無限循環

package main

import "fmt"

func main() {  
    for {
        fmt.Println("Hello World")
    }
}

switch 語句

func main() {
    switch finger := 8; finger {
    case 1:
        fmt.Println("Thumb")
    case 2:
        fmt.Println("Index")
    case 3:
        fmt.Println("Middle")
    case 4:
        fmt.Println("Ring")
    case 5:
        fmt.Println("Pinky")
    default: // 預設情況
        fmt.Println("incorrect finger number")
    }
}

當它不符合其中任何情況，會使用預設值。

多表達式判斷

package main

import (
    "fmt"
)

func main() {
    letter := "i"
    switch letter {
    case "a", "e", "i", "o", "u": // 一個選項多個表達式
        fmt.Println("vowel")
    default:
        fmt.Println("not a vowel")
    }
}

無表達式的 switch

在 switch 語句中，表達式是可選的，可以被省略。如果省略表達式，則表示這個 switch 語句等同于 switch true，并且每個 case 表達式都被認定為有效，相應的代碼塊也會被執行。

package main

import (
    "fmt"
)

func main() {
    num := 75
    switch { // 表達式被省略了
    case num >= 0 && num <= 50:
        fmt.Println("num is greater than 0 and less than 50")
    case num >= 51 && num <= 100:
        fmt.Println("num is greater than 51 and less than 100")
    case num >= 101:
        fmt.Println("num is greater than 100")
    }

}

Fallthrough 語句

在 Go 中，每執行完一個 case 後，會從 switch 語句中跳出來，不再做後續 case 的判斷和執行。使用 fallthrough 語句可以在已經執行完成的 case 之後，把控制權轉移到下一個 case 的執行代碼中。

package main

import (
    "fmt"
)

func number() int {
    num := 15 * 5 
    return num
}

func main() {

    switch num := number(); { // num is not a constant
    case num < 50:
        fmt.Printf("%d is lesser than 50\n", num)
        fallthrough
    case num < 100:
        fmt.Printf("%d is lesser than 100\n", num)
        fallthrough
    case num < 200:
        fmt.Printf("%d is lesser than 200", num)
    }

}

如果内容對你有幫助，記得關注作者給個贊哦~，後續會持續更新。

Go基礎文法（二）

函數

空白符

包

init函數

使用空白辨別符（Blank Identifier）

if-else語句

for 循環文法

switch 語句

繼續閱讀

Golang結構體中的tag

GO語言筆記--結構體1.說明2.工廠函數

Go語言之map與結構體初入map結構體初入（場景map的value通常為struct）

Go初探 (5) – 結構體與接口

go(7)結構體，方法，接口

Go學習筆記: 結構體、方法、接口

06結構體、接口結構體接口

go語言筆記（結構體、方法、接口）go語言筆記（結構體、方法、接口）

Go中結構體和接口的定義

Rich Domain Model

【C++進階】__stdcall 詳解函數調用約定

Linux之父警告全球程式員：我剛釋出的5.12核心有bug，你們千萬别用

DOG（4）：解析器的部分實作細節先來說說parser一些可能迷惑的地方結果如何傳回?pcd其實是一回事最後的一點說明

effective c++ 第三版讀書筆記1

可變參數宏， Variadic Macros

什麼是BNF範式