Golang流程语句 Yang

package main

import (
    "fmt"
)

func main() {

    //if
    /*
        x := 5
        if x > 10 {
            fmt.Println("X is larger than 10")
        } else {
            fmt.Println("X is smaller than 10")
        }

        //也可写成
        //if y := GetSomeNumber(); y < 10 {

        //}
    */

    //goto 用goto跳转到必须在当前函数内定义的标签(以冒号结束作为标签,且大小写敏感)
    /*
            i := 0
        Here:
            fmt.Println(i)
            i++
            goto Here
    */

    //for  和其他语言的for一样，但他可以当作while来使用,也可配合range 读取slice,map数据
    /*
            //for=while
            sum := 0
            for sum < 100 {
                sum++
            }

            //for range map(slice)
            for k,v=range map{
                fmt.Println("map's key :",k)
                fmt.Println("map's value:",v)
            }

            //如果没有fmt.Println("map's key :",k)这句，使用k申明了而没使用，会造成编译出错
            //所以，要做修改将k改成_,来丢弃不需要的返回值
            for k,v=range map{
                fmt.Println("map's key :",k)
                fmt.Println("map's value:",v)
            }
            //修改成
            for _,v=range map{
                fmt.Println("map's value:",v)
            }
    */

    //switch,如果swith 没有表达式，它会匹配true;每个case后面不用加break;
    //它默认加了break,如果要实现没有break的情况，要在除default外的所有case后面加fallthrough
    /*
        i := 5
        switch i {

        case 1:
            fmt.Println("i is equal to 1")
        case 2:
            fmt.Println("i is equal to 2")
        case 3, 4, 5, 6:
            fmt.Println("i is equal to 3,4,5 or 6")
            fallthrough //添加后，相当于去掉默认的break
        default:
            fmt.Println("others")

        }
    */

    //函数
    /*
            func funcName(input1 type1,input2 type2)(output1 type1,output2 type2)
            {
                      //返回多个值
                      return value1,value2        
            }

            //上面返回值声明了两个变量output1和output2，
            //如果你不想声明也可以，直接就两个类型
            func funcName(input1 type1,input2 type2)(type1,type2)
            {
                      //返回多个值
                      return value1,value2        
            }

            //如果只有一个返回值且不声明返回值变量，那么你可以省略 包括返回值 的括号
            func funcName(input1 type1,input2 type2) type1
            {
                      //返回1个值,可省略返回值的名称和括号
                      return value1+value2        
            }

            //如果没有返回值，那么就直接省略最后的返回信息
            func funcName(input1 type1,input2 type2) 
            {
                      //没有返回值,可省略返回信息
                      sum:= value1+value2        
            }

            //如果参数类型相同，则可以省略第一个参数的类型
            //说明input1和input2都是参数都是int类型的
            func funcName(input1 ,input2 int) 
            {
                      //有返回值,return必须写在最外层
                      return  value1+value2        
            }
            //变参,参数类型为int,个数不限
            func funcName(arg ...int) {

            }

            //示例
            var var1 int32 = 2
            var var2 int32 = 5
            var3, var4 := PlusAndTimes(var1, var2)
            fmt.Printf("%d,%d", var3, var4)
    */

    //传值与传指针

    //传指针使得多个函数能操作同一个对象。
    //传指针比较轻量级 (8bytes),只是传内存地址，
    //我们可以用指针传递体积大的结构体。
    //如果用参数值传递的话, 在每次copy上面就会花费相对较多的系统开销（内存和时间）。
    //所以当你要传递大的结构体的时候，用指针是一个明智的选择。
    //Go语言中string，slice，map这三种类型的实现机制类似指针，
    //所以可以直接传递，而不用取地址后传递指针。
    //（注：若函数需改变slice的长度，则仍需要取地址传递指针）

    //传值,传指针示例
    /*
        x := 3
        fmt.Println("x = ", x)    // 应该输出 "x = 3"
        x1 := addByValue(x)       //调用add1(x)
        fmt.Println("x+1 = ", x1) // 应该输出"x+1 = 4"
        fmt.Println("x = ", x)    // 应该输出"x = 3"

        fmt.Println("------------")
        //传指针
        fmt.Println("x = ", x)    // 应该输出 "x = 3"
        x2 := addByPoint(&x)      //调用add1(x)
        fmt.Println("x+1 = ", x2) // 应该输出"x+1 = 4"
        fmt.Println("x = ", x)    // 应该输出"x = 4"
    */

    //defer
    //Go语言中有种不错的设计，即延迟（defer）语句，你可以在函数中添加多个defer语句。
    //当函数执行到最后时，这些defer语句会按照【逆序】执行，最后该函数返回
    //见示例

    //函数作为值、类型
    //Go中函数也是一种变量，我们可以通过type来定义它，
    //它的类型就是所有拥有相同的参数，相同的返回值的一种类型
    //类似于c#中的委托

    //示例
    slice := []int{1, 2, 3, 4, 5, 7}
    fmt.Println("slice = ", slice)
    odd := filter(slice, isOdd) // 函数当做值来传递了
    fmt.Println("Odd elements of slice are: ", odd)
    even := filter(slice, isEven) // 函数当做值来传递了
    fmt.Println("Even elements of slice are: ", even)

    //Panic和Recover
    //Panic:当函数F调用panic，函数F的执行被中断，
    //但是F中的延迟函数会正常执行，然后F返回到调用它的地方。
    //Recover:仅在延迟函数中有效。
    //在正常的执行过程中，调用recover会返回nil，并且没有其它任何效果。

    //main函数和init函数
    //每个package中的init函数都是可选的，
    //但package main就必须包含一个main函数。

    //执行顺序
    //初始化和执行main包-->导入其他包（如果main包导入了其他包）-->初始化其他包的常量、变量
    //-->执行其他包的init()-->初始化main包的变量、常量-->执行main包的init()-->执行main()
}

func PlusAndTimes(var1, var2 int32) (plusVar, timesVar int32) {
    plusVar = var1 + var2
    timesVar = var1 * var2
    return
}

//简单的一个函数，实现了参数+1的操作
func addByValue(a int) int {
    a = a + 1 // 我们改变了a的值
    return a  //返回一个新值
}

//简单的一个函数，实现了参数+1的操作
func addByPoint(a *int) int {
    *a = *a + 1
    return *a
}

//defer Demo
/*
func testNoDefer() bool {
    file.open("file")
    if failureX {
        file.close()
        return false
    }
    if failureY {
        file.close()
        return false
    }
    file.close()
    return true
}

func testDefer() bool{
    file.opern()
    defer file.close()
    if failureX {
        return false
    }
    if failureY {
        return false
    }
    return true
}
*/

//声明一个函数类型(类型于c#中的委托),isOdd和isEven的参数和返回值必须和testInt一样

type testInt func(intVar int) bool

func isOdd(integer int) bool {
    if integer%2 == 0 {
        return true
    }
    return false
}

func isEven(integer int) bool {
    if integer%2 == 0 {
        return false
    }
    return true
}

func filter(slice []int, f testInt) []int {
    var result []int
    for _, value := range slice {
        if f(value) {
            result = append(result, value)
        }
    }
    return result
}