Go 流程控制

Go在流程控制方面特点如下：

• 没有do和while循环，只有一个广义的for语句
• switch语句灵活多变，还可以用于类型判断
• if语句和switch语句都可以包含一条初始化子语句
• break语句和continue语句可以跟一条label标签语句，用于标识需要终止或继续的代码块
• defer语句可以使我们更加方便地执行异常捕获和资源回收任务
• select语句也可以用于多分支选择，但只与通道配合使用
• go语句用于异步启动goroutine并执行指定函数

for range 注意点：

• 对数组、切片或者字符串值进行迭代，：=左边只有一个迭代变量时，要注意只能得到元素的索引，而不是元素。
• 迭代没有任何元素的数组值、为nil的切片值、为nil的字典值、为“”的字符串值，不会执行for语句中的代码。for在一开始就会结束。因为这些值长度是0
• 迭代为nil的通道值会让当前流程永远阻塞在for语句上。

Golang之（if）流程控制

package main

import (
    "fmt"
)

func testIf1() {
    num := 10
    //var num int
    //num = 10
    if num%2 == 0 {
        fmt.Printf("num:%d is even
", num)
    } else {
        fmt.Printf("num:%d is odd
", num)
    }

    fmt.Printf("num=%d
", num)
}

func testIf2() {
    num := 10
    if num > 5 && num < 10 {
        fmt.Printf("num:%d is > 5 and < 10
", num)
    } else if num >= 10 && num < 20 {
        fmt.Printf("num:%d is > 10 and < 20
,", num)
    } else if num >= 20 && num < 30 {
        fmt.Printf("num:%d is > 20 and < 30
", num)
    } else {
        fmt.Printf("num:%d is > 30
", num)
    }
}

func testIf3() {
    //num := 10
    //var num int
    //num = 10
    if num := 11; num%2 == 0 {
        fmt.Printf("num:%d is even
", num)
    } else {
        fmt.Printf("num:%d is odd
", num)
    }

    //fmt.Printf("num=%d
", num)
}

func getNum() int {
    return 1
}

func testIf4() {
    //num := 10
    //var num int
    //num = 10
    if num := getNum(); num%2 == 0 {
        fmt.Printf("num:%d is even
", num)
    } else {
        fmt.Printf("num:%d is odd
", num)
    }

    //fmt.Printf("num=%d
", num)
}

func main() {
    //testIf1()
    //testIf2()
    //testIf3()
    testIf4()
}

Golang之（for）用法

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func testFor1() {
    var i int
    for i = 1; i < 10; i++ {
        fmt.Printf("i=%d
", i)
    }
    fmt.Printf("final:i=%d
", i)
}

func testFor2() {
    var i int
    for i = 1; i < 10; i++ {
        fmt.Printf("i=%d
", i)
        if i > 5 {
            break
        }
    }
    fmt.Println(i)
}

//打印奇数
func testFor3() {
    var i int
    for i = 1; i < 1000; i++ {
        //正整数，就调出本次循环，所以不打印
        if i%2 == 0 {
            continue
        }
        fmt.Printf("i=%d
", i)
    }

}
func testFor4() {
    i := 1
    for i <= 10 {
        fmt.Printf("i=%d
", i)
        i = i + 2
    }
}

func testFor5() {
    i := 1
    for i <= 10 {
        fmt.Printf("i=%d
", i)
        i = i + 2
    }
}

func testMultiSign() {
    a, b, c := 10, "hello", 100
    fmt.Printf("a=%d b=%s c=%d
", a, b, c)
}

func testFor6() {
    for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 {
        fmt.Printf("%d*%d=%d
", no, i, no*i)
    }
}

func testFor7() {
    for {
        fmt.Printf("hello
")
        time.Sleep(time.Second)
    }
}

//峰云大神-http://xiaorui.cc/2016/03/23/golang%E9%9A%8F%E6%9C%BAtime-sleep%E7%9A%84duration%E9%97%AE%E9%A2%98/
func fengyun() {
    rand.Seed(time.Now().UnixNano())
    for i := 0; i < 10; i++ {
        x := rand.Intn(10)
        fmt.Println(x)
        time.Sleep(time.Duration(x) * time.Second)
    }
}

//入口执行函数
func main() {
    //testFor1()
    //testFor2()
    //testFor3()
    //testFor4()
    //testFor5()
    //testFor6()
    //testFor7()
    fengyun()
}

Golang实现一个密码生成器

package main

import (
    "flag"
    "fmt"
    "math/rand"
    "time"
)

var (
    length  int
    charset string
)

const (
    NUmStr  = "0123456789"
    CharStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
    SpecStr = "+=-@#~,.[]()!%^*$"
)

//解析参数
func parseArgs() {
    //需要接受指针，就传递地址,&
    flag.IntVar(&length, "l", 16, "-l 生成密码的长度")
    flag.StringVar(&charset, "t", "num",
        //反引号以原样输出
        `-t 制定密码生成的字符集,
        num:只使用数字[0-9],
        char:只使用英文字母[a-zA-Z],
        mix:使用数字和字母，
        advance:使用数字、字母以及特殊字符`)
    flag.Parse()
}

//检测字符串中的空格
func test1() {
    for i := 0; i < len(CharStr); i++ {
        if CharStr[i] != ' ' {
            fmt.Printf("%c", CharStr[i])
        }
    }
}

func generatePasswd() string {
    //初始化密码切片
    var passwd []byte = make([]byte, length, length)
    //源字符串
    var sourceStr string
    //判断字符类型,如果是数字
    if charset == "num" {
        sourceStr = NUmStr
        //如果选的是字符
    } else if charset == "char" {
        sourceStr = charset
        //如果选的是混合模式
    } else if charset == "mix" {
        sourceStr = fmt.Sprintf("%s%s", NUmStr, CharStr)
        //如果选的是高级模式
    } else if charset == "advance" {
        sourceStr = fmt.Sprintf("%s%s%s", NUmStr, CharStr, SpecStr)
    } else {
        sourceStr = NUmStr
    }
    fmt.Println("source:", sourceStr)

    //遍历，生成一个随机index索引,
    for i := 0; i < length; i++ {
        index := rand.Intn(len(sourceStr))
        passwd[i] = sourceStr[index]
    }
    return string(passwd)
}

func main() {
    //随机种子
    rand.Seed(time.Now().UnixNano())
    parseArgs()
    fmt.Printf("length:%d charset:%s
", length, charset)
    //test1()
    passwd := generatePasswd()
    fmt.Println(passwd)
    fmt.Printf("length:%d charset:%s
", length, charset)
}

defer 控制语句

package main

import (
    "fmt"
)

//outerFunc是外围函数
//defer执行顺序是，先进后出，延迟调用指定的函数
//当外围函数中语句执行完毕时，只有延迟函数都执行完毕，外围函数才真的结束
//当执行外媒函数中的return时，只有延迟函数都执行完毕，外围函数才返回
//当外围函数中的代码引发运行错误时，只有延迟函数执行完毕，运行时的错误才会被扩散至调用函数。

//因此defer常用在执行释放资源或异常处理等收尾任务
//defer语句在外围函数体中位置不限，数量不限

func printNumbers() {
    for i := 0; i < 5; i++ {
        //defer被压进一个栈，函数完毕前一刻，先进后出，所以是43210
        defer func() {
            fmt.Printf("%d", i)
        }()
    }
}

func printNumbers1() {
    for i := 0; i < 5; i++ {
        //defer被压进一个栈，函数完毕前一刻，先进后出，所以是43210
        defer func(n int) {
            fmt.Printf("%d", n)
        }(i)
    }
}
func printNumbers2() {
    for i := 0; i < 5; i++ {
        //defer被压进一个栈，函数完毕前一刻，先进后出，所以是43210
        defer func(n int) {
            fmt.Printf("%d", n)
        }(i * 2)
    }
}

func main() {
    printNumbers()
    fmt.Println()
    printNumbers1()
    fmt.Println()
    printNumbers2()
}

Golang之一个简单的聊天机器人

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    //从标准输入读取数据
    inputReader := bufio.NewReader(os.Stdin)
    fmt.Println("Please input your name：")
    //读取数据直到遇见
位置
    input, err := inputReader.ReadString('
')
    if err != nil {
        fmt.Printf("An error occurred:%s
", err)
        //异常错误后退出
        os.Exit(1)

    } else {
        //用切片操作删除最后的

        name := input[:len(input)-1]
        fmt.Printf("Hello,%s!What can i di for you?
", name)
    }
    for {
        input, err = inputReader.ReadString('
')
        if err != nil {
            fmt.Printf("An error occurred:%s
", err)
            continue
        }
        input = input[:len(input)-1]
        //全部转换为小写
        input = strings.ToLower(input)
        switch input {
        case "":
            continue
        case "nothing", "bye":
            fmt.Println("Bye!")
            //正常退出
            os.Exit(0)
        default:
            fmt.Println("Sorry,I didn't catch you.")

        }
    }
}