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