golang 函数 05

灰太狼 2022-12-08 12:53 134阅读 0赞

*   func进行函数声明
 *  函数的左花括号也不能另起一行
 *  不允许函数内嵌定义
 *  支持多返回值、支持命名返回值
 *  函数只能判断是否为nil
 *  参数视为局部变量，因此不能声明同名变量
 *  不支持默认参数，支持可变参数
 *  可以在函数内定义匿名函数
 *  闭包（以后会单独写一篇博客介绍golang中的闭包）
 *  不支持函数重载

package base016
    
    import "fmt"
    
    func FunRun(){
    	sum,avg := calc(3,5)
    	fmt.Println("FunRun", sum,avg)
    	fmt.Println("FunRun", addMore(6,1,2,3,4))
    
    	a()
    }
    
    func a() {
    	defer func() {
    		fmt.Println("defer","1")
    	}()
    	defer func() {
    		fmt.Println("defer","2")
    	}()
    	defer func() {
    		fmt.Println("defer","3")
    	}()
    	fmt.Println("defer")
    	return
    
    	/*
    	file := open(filename)
    	defer file.Close()
    	//文件操作
    	*/
    	/*
    	mc.Lock()
    	defer mc.Unlock()
    	//其他操作
    	*/
    }
    
    //函数有异常返回
    func div(a, b int) (int, error) {
    	if b == 0 {
    		return 0, fmt.Errorf("分母不能为0")
    	}
    	return a / b, nil
    }
    
    /**
    	a,b 传入参数
    	直接设置sum 和 avg是传出参数
     */
    func calc(a, b int) (sum int, avg int) {
    	sum = a + b
    	avg = (a +b)/2
    	return
    }
    
    func addMore(a int, arg... int) int {
    	for _, v := range arg {
    		a += v
    	}
    	return a
    }

//有Exit退出程序，是不会执行defer
    func deferExit() {
        defer func() {
            fmt.Println("defer")
        }()
        os.Exit(0)
    }

*  什么是method 
 *  带有receiver的一个function

package main
    
    import "fmt"
    
    type Human struct {
    	name string
    	age int
    	phone string
    }
    
    type Student struct {
    	Human //匿名字段
    	school string
    }
    
    type Employee struct {
    	Human //匿名字段
    	company string
    }
    
    //继承（子类都包含这个方法）
    func (h *Human) SayHi() {
    	fmt.Printf("Hi, I am %s you can call me on %s\n", h.name, h.phone)
    }
    
    //重写（指定子类修改原始方法）
    func (e *Employee) SayHi() {
    	fmt.Printf("Hi, I am %s, I work at %s. Call me on %s\n", e.name,
    		e.company, e.phone) //Yes you can split into 2 lines here.
    }
    
    func main() {
    	mark := Student{Human{"David", 32, "13478808311"}, "MIT"}
    	sam := Employee{Human{"Messi", 30, "13478808311"}, "Xueba Edu"}
    	mark.SayHi()
    	sam.SayHi()
    }

/*
    go 不支持重载
    
    执行顺序:全局变量 》 init 》 main
    */
    func main() {
    	//funSprint(1, 2, 3, 4, 5, 6)
    
    	//niming()
    
    	fun1 := clousure()
    	fmt.Println(fun1(1))
    	fmt.Println(fun1(6))
    	fmt.Println(fun1(3))
    
    	fun2 := clousure()
    	fmt.Println(fun2(3))
    	fmt.Println(fun2(6))
    	fmt.Println(fun2(8))
    
    	runDefer()
    }
    
    func funSprint(args ...int) {
    	for k, v := range args {
    		fmt.Println(k, v)
    	}
    
    }
    
    //匿名函数
    func niming() {
    	//1
    	sumVar1 := func(num1, num2 int) int {
    		return num1 * num2
    	}(2, 6)
    	fmt.Println(sumVar1)
    
    	funVar2 := func(num1, num2 int) int {
    		return num1 + 5*num2
    	}
    
    	fmt.Println(funVar2(2, 6))
    }
    
    //闭包
    func clousure() func(int64) int64 {
    	var step int64 = 0
    
    	return func(_step int64) int64 {
    		step += _step
    		return step
    	}
    }
    
    //先进后出，会在函数执行完，最后执行
    func runDefer() {
    
    	defer fmt.Println(1)
    	defer fmt.Println(2)
    	defer fmt.Println(3)
    	defer fmt.Println(4)
    }

package main
    
    import (
    	"fmt"
    )
    
    type Base struct{}
    type Baser interface {
    	Get() float32
    }
    
    type TypeOne struct {
    	value float32
    	Base
    }
    
    type TypeTwo struct {
    	value float32
    	Base
    }
    
    type TypeThree struct {
    	value float32
    	Base
    }
    
    func (t *TypeOne) Get() float32 {
    	return t.value
    }
    
    func (t *TypeTwo) Get() float32 {
    	return t.value * t.value
    }
    
    func (t *TypeThree) Get() float32 {
    	return t.value + t.value
    }
    
    func main() {
    	base := Base{}
    	t1 := &TypeOne{1, base}
    	t2 := &TypeTwo{2, base}
    	t3 := &TypeThree{4, base}
    
    	bases := []Baser{Baser(t1), Baser(t2), Baser(t3)}
    
    	for s, v := range bases {
    		switch bases[s].(type) {
    		case *TypeOne:
    			fmt.Println("TypeOne")
    		case *TypeTwo:
    			fmt.Println("TypeTwo")
    		case *TypeThree:
    			fmt.Println("TypeThree")
    		}
    
    		//fmt.Printf("The value is:  %f\n", bases[s].Get())
    		fmt.Printf("The value is:  %f\n",v.Get())
    	}
    }