go语言

Posted 2022-08-30 parallel-y

一、函数基础

　　定义：有输入、有输出、用来执行一个指定任务的代码块

func 函数名(形参列表)(返回值列表)
    执行代码
    return 返回值列表


//无参数和返回值
func test()
    fmt.Println("helloWorld")

func main()
    test()


//函数的多返回值
func test(x,y int,z string) (int,string)
    //类型相同的相邻参数x,y参数类型可以合并
    //多返回值得用括号括起来
    n := x+y
    return n,z


//返回值进行命名
func test2(a,b int) (sum int,sub int) 
    sum = a+b
    sub = a-b
    return

func main()
    sum,sub := test2(100,800)
    fmt.Println(sum,sub)


//可变参数
func test3(b ...int) int
    sum :=0
    for i := 0;i<len(b);i++
        sum = sum + b[i]
    
    return sum

func main()
    sum := test3(10,20)    //可以传任意个参数
    fmt.Printf("sum=%d\n"),sum)

二、函数defer语句

　　　　定义：在一个函数中有defer语句时，只有到返回的时候才会执行，多个defer时执行顺序是从后往前，多用于资源脂肪，使用defer关闭资源

func test()
    defer fmt.Println("Hello")
    fmt.Println("Parallel")
    fmt.Println("World")
)
//结果    Parallel  World  Hello

func test2()
    defer fmt.Println("Hello")
    defer fmt.Println("Hello1")
    defer fmt.Println("Hello2")
    fmt.Println("Parallel")
    fmt.Println("World")

//结果    Parallel  World  Hello2  Hello1  Hello

fun test3()
    for i:=0;i<5;i++
        defer fmt.Println(i)
    

//结果    4  3  2  1  0

func test4()
    i := 0
    defer fmt.Println(i)
    i = 1000
    fmt.Println(i)

//结果    1000 0    当执行代码到defer时，参数已经传入，但是最后执行

三、内置函数

　　　　close：主要用来关闭channel(管道)

　　　　len：用来求长度(如：string，array，slice，map，channel)

　　　　new：用来初始化int、struct，返回指针　　var a = new(int)：得到一个int类型的指针

　　　　make：用来初始化channel，map，slice

　　　　append：用来追加元素到slice

　　　　panic和recover：用来做错误处理　　

　　变量作用域和可见性

//作用域：全局变量，在函数最外层
var a int = 100
func test()
    fmt.Printf("a = %d\n",a)


//作用域：局部变量(1.函数内定义2.语句块内定义)
func add(a int,b int) int 
    var sum int = 0    //sum是局部变量
    if a>0
        var c int = 100    //c是局部变量，只在if语句块有效
    


//可见性：包内任何变量或函数都是能访问的，首字母大写是可以导出的，能够被其他包访问或调用，小写表示私有，不能被嗲用
package caic
var a int = 100
var A int = 200
func Add(a,b int) int
    return a+b

func sub(a,b int) int
    return a-b


package caic
func Test()int
    return a
    //包名相同，可以调用

package main
import ("fmt","caic")
func main()
    var s1 int = 200
    var s2 int = 300
    sum := calc.Add(s1,s2)
    fmt.Printf("s1+s2=%d",sum)    //500
    fmt.Printf("caic.A=%d",caic.A)    //200
    fmt.Printf("caic.a=%d",caic.Test())
    //可以调用caic包中的Add函数和Test函数还有大写的的变量

四、匿名函数

//函数是一种类型，因此可以定义一个函数类型的变量
func add(a,b int) int
    return a + b

func testFunc1()
    f1:=add
    fmt.Printf("type of f1 = %T\n",f1)    //打印变量用%T
    sum := f1(2,5)    //函数类型的变量
    fmt.Printf("sum=%d\n",sum)

func main()
    testFunc1()


//匿名函数，没有命名的函数
func testFunc2()
    f1 := func(a,b int) int    //匿名函数
        return a+b
    
    fmt.Printf("type of f1=%T\n",f1)
    sum := f1(2,5)
    fmt.Printf("sum = %d\n",sum)

funt main()
    testFunc2()


//defer使用匿名函数
func testFunc3()    
    defer func()
        fmt.Printf("defer i=%d\n",i)    //100
    ()
    i = 100
    fmt.Printf("i=%d\n",i)


//函数作为一个参数
func add(a,b int) int
    return a+b

func sub(a,b int) int
    return a-b

func calc(a,b int,op func(int,int)int)int
    return op(a,b)

func testDefer5()
    sum := calc(100,300,add)
    sub := calc(100,300,sub)
    fmt.Printf("sum-%d sub-%d\n",sum,sub)

五、函数闭包

　　　　定义：一个函数和与其相关的引用环境组合而成的实体(匿名函数嵌套，闭包是外部函数嵌套内部函数，内部函数引用外部函数的变量，外部函数用完变量后，被内部函数引用并保留下来，作为自由变量使用，就是闭包)

func Adder() func(int) int
    var x int
    return func(d int) int
        x += d
        return x
    

func testClosure1()
    f:= Adder()
    ret := f(1)
    fmt.Printf("ret=%d\n",ret)    //1
    ret = f(20)
    fmt.Printf("ret%d\n",ret)    //21
    ret = f(300)
    fmt.Printf("ret=%d\n",ret)    //321


//test
func add(base int) func(int) int
    return func (i int) int
        base += i
        return base
    

func testClosure1()
    tmp1 := add(10)
    fmt.Println(tmp1(1),tmp1(2))
    tmp2 := add(100)
    fmt.println(tmp2(1),tmp2(2))


//test2
func test(suffix string) func(string) string
    return func(name string) string
        if !strings.HasSuffix(name,suffix)
            return name + suffix
        
        return name
    

func testClosure1()
    func1 := test(".bmp")
    func2 := test(".jpg")
    fmt.Println(func1("test"))    //test.bmp
    fmt.Println(func2("test"))    //test.jpg


//test3
func calc(base int) (func(int) int,func(int) int) 
    add := func(i int) int
        base += i
        return base
    
    return add,sub

func testClosure1()
    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
    fmt.Println(f1(7), f2(8))    //14 6


//test4
func testClosure1()
    for i:=0;i<5;i++
        go func()
            Fmt.Println(i)
        ()
    
    time.Sleep(time.Second)

//输出    55555    有坑，每次i会赋值给函数中，但到5时才打印

//test5
func testClosure1()
    for i:=0;i<5;i++
        go func(index int) 
            fmt.Println(index)
        (i)
    
    time.Sleep(time.Second)

//输出    01234