函数

函数签名（function signature）和函数类型

func (a int, b string, c string) (x int, y int, z bool)

func (a int, b, c string) (x, y int, z bool)

func (x int, y, z string) (a, b int, c bool)

func (_ int, _, _ string) (_, _ int, _ bool)

func (int, string, string) (int, int, bool) // 标准函数字面形式
func (a int, b string, c string) (int, int, bool)
func (x int, _ string, z string) (int, int, bool)
func (int, string, string) (x int, y int, z bool)
func (int, string, string) (a int, b int, _ bool)

// 这三个函数类型字面形式是等价的。
func () (x int)
func () (int)
func () int

// 这两个函数类型字面形式是等价的。
func (a int, b string) ()
func (a int, b string)

变长参数和变长参数函数类型

func (values ...int64) (sum int64)
func (sep string, tokens ...string) string

所有的函数类型都属于不可比较类型

函数原型（function prototype）

func Double(n int) (result int)

变长函数声明和变长函数调用

变长函数声明

// Sum返回所有输入实参的和。
func Sum(values ...int64) (sum int64) {
	// values的类型为[]int64。
	sum = 0
	for _, v := range values {
		sum += v
	}
	return
}

// Concat是一个低效的字符串拼接函数。
func Concat(sep string, tokens ...string) string {
	// tokens的类型为[]string。
	r := ""
	for i, t := range tokens {
		if i != 0 {
			r += sep
		}
		r += t
	}
	return r
}

func Print(a ...interface{}) (n int, err error)
func Printf(format string, a ...interface{}) (n int, err error)
func Println(a ...interface{}) (n int, err error)

变长参数函数调用

1. 传递一个切片做为实参。此切片必须可以被赋值给类型为[]T的值（或者说此切片可以被隐式转换为类型[]T）。此实参切片后必须跟随三个点...。
2. 传递零个或者多个可以被隐式转换为T的实参（或者说这些实参可以赋值给类型为T的值）。这些实参将被添加入一个匿名的在运行时刻创建的类型为[]T的切片中，然后此切片将被传递给此函数调用。

package main

import "fmt"

func Sum(values ...int64) (sum int64) {
	sum = 0
	for _, v := range values {
		sum += v
	}
	return
}

func main() {
	a0 := Sum()
	a1 := Sum(2)
	a3 := Sum(2, 3, 5)
	// 上面三行和下面三行是等价的。
	b0 := Sum([]int64{}...) // <=> Sum(nil...)
	b1 := Sum([]int64{2}...)
	b3 := Sum([]int64{2, 3, 5}...)
	fmt.Println(a0, a1, a3) // 0 2 10
	fmt.Println(b0, b1, b3) // 0 2 10
}

package main

import "fmt"

func Concat(sep string, tokens ...string) (r string) {
	for i, t := range tokens {
		if i != 0 {
			r += sep
		}
		r += t
	}
	return
}

func main() {
	tokens := []string{"Go", "C", "Rust"}
	langsA := Concat(",", tokens...)        // 风格1
	langsB := Concat(",", "Go", "C","Rust") // 风格2
	fmt.Println(langsA == langsB)           // true
}

package main

// 这两个函数的声明见前面几例。
func Sum(values ...int64) (sum int64) {......}
func Concat(sep string, tokens ...string) string {......}

func main() {
	// 下面两行报同样的错：实参数目太多了。
	_ = Sum(2, []int64{3, 5}...)
	_ = Concat(",", "Go", []string{"C", "Rust"}...)
}

更多关于函数声明和函数调用的事实

同一个包中可以同名的函数

1. 同一个包内可以声明若干个原型为func ()的名称为init的函数。
2. 多个函数的名称可以被声明为空标识符_。这样声明的函数不可被调用。

某些函数调用是在编译时刻被估值的

所有的函数调用的传参均属于值复制

不含函数体的函数声明

某些有返回值的函数可以不必返回

func fa() int {
	a:
	goto a
}

func fb() bool {
	for{}
}

自定义函数的调用返回结果可以被舍弃，但是某些内置函数的调用返回结果不可被舍弃

有返回值的函数的调用是一种表达式

1. 此调用可以在一个赋值语句中当作源值来使用，但是它不能和其它源值掺和到一块。
2. 此调用可以内嵌在另一个函数调用中当作实参来使用，但是它不能和其它实参掺和到一块。

package main

func HalfAndNegative(n int) (int, int) {
	return n/2, -n
}

func AddSub(a, b int) (int, int) {
	return a+b, a-b
}

func Dummy(values ...int) {}

func main() {
	// 这几行编译没问题。
	AddSub(HalfAndNegative(6))
	AddSub(AddSub(AddSub(7, 5)))
	AddSub(AddSub(HalfAndNegative(6)))
	Dummy(HalfAndNegative(6))
	_, _ = AddSub(7, 5)

	// 下面这几行编译不通过。
	/*
	_, _, _ = 6, AddSub(7, 5)
	Dummy(AddSub(7, 5), 9)
	Dummy(AddSub(7, 5), HalfAndNegative(6))
	*/
}

函数值

package main

import "fmt"

func Double(n int) int {
	return n + n
}

func Apply(n int, f func(int) int) int {
	return f(n) // f的类型为"func(int) int"
}

func main() {
	fmt.Printf("%T\n", Double) // func(int) int
	// Double = nil // error: Double是不可修改的

	var f func(n int) int // 默认值为nil
	f = Double
	g := Apply
	fmt.Printf("%T\n", g) // func(int, func(int) int) int

	fmt.Println(f(9))         // 18
	fmt.Println(g(6, Double)) // 12
	fmt.Println(Apply(6, f))  // 12
}

package main

import "fmt"

func main() {
	// 此函数返回一个函数类型的结果，亦即闭包（closure）。
	isMultipleOfX := func (x int) func(int) bool {
		return func(n int) bool {
			return n%x == 0
		}
	}

	var isMultipleOf3 = isMultipleOfX(3)
	var isMultipleOf5 = isMultipleOfX(5)
	fmt.Println(isMultipleOf3(6))  // true
	fmt.Println(isMultipleOf3(8))  // false
	fmt.Println(isMultipleOf5(10)) // true
	fmt.Println(isMultipleOf5(12)) // false

	isMultipleOf15 := func(n int) bool {
		return isMultipleOf3(n) && isMultipleOf5(n)
	}
	fmt.Println(isMultipleOf15(32)) // false
	fmt.Println(isMultipleOf15(60)) // true
}

遍历函数值（从Go 1.23开始）

// K和V是特定类型

func(yield func() bool)

func(yield func(V) bool)

func(yield func(K, V) bool)

package main

import "fmt"

func Loop3(yield func() bool) {
	for range 3 {
		if (!yield()) {
			return
		}
	}
}

func OneDigitNumbers(onValue func(int) bool) {
	for i := range 10 {
		if (!onValue(i)) {
			return
		}
	}
}

func SquareLessThan50(onKeyValue func(int, int) bool) {
	for i := range 8 {
		if (!onKeyValue(i, i*i)) {
			return
		}
	}
}

func main() {
	var n = 0
	for range Loop3 {
		fmt.Print(n)
		n++
	}
	fmt.Println()
	// 输出：012
	
	for i := range OneDigitNumbers {
		fmt.Print(i)
	}
	fmt.Println()
	// 输出：0123456789
	
	for i, ii := range SquareLessThan50 {
		fmt.Printf("%v:%v ", i, ii)
	}
	fmt.Println()
	// 输出：0:0 1:1 2:4 3:9 4:16 5:25 6:36 7:49 
}

func main() {
	var n = 0
	Loop3(func() bool {
		fmt.Print(n)
		n++
		return true
	})
	fmt.Println()
	
	OneDigitNumbers(func(i int) bool {
		fmt.Print(i)
		return true
	})
	fmt.Println()
	
	SquareLessThan50(func(i, ii int) bool {
		fmt.Printf("%v:%v ", i, ii)
		return true
	})
	fmt.Println()
}

---

---

---

目录：