先寫一個最基礎的函數案例
import "fmt"
func main() {
fmt.Println(max(5, 100))
}
func max(a, b int) int {
if a > b {
return a
} else {
return b
}
}
函數可能有以下幾種情況
- 無參無傳回值
- 有一個參數的函數
- 有兩個 or 多個參數的函數
- 有一個傳回值的函數
- 有兩個 or 多個傳回值的函數
package main
import "fmt"
func main() {
printinfo()
myprint("54564")
myprint1("54564",5)
fmt.Println(add2(55, 99))
fmt.Println(swap(55, 99))
}
// 無參數無傳回值的函數
func printinfo() {
fmt.Println("dasda")
}
// 有一個參數的函數
func myprint(msg string) {
fmt.Println(msg)
}
// 有兩個參數的函數
func myprint1(msg string, a int) {
fmt.Println(msg)
fmt.Println(a)
}
// 有一個傳回值的函數
func add2(a, b int) int {
c := a + b
return c
}
//有多個傳回值的函數
func swap(a, b int) (int, int) {
a, b = b, a
return a, b
}
1、return 如果直接定義了，那麼傳回結果按照 return 的順序
2、直接調用return不帶結果，那麼則傳回 函數傳回值定義的順序進行結果傳回。
package main
import "fmt"
//函數
func main() {
//var v1 = 1
//var v2 = 2
//fmt.Println(add(v1, v2))
fmt.Println(add(1, 2))
fmt.Println(add1(2, 5))
}
func add(a, b int) (int, int) {
c := a + b
d := a - b
return c, d
}
func add1(a, b int) (c, d int) {
c = a + b
d = a - b
return
}
如果想在函數中傳入可變數量的參數，應該怎麼辦呢？
package main
import "fmt"
func main() {
fmt.Println(add(5, 6, 8, 5))
}
func add(a int, nums ...int) int {
sum := 0
sum += a
for i := 0; i < len(nums); i++ {
sum += nums[i]
}
return sum
}
值傳遞與引用傳遞
package main
import "fmt"
func main() {
s1 := [4]int{1, 2, 3, 4}
fmt.Println(s1)
show1(s1)
fmt.Println(s1)
s2 := []int{1, 2, 3, 4}
fmt.Println(s2)
show2(s2)
fmt.Println(s2)
}
func show1(a [4]int) {
a[0] = 100
fmt.Println(a)
}
func show2(a []int) {
a[0] = 100
fmt.Println(a)
}
[1 2 3 4]
[100 2 3 4]
[1 2 3 4]
[1 2 3 4]
[100 2 3 4]
[100 2 3 4]
函數傳參總結
package main
import "fmt"
// go語言函數傳參總結
func main() {
var a int = 5
var b int = 10
var c int = 115
var d = [3]int{0, 1, 6}
e := [3]*int{&a, &b, &c}
fmt.Println(f1(1, 2))
fmt.Println(f2([3]int{1, 2, 30}))
fmt.Println(f3([]int{11, 22, 222}))
fmt.Println(f4(&a))
fmt.Println(f5(e))
fmt.Println(f6(&d))
f7(1111, 1, 2, 3, 4, 5, 6, 7)
}
// 基本形式
func f1(a, b int) (int, int) {
return b, a
}
// 傳入數組
func f2(a [3]int) [3]int {
return a
}
// 傳入切片
func f3(a []int) []int {
return a
}
// 傳入指針
func f4(a *int) int {
return *a
}
//傳入指針數組
func f5(a [3]*int) [3]int {
var b = [3]int{*a[0], *a[1], *a[2]}
return b
}
//傳入數組指針
func f6(a *[3]int) [3]int {
return *a
}
//傳入不定長資料
func f7(a int, num ...int) {
fmt.Println(a)
for _, v := range num {
fmt.Println(v)
}
for i := 0; i < len(num); i++ {
fmt.Println(num[i])
}
}
2 1
[1 2 30]
[11 22 222]
5
[5 10 115]
[0 1 6]
1111
1
2
3
4
5
6
7
1
2
3
4
5
6
7
匿名函數
Go語言支援匿名函數，即在需要使用函數時再定義函數，匿名函數沒有函數名隻有函數體，函數可以作為一種類型被指派給函數類型的變量，匿名函數也往往以變量方式傳遞。匿名函數是指不需要定義函數名的一種函數實作方式，由一個不帶函數名的函數聲明和函數體組成。
func (inputs) (outputs) {
// function body
}(arguments)
基礎案例
func(data int) {
fmt.Println("hello", data)
}(100)
注意第3行}後的(100)，表示對匿名函數進行調用，傳遞參數為 100。
// 匿名函數，在函數體後增加()，調用了這個函數，匿名函數隻能一次。
func() {
fmt.Println("我是一個匿名函數")
}()
// 将匿名函數進行指派，就可以實作多次調用。
//注意這種匿名函數定義的時候最後不加括号調用
f3 := func() {
fmt.Println("我是一個匿名函數")
}
f3()
// 匿名函數是否可以添加參數和傳回值
func(a, b int) {
fmt.Println("a,b")
}(1, 2)
// 将匿名函數的傳回值定義給變量。
r1 := func(a, b int) int {
fmt.Println("sdasdascdvdv")
return a + b
}(1, 2)
fmt.Println(r1)
注意最後一塊代碼将會先調用匿名函數，是以會列印那一串字母
我是一個匿名函數
我是一個匿名函數
a,b
sdasdascdvdv
3
func main() {
//f2 如果不加括号就是一個變量
fmt.Printf("%T\n", f2) //func(int, int)
fmt.Printf("%T\n", "asda") //string
fmt.Printf("%T\n", 5) //int
//var f5 func(int, int) int
f5 := f2
fmt.Println(f5)
fmt.Println(f2)
f5(1, 2)
}
func f2(a, b int) int {
fmt.Println(a, b)
return 1
}
func(int, int) int
string
int
0xc2fea0
0xc2fea0
1 2
匿名函數用作回調函數
周遊中通路每個元素的操作使用匿名函數來實作，使用者傳入不同的匿名函數體可以實作對元素不同的周遊操作
func main() {
visite([]int{1, 2, 3, 4}, func(i int) {
fmt.Println(i)
})
}
func visite(a []int, f func(int)) {
for _, v := range a {
f(v)
}
}
1
2
3
4
![241 Different Ways to Add Parentheses（C代碼版）[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)