函数
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)
}
}
如果内容对你有帮助，记得关注作者给个赞哦~，后续会持续更新。
