go学习 二

函数

无参无返回值

package main

import "fmt"

// import "time"   #引入包就要使用 不使用会报错

func MyFunc() {
    fmt.Println("asd")
}

func main() { //程序从入口执行 所以先执行的是main 函数
    MyFunc()

}

有参数无返回值

package main

import "fmt"

// import "time"   #引入包就要使用 不使用会报错

func MyFunc(a int) {   
    fmt.Printf("asd %d", a)
}

func main() { //程序从入口执行 所以先执行的是main 函数
    MyFunc(111)

}

不定参数列表

不定参数函数

package main

import "fmt"

// import "time"   #引入包就要使用 不使用会报错

func MyFunc(a int, arg ...int) { //固定参数必须传参，不定参数可以不传参数

    fmt.Printf("%d asd %d,tis %T", a, arg[0], arg)
}

func main() { //程序从入口执行 所以先执行的是main 函数
    MyFunc(11,223,4)

}

参数传递

有一个返回值和多个返回值

‘

或者返回类型一样的情况

有参数有返回值

package main

import "fmt"

// import "time"   #引入包就要使用 不使用会报错

func MyFunc(a, b int) (result int, result2 int) { //固定参数必须传参，不定参数可以不传参数
    if a > b {
        result = a
        result2 = b
    } else {
        result = b
        result2 = a
    }
    return result, result2

}

func main() { //程序从入口执行 所以先执行的是main 函数
    a, _ := MyFunc(11, 223)
    fmt.Printf("sss %d", a)

}

 函数的定义一个类型

（体会多肽）

多态的体现

 

package main

import "fmt"

// import "time"   #引入包就要使用 不使用会报错

func Add(a int, b int) int {
    return a + b
}

func Jian(a int, b int) int {
    return a - b
}

type FuncType func(int, int) int //定义一个类型的函数  体现多态

func MyFunc(a, b int, fTest FuncType) (result int) { //固定参数必须传参，不定参数可以不传参数
    fmt.Println("sss")
    result = fTest(a, b)
    return result

}

func main() { //程序从入口执行 所以先执行的是main 函数
    b := MyFunc(1, 4, Add)  
    s := MyFunc(6, 4, Jian)

    fmt.Println(b, s)
}

运行结果
sss
sss
5 2

匿名函数

func main() { //程序从入口执行 所以先执行的是main 函数
    a := "ass"
    b := 11
    f1 := func() {
        fmt.Printf("zheshi %s he %d\n", a, b)
    }
    f1()
    func() {
        fmt.Printf("zheshi %s he %d\n", a, b)
    }()
    func(a, b int) {  //有参数无返回值
        fmt.Printf("zheshi %d he %d\n", a, b)
    }(44, 55)
    x, y := func(x, y int) (max, min int) {  //又参数又返回值
        if x > y {
            max = x
            min = y
        } else {
            max = y
            min = x
        }
        return max, min

    }(4, 8)
    fmt.Printf("dadea %d xiaode %d", x, y)

}
打印结果

zheshi ass he 11
zheshi ass he 11
zheshi 44 he 55
dadea 8 xiaode 4

闭包函数（特别）

 

 

使用匿名函数

 

 defer函数

func main() { //程序从入口执行 所以先执行的是main 函数
    defer fmt.Println("bbbbb") //延迟调用  main函数结束前调用
    fmt.Println("aaaaa")

}
打印结果

aaaaa
bbbbb

先进后出

 

 defer和匿名函数一起执行的效果

 

获取命令行参数

 

局部变量

 

 全局变量

不同作用域的同名变量

就近原则，函数内部首先找自己函数内的变量，没有额话往外找

 工作区和工程管理

 

包的导入

注意  导入之后必须要使用

导入方式

点操作

给包名取别名

忽略此包

import _ "fmt"  此时我在函数中不实用 fmt包也不会报错 

 

 

 

 

函数

main.go

package main

// import "fmt"

func main() {
    test()
}

test.go

package main

import "fmt"

func test() {
    fmt.Println("zheshi test")

}

 不同目录的调用

目录结构

添加path路径

init函数

mian

package main

import (
    "calc"
    "fmt"
)

func init() {
    fmt.Println("tish is main init")
}

func main() {
    d := calc.Add(1, 2)
    fmt.Println(d)
}

calc.go

package calc

import "fmt"

func init() {
    fmt.Println("tish is calc init")
}

func Add(a, b int) (result int) {
    result = a + b
    return result
}

运行main函数结果  (导入函数  会先运行他的 init函数 然后在运行函数)

tish is calc init
tish is main init
3