go编程基础-func

package main

import (

"fmt"

)

func main() {

A("a", 1, 3, 5) //[1 3 5]

a, b := 1, 2

A1(a, b)          //[3 4]

fmt.Println(a, b) //1 2

s1 := []int{1, 2}

A2(s1)          //[3 4]

fmt.Println(s1) //[3 4]

b = 1

A3(&b)         //3

fmt.Println(b) //3

c := A4

c() //func A4

//匿名函数

d := func() {

fmt.Println("匿名函数")

}

d() //匿名函数

//闭包

e := A5(10)

fmt.Println(e(1)) //11

//析构-逆序调用-先进后出

fmt.Println("a")

defer fmt.Println("b")

defer fmt.Println("c")

//a c b

for i := 0; i < 3; i++ {

defer fmt.Printf("%d ", i)

}

//2 1 0

for i := 0; i < 3; i++ {

defer func() { fmt.Printf("%d ", i) }()

}

//3 3 3

//go没有异常机制，通过panic/recover模式来处理错误，panic可以在任何地方引发，但recover只能在defer调用的函数中有效

B()

C()

D()

//func B recover in B func D

var fs = [4]func(){}

for i := 0; i < 4; i++ {

defer fmt.Println("defer i=", i)

defer func() {

fmt.Println("defer_closure i=", i)

}()

fs[i] = func() { fmt.Println("closure i=", i) }

}

for _, f := range fs {

f()

}

}

//不定长变参 ...

func A(b string, a ...int) {

fmt.Println(a)

}

func A1(s ...int) {

s[0] = 3

s[1] = 4

fmt.Println(s)

}

func A2(s []int) {

s[0] = 3

s[1] = 4

fmt.Println(s)

}

func A3(a *int) {

*a = 3

fmt.Println(*a)

}

func A4() {

fmt.Println("func A4")

}

func A5(a int) func(int) int {

fmt.Printf("%p\n", &a) //0xc0840000a0

return func(b int) int {

fmt.Printf("%p\n", &a) //0xc0840000a0

return a + b

}

}

func B() {

fmt.Println("func B")

}

func C() {

defer func() {

if err := recover(); err != nil {

fmt.Println("recover in B")

}

}()

panic("panic in B")

}

func D() {

fmt.Println("func D")

}

func F(a int, b string, c int) {

}

func F1(a int, b string, c int) int {

return 1

}

func F2(a int, b string, c int) (int, string, int) {

return 1, "a", 2

}

func F3(a, c int, b string) (int, string, int) {

return 1, "a", 2

}

func F4(a, c int, b string) (d, e int) {

d, e = 1, 2

return d, e

}