转载连接:Go语言基础之函数 | 李文周的博客
1.普通函数
1
func 函数名(参数)(返回值){
函数体
}
创建函数
函数名的第一个字母要大写!!!
func Add(x, y int) int {
return x + y
}
func Sub(x, y int) int {
return x - y
}
func main(){
fmt.Println(Add(10, 20))
}
//output
30
2. 可变参数
可变参数变的是参数的数量而不是参数的类型。
func KbADD(x ...int) int {
sum := 0
for _, i := range x {
sum += i
}
return sum
}
func main(){
fmt.Println(KbADD(10,20,30))
}
//output
60
3. 对象数组
创建对象数组的参数的第一个字母都要大写!!!!,像Name,Sex,Age都需要大写!!!!!!!!!
type Person struct {
Name string
Sex string
Age int
}
func main(){
c := make([]Person, 0, 100)
c = append(c, Person{"apang", "man", 22})
c = append(c, Person{"Lcs", "nan", 23})
c = append(c, Person{"Mina", "woman", 20})
for _, x := range c {
if x.Name == "Lcs" {
fmt.Println(x)
break
}
}
}
//output
{Lcs nan 23}
4. 将函数作为参数
func AddPro(x, y int, op func(int, int) int) int {
return op(x, y)
}
func main(){
fmt.Println(AddPro(20, 20, Add))
}
//output
40
5.方法
type MyType struct {
Value int
}
func (m MyType) add(a int) int {
return m.Value + a
}
在这种情况下,add
依然是函数名,但是在函数名前面有一个参数 (m MyType)
。这个参数被称为接收器,这意味着 add
函数是 MyType
类型的一个方法。接收器可以是任何类型,不仅仅是结构体。
举例:
package main
import "fmt"
// 定义一个结构体类型
type Rect struct {
width, height int
}
// 为 Rect 类型定义一个方法 area
func (r Rect) area() int {
return r.width * r.height
}
func main() {
// 创建一个 Rect 类型的值
rect := Rect{width: 10, height: 5}
// 使用 Rect 的值调用 area 方法
fmt.Println(rect.area()) // 输出: 50
}
6. 匿名函数
匿名函数声明
func(参数)(返回值){
函数体
}
因为匿名函数没有函数名,所以匿名函数只能在某个变量或者函数中
匿名函数多用于实现回调函数和闭包.
func Nm() {
//匿名函数寄存在变量中,此时add相当于变量名,但只在Nm函数中可以调用。
add := func(x, y int) int {
return x + y
}
sum := add(20, 30)
fmt.Println(sum)
//自执行函数:匿名函数定义完加()直接执行
func(x, y int) {
fmt.Println(x + y)
}(50, 20)
}
func main(){
Nm()
}
//output
50
70
7. 闭包
闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说,闭包=函数+引用环境
闭包:
func Adder() func(int) int {
var x int
fmt.Println("x=:", x)
return func(y int) int {
fmt.Println("y=:", y)
x += y
fmt.Println("x=:",x)
return x
}
}
func main(){
f := hanshu.Adder()
fmt.Println(f(10))
fmt.Println(f(20))
fmt.Println("Next f1")
f1 := hanshu.Adder()
fmt.Println(f1(30))
fmt.Println(f1(40))
}
//output
x=: 0
y=: 10
10
y=: 20
30
Next f1
x=: 0
y=: 30
30
y=: 40
70
闭包进阶1:
func adder2(x int) func(int) int {
return func(y int) int {
x += y
return x
}
}
func main(){
f := hanshu.Adder2(10)
fmt.Println(f(5))
fmt.Println(f(3))
fmt.Println(f(2))
}
//output
15
18
20
闭包进阶2
//闭包进阶2
func MakeSuffixFunc(suffix string) func(string) string {
return func(name string) string {
//strings.HasSuffix是strings包中的函数,用于检查字符串是否以指定的后缀结尾。 其传入参数为(string,string)两个字符串,返回值为bool一个布尔类型.
//假如我传入x和y(strings.HasSuffix(x, y)),如果x的后缀为y,那么返回true;否则为false
if !strings.HasSuffix(name, suffix) {
return "照片类型-错误"
}
return "照片类型-正确"
}
}
func main(){
hz := hanshu.MakeSuffixFunc(".png")
println(hz("1.png"))
println(hz("2.png"))
println(hz("3.jpg"))
println(hz("4.png"))
println(hz("5.jpg"))
}
//output
照片类型-正确
照片类型-正确
照片类型-错误
照片类型-正确
照片类型-错误
闭包进阶3
func Calc(base int) (func(int) int, func(int) int) {
add := func(i int) int {
base += i
return base
}
sub := func(i int) int {
base -= i
return base
}
return add, sub
}
func main(){
add1, sub1 := hanshu.Calc(10)
fmt.Println(add1(5))
fmt.Println(sub1(3))
fmt.Println(add1(4))
fmt.Println(sub1(2))
}
//output
15
12
16
14