函数

Go 语言中，函数声明通用语法如下：

func functionname(parametername type) returntype {  
    // 函数体（具体实现的功能）
}

1. 函数的参数列表定义在 (和) 之间，返回值的类型则定义在之后的 returntype (返回值类型)处。
2. 声明一个参数的语法采用 参数名 参数类型 的方式，任意多个参数采用类似 (参数1 参数1的类型,参数2 参数2的类型)的形式指定，或者(参数1， 参数2，参数类型)。
3. 函数中的参数列表和返回值并非是必须的。

示例代码：

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 函数可用于执行初始化任务，也可用于在开始执行之前验证程序的正确性。

包的初始化顺序如下：

1. 首先初始化包级别（Package Level）的变量
2. 紧接着调用 init 函数。包可以有多个 init 函数（在一个文件或分布于多个文件中），它们按照编译器解析它们的顺序进行调用。
3. 如果一个包导入了另一个包，会先初始化被导入的包。
4. 尽管一个包可能会被导入多次，但是它只会被初始化一次。

测试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 包的初始化顺序为：

1. 首先初始化被导入的包。因此，首先初始化了 rectangle 包。
2. 接着初始化了包级别的变量 rectLen 和 rectWidth。
3. 调用 init 函数。
4. 最后调用 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)
    }

}

如果内容对你有帮助，记得关注作者给个赞哦~，后续会持续更新。