[Golang]-3 函数、多返回值、变参、闭包、递归

// test01 project main.go

package main

import (

	"fmt"

)

// 单返回值的函数

func plus(a int, b int) int {

	// Go 需要明确的返回值

	return a + b

}

// (int, int) 在这个函数中标志着这个函数返回 2 个 int。

func vals() (int, int) {

	return 3, 7

}

// 可变参数函数。可以用任意数量的参数调用。例如，fmt.Println 是一个常见的变参函数。

// 这个函数使用任意数目的 int 作为参数。

func sum(nums ...int) {

	fmt.Print(nums, " ")

	total := 0

	for _, num := range nums {

		total += num

	}

	fmt.Println(total)

}

// Go 支持通过 闭包来使用 匿名函数。匿名函数在你想定义一个不需要命名的内联函数时是很实用的

// 这个 intSeq 函数返回另一个在 intSeq 函数体内定义的匿名函数。这个返回的函数使用闭包的方式 隐藏 变量 i。

func intSeq() func() int {

	i := 0

	return func() int {

		i += 1

		return i

	}

}

// 递归

func fact(n int) int {

	if n == 0 {

		return 1

	}

	return n * fact(n-1)

}

func main() {

	res := plus(1, 2)

	fmt.Println("1+2 =", res)

	// 通过多赋值 操作来使用这两个不同的返回值

	a, b := vals()

	fmt.Println(a)

	fmt.Println(b)

	// 如果你仅仅想返回值的一部分的话，你可以使用空白定义符 _

	_, c := vals()

	fmt.Println(c)

	// 变参调用

	sum(1, 2)

	sum(1, 2, 3)

	// 如果你的 slice 已经有了多个值，想把它们作为变参使用，你要这样调用 func(slice...)

	nums := []int{1, 2, 3, 4}

	sum(nums...)

        // 闭包

	// 我们调用 intSeq 函数，将返回值（也是一个函数）赋给nextInt。这个函数的值包含了自己的值 i，这样在每次调用 nextInt 时都会更新 i 的值。

	nextInt := intSeq()

	// 通过多次调用 nextInt 来看看闭包的效果。

	fmt.Println(nextInt())

	fmt.Println(nextInt())

	fmt.Println(nextInt())

	// 为了确认这个状态对于这个特定的函数是唯一的，我们重新创建并测试一下。

	newInts := intSeq()

	fmt.Println(newInts())

	fmt.Println(newInts())

	// 递归函数调用

	fmt.Println(fact(0))

	fmt.Println(fact(1))

	fmt.Println(fact(2))

	fmt.Println(fact(3))

	fmt.Println(fact(4))

	fmt.Println(fact(5))

	fmt.Println(fact(6))

	fmt.Println(fact(7))

}

输出

// 普通函数

1+2 = 3

// 多返回值

3

7

7

// 可变参数函数

[1 2] 3

[1 2 3] 6

[1 2 3 4] 10

// 闭包

1

2

3

1

2

// 递归

1

1

2

6

24

120

720

5040

备注：

闭包：是能够读取其他函数内部变量的函数；
匿名函数：一个没有指定名称的函数。匿名函数的参数规则、作用域关系与有名函数是一样的；匿名函数的函数体通常应该是一个表达式,该表达式必须要有一个返回值。

巴特西

[Golang]-3 函数、多返回值、变参、闭包、递归

最新文章

热门文章