一、函数
函数声明
// 声明语法：Go 中函数传递的参数都是值传递(将形参的值拷贝一份给函数内部使用, 形参与实参是相互独立互不影响的)，其包括普通函数、lambda函数(匿名函数)、方法
func 函数名(参数) 返回值 {
函数体
} // eg: 斐波那契数列(递归)
func fibonacci(n int) int {
if n < {
return n
} else {
return fibonacci(n-) + fibonacci(n-)
}
}
函数返回值
// 一个返回值的函数
func max(num1 int, num2 int) int {
if num1 > num2 {
return num1
} else {
return num2
}
} // 多个返回值的函数
func allValue(num int, name string) (int, string) {
fmt.Println("In allValue function num: ", num)
fmt.Println("In allValue function name: " + name)
return num, name
} func main() {
num1 :=
num2 :=
result := max(num1, num2)
fmt.Println("result: ", result) num, name := allValue(num2, "power")
fmt.Println("In main function num: ", num)
fmt.Println("In main function name: ", name) }
函数参数
- 值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
func valueFunc(num1 int, num2 int) {
num1, num2 = num2, num1
}
// 当参数中多个参数类型一致时, 可简写参数的类型
func f1(x, y int, m, n string, i, j bool) int {
return x + y
}
func main() {
fmt.Println("值传递交换前 num1 的值： ", num1)
fmt.Println("值传递交换前 num2 的值： ", num2)
valueFunc(num1, num2)
fmt.Println("值传递交换后 num1 的值： ", num1)
fmt.Println("值传递交换后 num2 的值： ", num2)
}
// [Output]：值传递交换前 num1 的值： 20
// [Output]：值传递交换前 num2 的值： 10
// [Output]：值传递交换后 num1 的值： 20
// [Output]：值传递交换后 num2 的值： 10
- 引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
func pointFunc(prt1 *int, prt2 *int) {
*prt1, *prt2 = *prt2, *prt1
}
func main(){
num1, num2 := ,
var prt1 *int = &num1
var prt2 *int = &num2
fmt.Println("交换前 num1 的值： ", num1)
fmt.Println("交换前 num2 的值： ", num2)
pointFunc(prt1, prt2) // 指针作为函数参数，传递的是参数的地址
fmt.Println("交换后 num1 的值： ", num1)
fmt.Println("交换后 num2 的值： ", num2)
}
// [Output]: 交换前 num1 的值： 10
// [Output]: 交换前 num2 的值： 20
// [Output]: 交换后 num1 的值： 20
// [Output]: 交换后 num2 的值： 10
- 默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
可变参数：必须放在函数参数的最后, Go 语言中没有默认参数概念
// 接收相同类型的可变参数的函数
func argsSameFunc(args ... string) {
fmt.Print("same type elem: ")
for _, param := range args {
fmt.Print(param, ", ")
}
fmt.Println()
} // 接受不同类型的可变参数的函数
func argsDifferenceFunc(args ... interface{}) {
fmt.Print("difference type elem: ")
for _, param := range args {
fmt.Print(param, ",")
}
fmt.Print("\n")
} // 接收可变数量的参数, 类型约束为字符串
func joinStrings(slist ...string) string {
// 定义一个字节缓冲, 快速地连接字符串
var b bytes.Buffer
// 遍历可变参数列表slist, 类型为[]string
for _, s := range slist {
// 将遍历出的字符串连续写入字节数组
b.WriteString(s)
}
// 将连接好的字节数组转换为字符串并输出
return b.String()
} func main() { // 接受相同类型的可变参数函数
argsSameFunc("power")
argsSameFunc("forever", "topOne")
argsSameFunc("selina", "hebe", "ella") // 接受不同类型的可变参数函数
argsDifferenceFunc("power", )
argsDifferenceFunc("selina", , "hebe", , "ella", ) fmt.Println(joinStrings("Asia ", "sky", " crops：", "S.H.E"))
fmt.Println(joinStrings("They ", "gave ", "me ", "the ", "courage "))
fmt.Print(reflect.TypeOf(num1)) // 可获取变量的类型
}
函数作为参数、返回值
// 函数作为参数传递
func calc(x, y int, op func(int, int) int) int { // 接收两个int类型的参数, 和 一个拥有 2个int类型参数、1个int类型返回值的函数类型 参数
return op(x, y)
}
// 函数作为返回值
func do(s string) (func(int, int) int, error) {
switch s {
case "+":
return add, nil
case "-":
return sub, nil
default:
err := errors.New("无法识别的操作符")
return nil, err
} }
func add(x, y int) int {
return x + y
}
func sub(x, y int) int {
return x - y
}
全局、局部变量
、全局变量：定义在函数外部的变量, 在程序的整个运行周期内都有效, 在函数中可访问到全局变量。
、局部变量: 分为两种, 第一种 函数内定义的变量无法在该函数外使用; 如果局部变量和全局变量重名，优先访问局部变量
、局部变量: 第二种 语句块内定义的变量只能在语句块中生效(if、for、switch)
闭包
// 闭包: 闭包是一个函数 它包含这个函数 和 它外部作用域的变量(与其相关的引用环境) 组合而成的实体, 闭包=函数+引用环境； 底层原理: 函数可作为返回值; 函数内部查找变量的顺序, 先在函数内部找, 再往函数外部找 // 无参闭包
func adder() func(int) int { // 返回值的函数声明 与 return后的匿名函数 是一样的
var x int
return func(y int) int {
x += y
return x
}
} // 带参闭包
func adder2(x int) func(int) int {
return func(y int) int {
x += y
return x
}
} // 参数为函数引用的闭包
func ft(x, y int) {
fmt.Println("\nThis is ft function.")
fmt.Printf("ft(x - %v, y - %v)", x, y)
} func adders(f func(int, int), x, y int) func() {
tmp := func() {
f(x, y)
}
return tmp
} func main() { // 1、无参闭包
var f = adder() // 此时接收到的是 adder 函数返回的 匿名函数的引用
fmt.Println("closesure f(10) result: ", f()) // 此前并未给闭包内的x赋值, 所以x声明后为默认的零值, 此行代码运行过后, x已被赋值, x=0, y=10, x+=y, x=10
fmt.Println("closesure f(20) result: ", f()) // 在程序并未结束前, 前一句代码给闭包内的x所赋予的值都有效, 所以此行结果为: x=10, y=20, x+=y, x=30
var f1 = adder() // 重新赋值, 从头再来
fmt.Println("closesure f1(30) result: ", f1()) // x=0, y=30, x+=y, x=30
fmt.Println("closesure f1(50) result: ", f1()) // x=30, y=50, x+=y, x=80
fmt.Println() // 2、带参闭包
var fp = adder2() // x=10
fmt.Println("closesure fp(10) result: ", fp()) // x=10, y=10, x+=y, x=20
fmt.Println("closesure fp(30) result: ", fp()) // x=20, y=30, x+=y, x=50
var fp1 = adder2()
fmt.Println("closesure fp1(50) result: ", fp1()) // x=20, y=50, x+=y, x=70
fmt.Println("closesure fp1(20) result: ", fp1()) // x=70, y=20, x+=y, x=90 // 3、参数为函数引用的闭包
var ft1 = adders(ft, , )
ft1()
}
匿名函数
// 匿名函数: 没有函数名的函数, 它无法像普通函数那样调用, 需要将匿名函数保存到某个变量, 或作为立即执行的函数 [匿名函数多用于回调函数和闭包]
// 定义语法
func(参数列表)(返回参数列表){
// 函数体
} // 匿名函数 -- 作为执行函数(只执行一次), 函数定义完之后 加上() 将会立即执行 func(a, b int) {
fmt.Println("self excuting function a*b result: ", a*b)
}(, ) // 匿名函数 -- 作为回调函数
func visit(list []int, f func(int)) {
for _, elem := range list {
f(elem)
}
} func main() {
// 匿名函数
// 声明时调用
func(name string) {
fmt.Println("Hello ", name)
} ("power") // ---> 括号内是匿名函数执行传递的参数 // 将匿名函数赋值给变量，通过 变量() 调用
innominateFunc := func(name string) string {
fmt.Println("Hello ", name)
receiving := "Hello" + name
return receiving
}
innominateFunc("hebe") // 匿名函数作为回调函数 打印切片中的所有元素
visit([]int {, , }, func(v int) { // params: 切片，匿名函数(注意，此处的匿名函数在 visit函数的参数括号内，是作为参数传递给 visit 的)
fmt.Println(v)
})
}
方法
// 结构体
type Circle struct {
radius float64
} // 方法
func (circle Circle) method(msg string) float64 {
fmt.Println("The radius of the circle is: ", circle.radius)
return 3.14 * circle.radius * circle.radius
} func main() {
var circle Circle
circle.radius = 10.00
area := circle.method("This is a way of finding the area of a circle")
fmt.Println("The area of the circle is： ", area) fmt.Print("\n")
?
二、指针
package main
import "fmt"
const count int =
func pointFunc(prt1 *int, prt2 *int) {
*prt1, *prt2 = *prt2, *prt1
}
func main() {
// 指针声明
var ip *int
var fp *float32
var ipNum int
var fpFloat float32
ipNum =
fpFloat = 3.13
// 指针赋值
ip = &ipNum
fp = &fpFloat
fmt.Println("ip: ", ip)
fmt.Println("fp: ", fp)
// 空指针
var prt *string
fmt.Println("prt: ", prt)
if (prt != nil){
fmt.Println("prt isn't empty pointer.")
} else {
fmt.Println("prt is empty pointer.")
}
fmt.Print("\n")
// 指针数组
var array = [] int{, , , , }
var ptr [count]*int
zero :=
for t:=; t<count; t++ {
ptr[t] = &array[t]
}
for r:=; r<count; r++ {
// 打印数组内元素内存地址赋值给指针数据后的所有内存地址
fmt.Print(array[r], "\t")
fmt.Print(*ptr[r], "\t")
fmt.Print(ptr[r], "\t")
// 修改指针数组内所有元素的内存地址
ptr[r] = &zero
fmt.Print(ptr[r], "\t")
fmt.Println(*ptr[r])
}
fmt.Print("\n")
// 指向指针的指针变量
var a =
var aptr1 *int
var aptr2 **int
aptr1 = &a
aptr2 = &aptr1
fmt.Println("a value: ", a)
fmt.Println("a memory address: ", &a)
fmt.Println("aptr1 value: ", aptr1)
fmt.Println("*aptr1 value: ", *aptr1)
fmt.Println("&aptr1 memory address: ", &aptr1)
fmt.Println("aptr2 value: ", aptr2)
fmt.Println("*aptr2 value: ", *aptr2)
fmt.Println("**aptr2 value: ", **aptr2)
fmt.Println("&aptr2 memory address: ", &aptr2)
fmt.Print("\n")
// 指针作为函数的参数
num1, num2 := ,
var prt1 *int = &num1
var prt2 *int = &num2
fmt.Println("指针传递交换前 num1 的值： ", num1)
fmt.Println("指针传递交换前 num2 的值： ", num2)
pointFunc(prt1, prt2)
fmt.Println("指针传递交换后 num1 的值： ", num1)
fmt.Println("指针传递交换后 num2 的值： ", num2)
}
三、结构体
// 声明语法
type 结构体名称 struct {
字段名1 字段1类型
字段名2 字段2类型
字段名3 字段3类型
...
} // 示例1：每行声明一个字段
type Member struct {
name string
age int
weight float64
height float32
} // 示例2：同类型字段声明在同一行
type Test struct {
one, two, three int
four string
five float32
six float64
seven bool
} // 第一种方式实例化结构体
var members Member
members.name = "power"
members.age =
members.weight = // 第二种方式实例化结构体
member := Member{"top", , , 1.65}
member := Member{"name": "top", "age": , "weight": , "height": 1.65} // 打印结构体的每个字段值
func printMemberPoint(memberPoint *Member) {
fmt.Println("memberPoint: ", memberPoint)
fmt.Println("memberPoint.name: ", memberPoint.name)
fmt.Println("memberPoint.age: ", memberPoint.age)
fmt.Println("memberPoint.weight: ", memberPoint.weight)
fmt.Println("memberPoint.height: ", memberPoint.height)
fmt.Print("\n")
}
// 第一种方式实例化指针类型的结构体：new
pointMember := new(Member)
memberPoint.name = "power"
memberPoint.age =
memberPoint.weight =
memberPoint.height = 1.73
printMemberPoint(memberPoint) // 第二种方式实例化指针类型的结构体：取址 &
memberPoint := &Member{}
memberPoint.name = "top"
memberPoint.age =
memberPoint.weight =
memberPoint.height = 1.68
printMemberPoint(memberPoint)
var memberPoint *Member
memberPoint = &members
printMemberPoint(memberPoint) // 匿名结构体
stone := struct {
nickname string
skill string
}{"small stone", "fly"}
fmt.Println("stone.nickname：", stone.nickname)
fmt.Println("stone.skill：", stone.skill)
// 结构体的方法
func (structObject *structName) method(param paramType...) (returnType...) {
// do something }
returnValue := member.method(param)