Go 언어는 일반 함수, 익명 함수 및 클로저를 지원하며, 기능을 더욱 편리하게 사용할 수 있도록 디자인부터 최적화 및 개선되었습니다. Go 언어에서는 func 키워드를 사용하여 함수를 정의하며 구문은 "func 함수명(매개변수)(반환값){함수 본문}"입니다. 함수를 정의한 후 "함수명"을 통해 함수를 호출할 수 있습니다. ()".
이 튜토리얼의 운영 환경: Windows 7 시스템, GO 버전 1.18, Dell G3 컴퓨터.
Function은 단일 또는 관련 기능을 구현하는 데 사용되는 체계적이고 재사용 가능한 코드 세그먼트로, 애플리케이션의 모듈성과 코드 재사용률을 향상시킬 수 있습니다.
Go 언어는 일반 함수, 익명 함수 및 클로저를 지원하며, 기능을 더욱 편리하게 사용할 수 있도록 디자인부터 최적화 및 개선되었습니다.
Go 언어 함수는 "일류 시민"입니다. 즉,
함수 자체는 값으로 전달될 수 있습니다.
익명 함수 및 클로저를 지원합니다.
기능은 인터페이스를 만족시킬 수 있습니다.
func
키워드는 Go 언어에서 함수를 정의하는 데 사용됩니다. 구체적인 형식은 다음과 같습니다. func
关键字,具体格式如下:
func 函数名(参数)(返回值){ 函数体 }
其中:
,
分隔。()
包裹,并用,
分隔。我们先来定义一个求两个数之和的函数:
func intSum(x int, y int) int { return x + y }
函数的参数和返回值都是可选的,例如我们可以实现一个既不需要参数也没有返回值的函数:
func sayHello() { fmt.Println("Hello 沙河") }
定义了函数之后,我们可以通过函数名()
的方式调用函数。 例如我们调用上面定义的两个函数,代码如下:
func main() { sayHello() ret := intSum(10, 20) fmt.Println(ret) }
注意,调用有返回值的函数时,可以不接收其返回值。
函数的参数中如果相邻变量的类型相同,则可以省略类型,例如:
func intSum(x, y int) int { return x + y }
上面的代码中,intSum
函数有两个参数,这两个参数的类型均为int
,因此可以省略x
的类型,因为y
后面有类型说明,x
参数也是该类型。
可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加...
来标识。
注意:可变参数通常要作为函数的最后一个参数。
举个例子:
func intSum2(x ...int) int { fmt.Println(x) //x是一个切片 sum := 0 for _, v := range x { sum = sum + v } return sum }
调用上面的函数:
ret1 := intSum2() ret2 := intSum2(10) ret3 := intSum2(10, 20) ret4 := intSum2(10, 20, 30) fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60
固定参数搭配可变参数使用时,可变参数要放在固定参数的后面,示例代码如下:
func intSum3(x int, y ...int) int { fmt.Println(x, y) sum := x for _, v := range y { sum = sum + v } return sum }
调用上述函数:
ret5 := intSum3(100) ret6 := intSum3(100, 10) ret7 := intSum3(100, 10, 20) ret8 := intSum3(100, 10, 20, 30) fmt.Println(ret5, ret6, ret7, ret8) //100 110 130 160
本质上,函数的可变参数是通过切片来实现的。
Go语言中通过return
关键字向外输出返回值。
Go语言中函数支持多返回值,函数如果有多个返回值时必须用()
将所有返回值包裹起来。
举个例子:
func calc(x, y int) (int, int) { sum := x + y sub := x - y return sum, sub }
函数定义时可以给返回值命名,并在函数体中直接使用这些变量,最后通过return
func calc(x, y int) (sum, sub int) { sum = x + y sub = x - y return }
여기서:
,
로 구분됩니다. 반환값: 반환값은 반환값 변수와 해당 변수 유형으로 구성됩니다. 또한 반환값의 유형을 ()
로 묶어야 합니다. 와 함께 사용되며,
구분됩니다.
func someFunc(x string) []int { if x == "" { return nil // 没必要返回[]int{} } ... }
package main import "fmt" //定义全局变量num var num int64 = 10 func testGlobalVar() { fmt.Printf("num=%d\n", num) //函数中可以访问全局变量num } func main() { testGlobalVar() //num=10 }
함수명()
을 통해 함수를 호출할 수 있습니다. 예를 들어 위에서 정의한 두 함수를 호출할 때 코드는 다음과 같습니다. func testLocalVar() { //定义一个函数局部变量x,仅在该函数内生效 var x int64 = 100 fmt.Printf("x=%d\n", x) } func main() { testLocalVar() fmt.Println(x) // 此时无法使用变量x }
반환 값이 있는 함수를 호출할 때는 해당 반환 값을 받을 필요가 없습니다.
package main import "fmt" //定义全局变量num var num int64 = 10 func testNum() { num := 100 fmt.Printf("num=%d\n", num) // 函数中优先使用局部变量 } func main() { testNum() // num=100 }
intSum
함수 두 개의 매개변수가 있는데 두 매개변수의 유형은 모두 int
이므로 y
뒤에 유형 설명이 있으므로 x
유형은 생략할 수 있습니다. >, x
code> 매개변수도 이 유형입니다. 🎜...
를 추가하여 식별됩니다. 🎜🎜참고: 변수 매개변수는 일반적으로 함수의 마지막 매개변수로 사용됩니다. 🎜🎜예: 🎜func testLocalVar2(x, y int) { fmt.Println(x, y) //函数的参数也是只在本函数中生效 if x > 0 { z := 100 //变量z只在if语句块生效 fmt.Println(z) } //fmt.Println(z)//此处无法使用变量z }
func testLocalVar3() { for i := 0; i 🎜고정 매개변수가 가변 매개변수와 함께 사용되는 경우 가변 매개변수는 고정 매개변수 뒤에 배치되어야 합니다. 샘플 코드는 다음과 같습니다. 🎜<pre class="brush:php;toolbar:false">type calculation func(int, int) int
func add(x, y int) int { return x + y } func sub(x, y int) int { return x - y }
return
키워드를 통해 반환값을 출력합니다. 🎜🎜()를 사용해야 합니다. code >모든 반환 값을 래핑합니다. 🎜🎜예: 🎜<div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">var c calculation
c = add</pre><div class="contentsignin">로그인 후 복사</div></div><div class="contentsignin">로그인 후 복사</div></div>
<h3 id="autoid-1-4-1">🎜반환 값 이름 지정🎜🎜🎜함수 정의 시 반환 값의 이름을 지정할 수 있으며, 이러한 변수를 함수 본문에서 직접 사용할 수 있으며, 마지막으로 <code>return
키워드 반환을 통과합니다. 🎜🎜예: 🎜func main() { var c calculation // 声明一个calculation类型的变量c c = add // 把add赋值给c fmt.Printf("type of c:%T\n", c) // type of c:main.calculation fmt.Println(c(1, 2)) // 像调用add一样调用c f := add // 将函数add赋值给变量f1 fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int fmt.Println(f(10, 20)) // 像调用add一样调用f }
func add(x, y int) int { return x + y } func calc(x, y int, op func(int, int) int) int { return op(x, y) } func main() { ret2 := calc(10, 20, add) fmt.Println(ret2) //30 }
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(参数)(返回值){ 函数体 }
package main import "fmt" //定义全局变量num var num int64 = 10 func testNum() { num := 100 fmt.Printf("num=%d\n", num) // 函数中优先使用局部变量 } func main() { testNum() // num=100 }
接下来我们来看一下语句块定义的变量,通常我们会在if条件判断、for循环、switch语句上使用这种定义变量的方式。
func testLocalVar2(x, y int) { fmt.Println(x, y) //函数的参数也是只在本函数中生效 if x > 0 { z := 100 //变量z只在if语句块生效 fmt.Println(z) } //fmt.Println(z)//此处无法使用变量z }
还有我们之前讲过的for循环语句中定义的变量,也是只在for语句块中生效:
func testLocalVar3() { for i := 0; i <h2 id="autoid-2-1-2"><strong>函数类型与变量</strong></h2><h3 id="autoid-2-2-0"><strong></strong></h3><hr><h3 id="autoid-2-2-0"> <strong>定义函数类型</strong><br> </h3><p>我们可以使用<code>type</code>关键字来定义一个函数类型,具体格式如下:</p><pre class="brush:php;toolbar:false">type calculation func(int, int) int
上面语句定义了一个calculation
类型,它是一种函数类型,这种函数接收两个int类型的参数并且返回一个int类型的返回值。
简单来说,凡是满足这个条件的函数都是calculation类型的函数,例如下面的add和sub是calculation类型。
func add(x, y int) int { return x + y } func sub(x, y int) int { return x - y }
add和sub都能赋值给calculation类型的变量。
var c calculation c = add
我们可以声明函数类型的变量并且为该变量赋值:
func main() { var c calculation // 声明一个calculation类型的变量c c = add // 把add赋值给c fmt.Printf("type of c:%T\n", c) // type of c:main.calculation fmt.Println(c(1, 2)) // 像调用add一样调用c f := add // 将函数add赋值给变量f1 fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int fmt.Println(f(10, 20)) // 像调用add一样调用f }
高阶函数分为函数作为参数和函数作为返回值两部分。
函数可以作为参数:
func add(x, y int) int { return x + y } func calc(x, y int, op func(int, int) int) int { return op(x, y) } func main() { ret2 := calc(10, 20, add) fmt.Println(ret2) //30 }
函数也可以作为返回值:
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 } }
函数当然还可以作为返回值,但是在Go语言中函数内部不能再像之前那样定义函数了,只能定义匿名函数。匿名函数就是没有函数名的函数,匿名函数的定义格式如下:
func(参数)(返回值){ 函数体 }
匿名函数因为没有函数名,所以没办法像普通函数那样调用,所以匿名函数需要保存到某个变量或者作为立即执行函数:
func main() { // 将匿名函数保存到变量 add := func(x, y int) { fmt.Println(x + y) } add(10, 20) // 通过变量调用匿名函数 //自执行函数:匿名函数定义完加()直接执行 func(x, y int) { fmt.Println(x + y) }(10, 20) }
匿名函数多用于实现回调函数和闭包。
闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说,闭包=函数+引用环境
。 首先我们来看一个例子:
func adder() func(int) int { var x int return func(y int) int { x += y return x } } func main() { var f = adder() fmt.Println(f(10)) //10 fmt.Println(f(20)) //30 fmt.Println(f(30)) //60 f1 := adder() fmt.Println(f1(40)) //40 fmt.Println(f1(50)) //90 }
变量f
是一个函数并且它引用了其外部作用域中的x
变量,此时f
就是一个闭包。 在f
的生命周期内,变量x
也一直有效。 闭包进阶示例1:
func adder2(x int) func(int) int { return func(y int) int { x += y return x } } func main() { var f = adder2(10) fmt.Println(f(10)) //20 fmt.Println(f(20)) //40 fmt.Println(f(30)) //70 f1 := adder2(20) fmt.Println(f1(40)) //60 fmt.Println(f1(50)) //110 }
闭包进阶示例2:
func makeSuffixFunc(suffix string) func(string) string { return func(name string) string { if !strings.HasSuffix(name, suffix) { return name + suffix } return name } } func main() { jpgFunc := makeSuffixFunc(".jpg") txtFunc := makeSuffixFunc(".txt") fmt.Println(jpgFunc("test")) //test.jpg fmt.Println(txtFunc("test")) //test.txt }
闭包进阶示例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() { f1, f2 := calc(10) fmt.Println(f1(1), f2(2)) //11 9 fmt.Println(f1(3), f2(4)) //12 8 fmt.Println(f1(5), f2(6)) //13 7 }
闭包其实并不复杂,只要牢记闭包=函数+引用环境
。
Go语言中的defer
语句会将其后面跟随的语句进行延迟处理。在defer
归属的函数即将返回时,将延迟处理的语句按defer
定义的逆序进行执行,也就是说,先被defer
的语句最后被执行,最后被defer
的语句,最先被执行。
举个例子:
func main() { fmt.Println("start") defer fmt.Println(1) defer fmt.Println(2) defer fmt.Println(3) fmt.Println("end") }
输出结果:
start end 3 2 1
由于defer
语句延迟调用的特性,所以defer
语句能非常方便的处理资源释放问题。比如:资源清理、文件关闭、解锁及记录时间等。
在Go语言的函数中return
语句在底层并不是原子操作,它分为给返回值赋值和RET指令两步。而defer
语句执行的时机就在返回值赋值操作后,RET指令执行前。具体如下图所示:
阅读下面的代码,写出最后的打印结果。
func f1() int { x := 5 defer func() { x++ }() return x } func f2() (x int) { defer func() { x++ }() return 5 } func f3() (y int) { x := 5 defer func() { x++ }() return x } func f4() (x int) { defer func(x int) { x++ }(x) return 5 } func main() { fmt.Println(f1()) fmt.Println(f2()) fmt.Println(f3()) fmt.Println(f4()) }
func calc(index string, a, b int) int { ret := a + b fmt.Println(index, a, b, ret) return ret } func main() { x := 1 y := 2 defer calc("AA", x, calc("A", x, y)) x = 10 defer calc("BB", x, calc("B", x, y)) y = 20 }
问,上面代码的输出结果是?(提示:defer注册要延迟执行的函数时该函数所有的参数都需要确定其值)
内置函数介绍
内置函数 | 介绍 |
---|---|
close | 主要用来关闭channel |
len | 用来求长度,比如string、array、slice、map、channel |
new | 用来分配内存,主要用来分配值类型,比如int、struct。返回的是指针 |
make | 用来分配内存,主要用来分配引用类型,比如chan、map、slice |
append | 用来追加元素到数组、slice中 |
panic和recover | 用来做错误处理 |
Go语言中目前(Go1.12)是没有异常机制,但是使用panic/recover
模式来处理错误。 panic
可以在任何地方引发,但recover
只有在defer
调用的函数中有效。 首先来看一个例子:
func funcA() { fmt.Println("func A") } func funcB() { panic("panic in B") } func funcC() { fmt.Println("func C") } func main() { funcA() funcB() funcC() }
输出:
func A panic: panic in B goroutine 1 [running]: main.funcB(...) .../code/func/main.go:12 main.main() .../code/func/main.go:20 +0x98
程序运行期间funcB
中引发了panic
导致程序崩溃,异常退出了。这个时候我们就可以通过recover
将程序恢复回来,继续往后执行。
func funcA() { fmt.Println("func A") } func funcB() { defer func() { err := recover() //如果程序出出现了panic错误,可以通过recover恢复过来 if err != nil { fmt.Println("recover in B") } }() panic("panic in B") } func funcC() { fmt.Println("func C") } func main() { funcA() funcB() funcC() }
注意:
recover()
必须搭配defer
使用。
defer recover
一定要在可能引发panic
的语句之前定义。
练习题
分金币
/* 你有50枚金币,需要分配给以下几个人:Matthew,Sarah,Augustus,Heidi,Emilie,Peter,Giana,Adriano,Aaron,Elizabeth。 分配规则如下: a. 名字中每包含1个'e'或'E'分1枚金币 b. 名字中每包含1个'i'或'I'分2枚金币 c. 名字中每包含1个'o'或'O'分3枚金币 d: 名字中每包含1个'u'或'U'分4枚金币 写一个程序,计算每个用户分到多少金币,以及最后剩余多少金币? 程序结构如下,请实现 ‘dispatchCoin’ 函数 */ var ( coins = 50 users = []string{ "Matthew", "Sarah", "Augustus", "Heidi", "Emilie", "Peter", "Giana", "Adriano", "Aaron", "Elizabeth", } distribution = make(map[string]int, len(users)) ) /* func main() { left := dispatchCoin() fmt.Println("剩下:", left) } */ func main() { for _, v := range users { distribution[v] = 0 for _, k := range v { if k == 'e' || k == 'E' { distribution[v]++ } if k == 'i' || k == 'I' { distribution[v] += 2 } if k == 'o' || k == 'O' { distribution[v] += 3 } if k == 'u' || k == 'U' { distribution[v] += 4 } } } pay := 0 for i, v := range distribution { fmt.Printf("%s 分到:%d\n", i, v) pay += v } fmt.Printf("剩余:%d", (coins - pay)) }
【相关推荐:Go视频教程】
위 내용은 Go 언어는 어떤 기능을 지원하나요?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!