自定义函数
- 函数是面向过程编程的根本，Go 语言原生支持函数
- 函数定义的语法：
func functionName(optionalParameters) optionalReturnType {
body
}
func functionName(optionalParameters) (optionalReturnValues) {
body
}
- 函数如果没有参数那么圆括号是空的
- 函数可以有任意多个参数，如果有参数，则需要写成下面这样：
parames1 type1, ..., paramesN typeN // parames1 是参数，type1 是参数类型
- 参数必须按照给定的顺序来传递
- 如果要实现可变参数，可以将最后一个参数的类型之前写上省略号
- 函数返回值也可以是任意个
- 如果没有返回参数，那么返回值列表的右括号后面是紧接着左大括号
- 如果只有一个返回参数，可以直接写返回的类型
- 如果有多个返回类型，必须使用括号，并且这样写：
(type1, ..., typeN)
- 如果有一个或者多个命名的返回值，也必须使用括号，并且这样写：
(values1 type1, ..., valuesN typeN)
- 返回值可以全面命名，或者全部不命名，不能只是部分命名的
- 如果函数有返回值，则函数必须至少有一个
return 语句或者最后执行 panic() 调用
函数参数
将函数调用作为函数的参数
- 如果参数类型是
interface{}, 我们就可以传递任何类型的数据
- 我们可以将其他函数或者方法调用作为一个函数的参数
- 例子：
for i := 1; i <= 4; i++ {
a, b, c := PythagoreanTriple(i, i+1)
$1 := Heron(a, b, c)
$2 := Heron(PythagoreanTriple(i, i+1))
fmt.Printf("$1 == %10f == $2 == %10f\n", $1, $2)
}
func Heron(a, b, c int) float64 {
α, β, γ := float(a), float(b), float(c)
s := (α + β + γ) / 2
return math.Sqrt(s * (s - α) * (s - β) * (s - γ))
}
func PythagoreanTriple(m, n int) (a, b, c int) {
if m < n {
m, n = n, m
}
return (m * m) - (n * n), (2 * m * m), (m * m) + (n * n)
}
可变参数函数
- 可变参数函数是指函数的最后一个参数可以接受任意个参数
- 这类函数在最后一个参数的类型前面添加有一个省略号
- 在函数内这个可变参数实质上变成了一个对应参数类型的切片
- 例子：
fmt.Println(MinimumIntl(5, 3), MinimumIntl(7, 3, -2, 4, 0, -8, -5))
func MinimumIntl(first int, rest ...int) int {
for _, x := range rest {
if x < first {
first = x
}
}
return first
}
// 如果有一个 []int 类型的切片，我们可以这样使用 MinimumIntl() 函数
numbers := []int{7, 3, -2, 4, 0, -8, -5}
fmt.Println(MinimumIntl(numbers[0], numbers[1:]...))
- 我们可以在 slice 后面放一个省略号，这样可以把切片变成一系列参数
可选参数的函数
- Go 语言并没有直接支持的可选参数
- 实现可选参数并不难，只需要额外增加一个结构体即可，并且 Go 语言能保证所有值都会被初始化为零值
init() 函数和 main() 函数
- Go 语言为特定目的保留了两个函数名：
-
init() 函数（可以出现在任何的包里）
-
main() 函数（只能出现在 main 包里）
- 这两个保留函数，既不可接收任何参数，也不返回任何结果，一个包里可以有很多的
init() 函数
-
init() 和 main() 函数是自动执行的，所以我们不需要也不应该显式的调用它们
-
init() 函数是可选的，但是每一个程序必须在 main 包里包括一个 main() 函数
- Go 程序的初始化和执行总是在
main 包开始
- 如果一个包被多次导入的话，这个包实际只会被导入一次
-
main 函数执行顺序：
