Golang函数
这篇文章涵盖了Go语言中与函数有关的以下内容
- 为什么需要函数？
- 函数的声明
- 多个返回值
- 命名的返回值
- 延迟
- 关闭
- 匿名函数
- 指定为值的函数
- 向函数传递参数
- 将函数切成数组
为什么需要函数？
函数是为实现特定功能而编写的程序或多行代码。在Go语言中，每个功能都被定义为一个函数。
golang中每个可运行的代码都有main()函数。k函数可以在不同的位置被其他代码调用。使用函数的好处是可以重复代码和维护代码。
golang中函数的几个关键点：
- 函数是为实现某些任务而设计的代码语句
- 它接受输入，执行代码并返回输出。
- 当函数被一些其他代码调用时，函数就会被执行
- 函数也被称为子程序、方法、程序
定义函数的语法
func functionname([argument1 datatype,argument2 datatype])[returnvaluename returntype]{
code block statement(s)
}
在任何编程语言中设计函数，都需要以下东西
- 函数标题
- 函数主体
- 函数调用者
函数声明包含头和主体。
关于函数语法的一些说明：
- func关键字- func是golang的一个关键字。每个函数声明总是以这个关键字开始。
- functionname- 这是一个函数名，它被调用者用于在其他地方的代码库中执行。
- argument1- 这些也被称为参数，将用（和）括起来。参数声明的语法是在参数名称后面加上数据类型。多个参数也可以用逗号分开声明。这些是可选的，即空参数也有效。
- 返回类型- 函数返回多个值。返回类型的声明包含名称和类型。类型是可选的。可以声明任何数量的返回类型。它是一个可选的类型。
- 函数主体--它是为实现某些任务而编写的实际代码，它被放在{和}之间
- 函数调用者- 一旦函数被声明，我们需要通过调用它来执行一个函数。一旦函数被调用，控制权就会转移到函数主体，执行它并返回值，一旦完成，控制权就会转移到调用者的代码中。
Golang函数实例
在下面的章节中，我们将通过各种例子来了解函数的各种特性。
使用空函数声明
下面是一个空函数，它没有输入参数，也不返回任何东西。这也是一个有效的函数。
func printmessage() {
fmt.Println("Hello world")
}
有输入和输出的基本函数 下面是一个函数的例子 下面的函数有两个输入参数 - 数据类型为int的value1和value2。返回类型也是int，返回这两个数字的总和。
package main
import "fmt"
func sum(value1 int, value2 int) int {
return value1 + value2
}
func main() {
fmt.Println(sum(1, 2))
}
我们已经声明了一个函数。现在我们必须调用该函数。通过给出函数参数，用函数名称调用该函数。语法是sum(1, 2)，上述程序的输出是
3
同一类型的多个参数
当有多个同一类型的参数并列声明时，我们可以通过简单的语法多次声明类型来避免，如下所示
func sum(value1, value2 int) int {
return value1 + value2
}
从一个函数中返回多个值
在其他编程语言中，如Java和javascript总是返回一个单一的值。而Golang中的函数则返回多个值。用两个相同类型的参数声明IncrementAndDecrement函数，第一个参数增加1，第二个参数减少1，最后都返回数值。
func IncrementAndDecrement(value1, value2 int) (int, int) {
var incrValue = value1 + 1
var decrValue = value2 - 1
return incrValue, decrValue
}
func main() {
value1, value2 := IncrementAndDecrement(5, 5)
fmt.Printf("%d %d", value1, value2)
}
上述程序代码的输出是
6 4
请看下面的代码，其中返回类型没有用( 和 ) 声明。它给出的编译错误是缺少函数体，顶层声明后有意外的逗号，函数体外有非声明语句。
func IncrementAndDecrement(value1, value2 int) int, int {
var incrValue = value1 + 1
var decrValue = value2 - 1
return incrValue, decrValue
}
func main() {
value1, value2 := IncrementAndDecrement(5, 5)
fmt.Printf("%d %d", value1, value2)
}
完整的错误报告是
A:\Golang\work>go run First.go
# command-line-arguments
.\First.go:5:6: missing function body
.\First.go:5:51: syntax error: unexpected comma after top level declaration
.\First.go:8:2: syntax error: non-declaration statement outside function body
空白标识符 - 子集返回值
我们已经在golang中看到了对多个返回值的支持。函数返回了两个值，调用者必须只得到数据的一个子集，即一个值应该从函数返回。那么我们将使用空白标识符来实现这一点。_被称为空白标识符。在此基础上，任何类型的值都可以接受，并且不从函数中返回。 IncrementAndDecrement函数返回两个值，但是调用者只需要一个值，另一个值的位置应该用空白标识符（_）代替。
package main
import "fmt"
func IncrementAndDecrement(value1, value2 int) (int, int) {
var incrValue = value1 + 1
var decrValue = value2 - 1
return incrValue, decrValue
}
func main() {
_, value2 := IncrementAndDecrement(5, 5)
fmt.Printf("%d", value2)
}
输出是
4
函数的命名返回值
在以上所有的例子中，我们只是在函数声明中提供了返回类型。我们也可以提供返回的名称和类型 在下面的函数声明中，返回的语句包含了名称和类型，并且都用（和）括起来。
func Increment(value1 int) (v1 int) {
v1 = value1 + 1
return v1
}
func main() {
value1 := Increment(5)
fmt.Printf("%d", value1)
}
在上述代码中，多值返回的情况是有效的。不需要手动返回值。在声明中命名的返回值(v1)即(v1 int)和正文即.v1 = value1 + 1在这种情况下应该有相同的名字。
func Increment(value1 int) (v1 int) {
v1 = value1 + 1
return // not required to have return value
}
这也是有效的，因为命名的值v1与v2不同，但返回语句必须与新变量一起声明。
func Increment(value1 int) (v1 int) {
var v2 = value1 + 1
return v2
}
下面的代码是无效的，因为头中的返回语句缺少（和），它给出了编译错误--缺少函数体的语法错误：顶级声明后出现意外的int
func Increment(value1 int) v1 int {
v1 = value1 + 1
return v1
}
变量函数--变量参数
这是golang中函数的另一个特点。函数可以用变数参数进行声明。Println是一个内置的函数，它接受可变的参数数。这个函数声明的语法
func functionname (arguments ...datatype)
这些函数在参数中用椭圆（三个点）声明。这应该被声明为最后一个参数。
package main
import "fmt"
func IncrementAndDecrement(nums ...int) int {
result := 0
for i := range nums {
result += nums[i]
}
return result
}
func main() {
res := IncrementAndDecrement(5, 5)
fmt.Printf("%d", res)
res1 := IncrementAndDecrement(5, 1, 7)
fmt.Printf(" %d", res1)
}
下面的代码给出了编译错误--只能使用......与列表中的最后参数numbs参数不是函数声明的最后参数或最后参数。
func IncrementAndDecrement(nums ...int, string s) int {
result := 0
for i := range nums {
result += nums[i]
}
return result
}
闭包或匿名函数
Golanguage 支持没有名字的函数声明。这些函数在java和javascript等其他编程语言中被称为匿名函数。 closure是匿名函数的一种，它可以访问定义在外层函数本身的变量。我们将看到这两个特征的各种例子 函数可以作为值并分配给变量 这里没有声明的函数被分配给变量，这是在其他地方使用变量名用（和）调用的。
var functionName = func() string { // this assigns anonymous function to variable
return "testvalue"
}
func main() {
fmt.Printf("%s", functionName())
}
带有内联参数的匿名函数
上面的函数可以用另一种方式编写，即用( 和 ) 添加内联参数值
func main() {
//Anonymous functin assined to variable by appending argument value inline
var functionName = func(s string) string {
return "testvalue " + s
}("cloudhadoop")
fmt.Printf("%s", functionName)
}
输出为
testvalue cloudhadoop
将函数作为参数传递
函数也可以作为参数传递给其他函数，在下面的例子中，Function2被声明为具有函数参数，这个函数2被调用时提供了参数
func funciton1(value int) int {
return value * value
}
func funciton2(functionargument func(int) int) int {
return functionargument(5)
}
func main() {
fmt.Printf("%d", funciton2(funciton1))
}
输出是
25
作为其他函数的返回类型
函数声明包含返回类型的匿名函数声明 function1被声明为具有返回类型的匿名函数，具有参数和返回类型的函数调用者应该将两个参数分别用( 和 )括起来，在这里闭合应用为访问内部匿名函数内部的value1变量
func function1(value1 int) func(int) int {
var result = func(value2 int) int { return value1 + value2 }
return result
}
func main() {
fmt.Printf("%d", function1(4)(5))
}
输出是
9
带有嵌套函数的闭包
一个在其他函数内部声明的函数，外部函数的变量被访问到内部函数中，嵌套函数被声明在主函数中。 fmt类被声明在主函数中，被访问到嵌套函数中 value2被声明在主函数中，被访问到嵌套函数中
func main() {
var value2 = 12
var nestedFunction = func(value int) int {
fmt.Println(value)
return value + value2
}
fmt.Println(nestedFunction(6))
}
而输出是
6
18
defer 语句
defer是一个关键字，在语言中作为一个语句使用。defer被用在函数中，在函数返回其值之前执行。defer逻辑总是在声明的函数返回其值之前执行。defer关键字在一个外层函数声明之前声明
package main
import "fmt"
func myfunction() (value int) {
defer func() {
value = 25
}()
return value
}
func main() {
fmt.Println(myfunction())
}
输出是
25
数组作为参数的片断
函数可以用一个数组作为参数来传递，而不是在函数声明中声明一个数组，我们可以将数组切片。 函数声明使用椭圆符号接受变量参数，函数调用者接受切片数组，如myfunction(array1...)
func myfunction(params ...int) int {
result := 0
for _, value := range params {
result += value
}
return result
}
func main() {
var array1 = []int{1, 2, 7}
fmt.Println(myfunction(array1...))
}
而输出是
10
结论
像每一种编程语言一样，函数是构件，在go语言中最有用。在这门语言中，有很多函数支持的功能。
请分享您的宝贵意见或反馈，并分享给社交媒体。
