概念简介
特点：
-
函数是基本的代码块，用于执行一个任务。
-
Go 语言最少有个 main() 函数。
-
可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
函数声明格式
-
函数的名称，返回类型，参数。(和Java是有区别的，Go当中的返回值在最后声明，方法名后的'()'放参数列表)
函数的定义
func function_name( [parameter list] ) [return_types] {
函数体
}
函数定义解析：
-
parameter list--->形参和实参。
-
参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
-
-
return_types--->返回类型，函数返回一列值。
-
该列值的数据类型。
-
有些函数无返回值
-
有些函数有多个返回值
-
-
示例：
package main
func max(num1, num2 int) int {
var result int
if num1-num2 > 0 {
result = num1
return result
}else {
result = num2
return result
}
}
函数的调用
调用函数，向函数传递参数，并返回值
示例：
package main
import "fmt"
func max(num1, num2 int) int {
var result int
if num1-num2 > 0 {
result = num1
return result
}else {
result = num2
return result
}
}
func main() {
var valueNum1 int
var valueNum2 int
var resultValu1 int
//键盘输入
fmt.Println("Input first value:")
fmt.Scanln(&valueNum1)
fmt.Println("Input Second value:")
fmt.Scanln(&valueNum2)
resultValu1 = max(valueNum1, valueNum2)
fmt.Println("The max value is :", resultValu1)
}
函数返回值
无返回值
返回一个值
返回多个值
多个同类型的值
多个不同类型的值
函数无返回值
package main
import "fmt"
func noReturn(arr int) {
fmt.Println("Value is :", arr)
}
func main() {
var input int
fmt.Println("Input value :")
fmt.Scanln(&input)
noReturn(input)
}
一个返回值
package main
import "fmt"
func returnValue(arr int) int {
fmt.Println("Return Value is :", arr)
return arr
}
func main() {
var input int
fmt.Println("Input Value is :")
fmt.Scanln(&input)
returnValue(input)
}
多个返回值
package main
import "fmt"
func returnMoreValue(arr, brr string) (string, bool) {
var valueNo1 = arr
var valueNo2 = brr
return valueNo1,(valueNo1==valueNo2)
}
func main() {
var arr string
var brr string
fmt.Println("Input string first value :")
fmt.Scanln(&arr)
fmt.Println("Input string second value :")
fmt.Scanln(&brr)
fmt.Println(returnMoreValue(arr,brr))
}
函数参数
值传递
引用传递
| 传递类型 | 描述 |
|---|---|
[值传递] |
值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。 |
[引用传递] |
引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。 |
值传递
Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
示例：
package main
import "fmt"
/*定义一个函数，实现传入两个整数，交换他们的值*/
func changeValue(arr, brr int) int {
if arr == brr {
return arr
}else {
//使用冒泡排序算法的方法让两个变量的值进行交换
temp := arr
arr = brr
brr = temp
}
return brr
}
func main() {
var valuePracticeNo1 int
var valuePracticeNo2 int
//获取输入值
fmt.Println("First Value is :")
fmt.Scanln(&valuePracticeNo1)
fmt.Println("Second Value is :")
fmt.Scanln(&valuePracticeNo2)
fmt.Println("Before change value :", valuePracticeNo1, valuePracticeNo2)
//调用方法
fmt.Println("After change ValuePracticeNo2 value is :", changeValue(valuePracticeNo1,valuePracticeNo2))
}
引用传递
在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。--->引用传递指针参数传递到函数内
示例：--->形参是指针变量
//设置两个变量，指定变量的值。通过交换指针的指向达到改变两个变量的值
package main
import "fmt"
/*写一个函数，交换传入的指针变量的值*/
func changePointerValue(arr *int, brr *int) {
//指针之间进行值的交换。
//使用中间变量的方法存储值
temp := *arr
*arr = *brr
*brr = temp
}
func main() {
//设置两个变量，指定变量的值。通过交换指针的指向达到改变两个变量的值
a := 200
b := 100
fmt.Printf("指针交换前a的值:\n", a)
fmt.Println("\n")
fmt.Printf("指针交换前b的值:\n", b)
/* 调用 swap() 函数
* &a 指向 a 指针，a 变量的地址
* &b 指向 b 指针，b 变量的地址
*/
changePointerValue(&a, &b)
fmt.Println("\n")
fmt.Println("指针交换后a的值:", a)
fmt.Println("指针交换后b的值:", b)
}
函数用法
| 函数用法 | 描述 |
|---|---|
[函数作为另外一个函数的实参] |
函数定义后可作为另外一个函数的实参数传入 |
[闭包] |
闭包是匿名函数，可在动态编程中使用 |
[方法] |
方法就是一个包含了接受者的函数 |
函数作为另一个函数的实参
Go 语言可以很灵活的创建函数，并作为另外一个函数的实参。
概括：
-
创建一个函数变量，变量指向函数体
-
函数体可以直接作为赋值号右边的内容直接书写
package main
import (
"fmt"
"math"
)
func main() {
/*声明函数变量*/
getSquareRoot := func(num float64) float64 {
return math.Sqrt(num)
}
/*使用函数*/
fmt.Println(getSquareRoot(8))
}
闭包
特点：
-
Go 语言支持匿名函数，可作为闭包。
-
匿名函数是一个"内联"语句或表达式。可以直接使用函数内的变量，不必申明。
示例：
创建了函数 getSequence() ，返回另外一个函数。函数在闭包中递增 i 变量
//声明格式是在形参列表 + 函数名 + 返回值
package main
import "fmt"
func getSequence() func() int {
i := 0
//返回值书写内置函数
return func() int {
i += 1
return i
}
/*
内部返回值是int类型
返回后外部返回值认为函数相当于一个int类型的引用变量
*/
}
func main() {
/*设置函数变量*/
nextNumber := getSequence()
/*调用nextNumber函数*/
fmt.Println(nextNumber())
fmt.Println(nextNumber())
fmt.Println(nextNumber())
}
方法
-
Go语言中，一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。
-
所有给定类型的方法属于该类型的方法集。
声明格式：
func (variable_name variable_data_type) function_name() [return_type]{
/* 函数体*/
}
理解：
-
结构体相当于一个类，类中定义私有的属性(变量)
-
可以声明一个对应结构体的变量来访问结构体里面的属性
-
可以声明函数属于的结构体，这样可以访问结构体当中的属性
package main
import "fmt"
/*定义一个结构体,里面存储私有属性*/
type Circle struct {
radius float64
}
//定义一个方法--->该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
return 3.14*c.radius*c.radius
}
func main() {
/*声明一个结构体类型的变量，访问结构体的属性*/
var c1 Circle
c1.radius = 10.00
/*因为getArea方法属于结构体，所以只能使用结构体变量去调用它*/
fmt.Println("面积为:", c1.getArea())
}
