练习题1：

创建一个goroutine与主线程按顺序相互发送信息若干次 且打印

package temp

import "fmt"

//创建一个goroutine与主线程按顺序相互发送信息若干次 且打印
var c chan string //声明一个string管道
func Pingpong() {
    i := 0
    for {
        fmt.Println(<-c) //打印管道中取出的数据
        c <- fmt.Sprintf("From pingpong: say hi ,%d", i)
        i++
    }
}
func main() {
    c = make(chan string) //初始化管道内存
    //协程执行函数
    go Pingpong()
    //主函数循环打印十次
    for i := 0; i < 10; i++ {
        c <- fmt.Sprintf("From main: say hi,%d", i)
        fmt.Println(<-c)
    }
}

slice在自动扩容后，内存地址变化

package main

import (
    "fmt"
)

/*
//有关slice的坑，slice在自动扩容后，内存地址已经变了
func Pingpong(s []int) {
    s = append(s, 3)
}

func main() {
    s := make([]int, 0)
    fmt.Println(s)
    Pingpong(s)
    fmt.Println(s)
}
*/

//提供返回值，将append这个心的切片返回
func Pingpong(s []int) []int {
    s = append(s, 3)
    return s
}

func main() {
    s := make([]int, 0) //初始容量是0,append后切片地址变了
    fmt.Printf("%p %v\n", s, s)
    s = Pingpong(s)
    fmt.Printf("%p %v\n", s, s)
}

goroutine与闭包的坑

package main

import (
    "fmt"
)

func main() {
    s := []string{"a", "b", "c"}
    for _, v := range s {
        //此时func()是个闭包函数，变量v是c
        //可以接收一个参数，作为值拷贝
        go func(v) {
            fmt.Println(v)
        }(v)
    }
    select {} //用select阻塞main退出
}

写⼀一个程序，获取当前时间，并格式化成 2017/06/15 08:05:00形式

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    //通过now.Format格式化时间
    fmt.Println(now.Format("2006/01/02 15:04:05"))
}

写⼀一个程序，统计⼀一段代码的执⾏行行耗时，单位精确到微秒。

package main

import (
    "fmt"
    "time"
)

/*
1秒=1000毫秒(ms)

1秒=1,000,000 微秒(μs)

1秒=1,000,000,000 纳秒(ns)
*/
func Task() {
    start := time.Now().UnixNano()   //返回当前的纳秒数
    time.Sleep(5 * time.Millisecond) //睡眠5毫秒
    end := time.Now().UnixNano()
    cost := (end - start) / 1000 //换算成us微秒
    fmt.Printf("do task spend:%d us \n", cost)
}

func main() {
    Task()
}

99乘法表

func testMulti() {
    //有9行，每行有同等数的列
    //i代表行
    for i := 1; i < 10; i++ {
        //j代表列，从1开始，等同于行数
        for j := 1; j <= i; j++ {
            fmt.Printf("%d * %d = %d\t", j, i, j*i)
        }
        fmt.Println()
    }
}

写⼀一个程序，对英⽂文字符串串进⾏行行逆序

func testReverString() {
    var str = "hello超哥"
    //对字符串操作，反转含有中文的字符串，转化为rune切片，rune切片存的是单个字符，而byte切片存单个字节
    var r []rune = []rune(str)
    //遍历rune切片，每次交换头尾2个值，因此只需要交换长度的一半
    fmt.Println(len(r)) //默认rune切片长度是7
    fmt.Printf("%c\n", r)
    for i := 0; i < len(r)/2; i++ {
        //因为索引是从0开始，因此长度要减一
        //每次交换，头尾交换数据，交换5次
        r[len(r)-i-1], r[i] = r[i], r[len(r)-i-1] //交换头尾，r[len(r)-i-1]是尾巴索引，交换给头索引，也就是9换0，8换1，7换2，6换3，5换4
        fmt.Printf("%c\n", r)
    }
    str = string(r)
    fmt.Printf("%s\n", str)
}

写⼀一个程序，判断⼀一个字符串串是否是回⽂文。

func isHuiwen(str string) bool {
    //对字符串操作，反转含有中文的字符串，转化为rune切片，rune切片存的是单个字符，而byte切片存单个字节
    var r []rune = []rune(str)
    //遍历rune切片，每次交换头尾2个值，因此只需要交换长度的一半
    fmt.Println(len(r)) //默认rune切片长度是7
    for i := 0; i < len(r)/2; i++ {
        //因为索引是从0开始，因此长度要减一
        //每次交换，头尾交换数据，交换5次
        r[len(r)-i-1], r[i] = r[i], r[len(r)-i-1] //交换头尾，r[len(r)-i-1]是尾巴索引，交换给头索引，也就是9换0，8换1，7换2，6换3，5换4
    }
    str1 := string(r)
    if str1 == str {
        return true
    }
    //这里由于 golint对代码的静态检查，因此不需要写else，直接return false即可
    return false

}

func main() {
    b := isHuiwen("上海自来水来自海上")
    fmt.Println(b)
}

求1到100之内的所有质数，并打印到屏幕上

//质数p，又称素数(prime)，指在大于1的自然数中，除了1和该数自身外，无法被其他自然数整除的数
//求1-100的质数,
func justify(n int) bool {
    //对传入的数值判断
    //如果小于等于1直接判断false
    if n <= 1 {
        return false
    }
    //循环判断2-100是否为素数
    //此时i是除数，n是被除数
    for i := 2; i < n; i++ {
        //如果余数可以为0，代表可以被整除，也就不符合素数的概念
        if n%i == 0 {
            return false
        }
    }
    return true
}
func test() {
    //循环1-200的数，排除1
    for i := 2; i < 100; i++ {
        if justify(i) == true {
            fmt.Printf("%d is prime\n", i)
        }
    }
}

func main() {
    test()
}

求100-1000的水仙花数

func isShuixianhua(n int) bool {
    //个位数,一个数对10求模就是获取该数的个位数，例如153%10的值是3
    first := n % 10
    //十位数
    second := (n / 10) % 10
    //百位数
    third := (n / 100) % 10
    //水仙花数
    sum := first*first*first + second*second*second + third*third*third
    if sum == n {
        return true
    }
    return false
}
func main() {
    //遍历100-1000之间
    for i := 100; i < 1000; i++ {
        if isShuixianhua(i) == true {
            fmt.Printf("%d 是水仙花数\n", i)
        }
    }
}

输⼊入⼀一⾏行行字符，分别统计出其中英⽂文字⺟母、空格、数字和其它字符的个数

func calc(str string) (charCount int, numCount int, spaceCount int, otherCount int) {
    //遍历统计字符串，需要转换为rune切片，进行挨个判断，如果是某一个类型，计数器就加一
    utfChars := []rune(str)
    for i := 0; i < len(utfChars); i++ {
        if utfChars[i] >= 'a' && utfChars[i] <= 'z' || utfChars[i] >= 'A' && utfChars[i] <= 'Z' {
            charCount++
            continue
        }

        if utfChars[i] >= '0' && utfChars[i] <= '9' {
            numCount++
            continue
        }

        if utfChars[i] == ' ' {
            spaceCount++
            continue
        }

        otherCount++
    }
    return
}
func main() {
    var str string = "我爱北京天安门  10000年"
    charCount, numCount, spCount, other := calc(str)
    fmt.Printf("char count:%d | num count:%d | sp count:%d | other:%d\n", charCount, numCount, spCount, other)
}

插入排序

//插入排序
func insert_sort(a [8]int)[8]int{
    for i:=1;i<len(a);i++{
        for j:=i;j>0;j--{
            if a[j]<a[j-1]{
                a[j],a[j-1]=a[j-1],a[j]
            }else {
                break
            }
        }
    }
    return a
}

选择排序

func select_sort(a [8]int)[8]int{
    for i:=0;i<len(a);i++{
        for j:=i+1;j<len(a);j++{
            if a[j]<a[i]{
                a[i],a[j]=a[j],a[i]
            }
        }
    }
    return a
}

冒泡排序

func bubble_sort(a [8]int) [8]int {
    for i := 0; i < len(a); i++ {
        for j := 0; j < len(a)-i-1; j++ {
            if a[j] > a[j+1] {
                a[j], a[j+1] = a[j+1], a[j]
            }
        }
    }
    return a
}

求数组所有元素之和

//求数组所有元素之和
func sumArray(r [10]int) int {
    var sum int
    for _, v := range r {
        sum += v
    }
    return sum
}

//随机生成一个长度10的数组
func testArray() {
    //通过随机数种子生成值,否则rand.Intn总是一个固定的随机数
    rand.Seed(time.Now().Unix())
    var b [10]int
    for i := 0; i < len(b); i++ {
        b[i] = rand.Intn(100)
    }
    fmt.Println(b)
    sum := sumArray(b)
    fmt.Println(sum)
}

func main() {
    testArray()
}

判断如下结果的输出信息

func main() {
    var sa = make([]string, 5, 10)
    fmt.Println(sa) //默认有5个空元素的切片
    //循环写入十个元素，sa切片自动扩容
    for i := 0; i < 10; i++ {
        //追加是从第六个元素追加
        sa = append(sa, fmt.Sprintf("%v", i))
        fmt.Printf("长度%d，容量%d 内容%v\n", len(sa), cap(sa), sa)
    }
    fmt.Println(sa)
}

结果

yugoMBP:lesson1 yuchao$ go run main.go 
[    ]
长度6，容量10 内容[     0]
长度7，容量10 内容[     0 1]
长度8，容量10 内容[     0 1 2]
长度9，容量10 内容[     0 1 2 3]
长度10，容量10 内容[     0 1 2 3 4]
长度11，容量20 内容[     0 1 2 3 4 5]
长度12，容量20 内容[     0 1 2 3 4 5 6]
长度13，容量20 内容[     0 1 2 3 4 5 6 7]
长度14，容量20 内容[     0 1 2 3 4 5 6 7 8]
长度15，容量20 内容[     0 1 2 3 4 5 6 7 8 9]
[     0 1 2 3 4 5 6 7 8 9]

用golangsort包对数组排序

func pkgSort() {
    // s1 := []int{3, 6, 5, 7, 8, 1} //声明初始化切片
    var a [5]int = [5]int{5, 4, 3, 2, 1}
    sort.Ints(a[:])
    fmt.Println("a:", a)

    var b [5]string = [5]string{"ac", "ec", "be", "fa", "ii"}
    sort.Strings(b[:])
    fmt.Println("b:", b)

    var c [5]float64 = [5]float64{29.38, 22.32, 0.8, 99191.2}
    sort.Float64s(c[:])

    fmt.Println("c:", c)
}

实现⼀一个密码⽣生成⼯工具，支持以下功能 用户可以通过-l指定⽣生成密码的⻓长度 提示:可以⽤用标准包 “flag”解析命令⾏行行参数

用户可以通过-t指定⽣生成密码的字符集，⽐比如 -t num⽣生成全数字的密码 -t char ⽣生成包含全英⽂文字符的密码， -t mix包含⽣生成数字和英⽂文的密码， -t advance ⽣生成包含数字、英⽂文以及特殊字符的密码

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 {
    //初始化密码，存为切片，字符是byte，因此是[]byte，容量是用户指定的
    var passwd []byte = make([]byte, length, length)
    var sourceStr string
    //如果类型是num，返回数字常量，密码就是一堆数字
    if charset == "num" {
        sourceStr = NumStr
        //或者是一个字符
    } else if charset == "char" {
        sourceStr = CharStr
        //或者是混合型的
    } 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)
    //判断用户输入参数 -l
    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\n", length, charset)
    //生成随机数密码
    passwd := generatePasswd()
    fmt.Println(passwd)
}

写⼀一个函数，传⼊入⼀一个int类型的指针，并在函数中修改所指向的值

func testPtr(n *int) {
    *n = 666
}
func main() {
    n := 200
    testPtr(&n)
    fmt.Println(n)
}

写⼀一个程序，统计⼀一个字符串串每个单词出现的次数。⽐比如: s = “how do you do” 输出 how = 1 do = 2 you = 1

//单词次数统计，返回map类型，key=单词，value=次数
func wordCount(str string) map[string]int {
    //初始化map，存放结果
    var result = make(map[string]int, 128)
    //对用户的输入，通过空格分割，区分单词，返回值是个切片
    words := strings.Split(str, " ")
    //遍历切片
    for _, v := range words {
        //ok是对map中的数据判断，count是map的值，也就是统计单词的次数
        count, ok := result[v]
        //如果不存在,添加一次统计
        if !ok {
            result[v] = 1

        } else {
            //如果已经存在了，value的数值+1
            result[v] = count + 1
        }
    }
    return result
}
func main() {
    str := "I am a boy. I have a apple."
    result := wordCount(str)
    //%v 输出默认值  %#v 输出完全的go语法格式
    fmt.Printf("result:%#v\n", result)
}

写⼀一个程序，实现学⽣生信息的存储，学⽣生有id、年年龄、分数等信息。需要⾮非常⽅方 便便的通过id查找到对应学⽣生的信息。

func testInterface() {
    //空接口可以接受任意值
    var a interface{}
    var b int = 100
    var c float32 = 1.2
    var d string = "hello"

    a = b
    fmt.Printf("a=%#v %T\n", a, a)

    a = c
    fmt.Printf("a=%#v %T\n", a, a)

    a = d
    fmt.Printf("a=%#v %T\n", a, a)
}

//写⼀一个程序，实现学⽣生信息的存储，学⽣生有id、年年龄、分数等信息。需要⾮非常⽅方 便便的通过id查找到对应学⽣生的信息。
func studentStore() {
    /*声明map类型，用它存储k-v形式数据 最合适不过
    格式
    学号id [年纪：18 id:1 名字:阿狗 socre:99.9]
    转化为map
    */
    //有一处map的类型是interface{}，可以存储任何类型值，如int，string，float
    //初始化第一层的map，注意内层map还需继续初始化方可使用
    var stuMap = make(map[int]map[string]interface{}, 16)
    // //创建一条学生信息
    // id := 1
    // name := "阿狗"
    // score := 88.9
    // age := 18
    // //插入第一个学生的数据，如果学生不存在，就插入数据，必须得初始化方可使用
    // value, ok := stuMap[id]
    // //如果插入失败，是因为要对map进行初始化才能使用
    // if !ok {
    //     value = make(map[string]interface{}, 8)
    // }
    // value["name"] = name
    // value["id"] = id
    // value["score"] = score
    // value["age"] = age
    // //设置第一条数据
    // stuMap[id] = value
    // fmt.Printf("stuMap: %v\n", stuMap)

    //循环十条记录写入
    for i := 0; i < 10; i++ {
        value, ok := stuMap[i]
        if !ok {
            //如果值不存在，必须要初始化
            value = make(map[string]interface{}, 8)
        }
        //Sprintf接收格式化输出，返回字符串
        value["name"] = fmt.Sprintf("stu%d", i)
        value["id"] = i
        //返回随机的浮点数据
        value["score"] = rand.Float32() * 100.0
        value["age"] = rand.Intn(100) //随机返回100以内的年纪数字
        stuMap[i] = value
    }
    fmt.Println()
    //遍历取出所有学生成绩
    for k, v := range stuMap {
        fmt.Printf("学生id=%d 学生信息=%v\n", k, v)
    }
    //学生6号的信息
    info, ok := stuMap[6]
    if ok {
        fmt.Printf("学生%d号的 姓名：%s 成绩：%f 年纪：%d", info["id"], info["name"], info["score"], info["age"])
    }
    fmt.Println()
}

func main() {
    //testInterface()
    studentStore() //所有学生成绩
    //取出学生成绩
}

你有50枚⾦金金币，需要分配给以下⼏几个⼈人:Matthew, Sarah, Augustus, Heidi, Emilie,Peter, Giana, Adriano, Aaron, Elizabeth。

分配规则如下所示: a. 名字中包含’a’或’A’: 1枚⾦金金币 b. 名字中包含’e’或’E’: 1枚⾦金金币 c. 名字中包含 ‘i’或’I’: 2枚⾦金金币 d. 名字中包含’o’或’O’: 3枚⾦金金币 e. 名字中包含’u’或’U’: 5枚⾦金金币 写⼀一个程序，计算每个⽤用户分到了了多少⾦金金币，以及最后剩余多少⾦金金币?

package main

import "fmt"

//定义50个金币
var (
    coins = 50
    //用户信息存入一个切片，声明且初始化
    users = []string{
        "Matthew", "Sarah", "Augustus", "Heidi", "Emilie",
        "Peter", "Giana", "Adriano", "Aaron", "Elizabeth",
    }
    //分配distribution，根据用户个数分配
    distribution = make(map[string]int, len(users))
)

//计算金币，参数用户名字，计算个人的金币数量
func calcCoin(username string) int {
    var sum int = 0
    for _, char := range username {
        switch char {
        case 'a', 'A':
            sum++
        case 'e', 'E':
            sum++
        case 'i', 'I':
            sum += 2
        case 'o', 'O':
            sum += 3
        case 'u', 'U':
            sum += 5
        }
    }
    return sum
}

//分配金币
func dispathchCoin() int {
    var left = coins //定义剩余金币数
    //遍历users切片，计算金币
    for _, username := range users {
        allCoin := calcCoin(username)
        //计算剩余金币
        left -= allCoin
        value, ok := distribution[username]
        if !ok {
            distribution[username] = allCoin
        } else {
            distribution[username] = value + allCoin
        }
    }
    return left
}

func main() {
    left := dispathchCoin() //剩余金币数
    //遍历map
    for username, coin := range distribution {
        fmt.Printf("用户:\t%s\t拥有\t%d\t金币\n", username, coin)
    }
    fmt.Printf("剩余金币总数：%d\n", left)
}

Go作用域的坑，请说出如下输出

package main

import (
    "fmt"
)

//全局变量
var (
    Ga int = 99
)

const (
    v int = 199
)

func GetGa() func() int {

    if Ga := 55; Ga < 60 {
        fmt.Println("GetGa if 中：", Ga)
    }

    for Ga := 2; ; {
        fmt.Println("GetGa循环中：", Ga)
        break
    }
    //这里用全局变量
    fmt.Println("GetGa函数中：", Ga)
    //闭包函数，匿名函数func()对全局Ga的引用，第一次调用是99+1，第二次是100+1，第三次是101+1，第四次是102+1
    return func() int {
        Ga += 1
        return Ga
    }
}

func main() {
    Ga := "string"
    fmt.Println("main函数中：", Ga)

    b := GetGa()
    fmt.Println("main函数中：", b(), b(), b(), b())

    v := 1 //main函数体中局部变量
    //隐式代码块，有自己局部作用域
    {
        v := 2
        fmt.Println(v)
        {
            v := 3
            fmt.Println(v)
        }
    }
    fmt.Println(v)
}

结果

yugoMBP:golesson yuchao$ go run main.go 
main函数中： string
GetGa if 中： 55
GetGa循环中： 2
GetGa函数中： 99
main函数中： 100 101 102 103
2
3
1

解释

Ga作为全局变量纯在是int类型，值为99；而在main()中时，Ga通过简式声明 := 操作，是string类型，值为string。在main()中，v很典型地体现了在“{}”花括号中的作用域问题，每一层花括号，都是对上一层的屏蔽。而闭包函数，GetGa()返回的匿名函数，赋值给b，每次执行b()，Ga的值都被记忆在内存中，下次执行b()的时候，取b()上次执行后Ga的值，而不是全局变量Ga的值，这就是闭包函数可以使用包含它的函数内的变量，因为作为代码块一直存在，所以每次执行都是在上次基础上运行。
简单总结如下：
有花括号"{ }"一般都存在作用域的划分；
:= 简式声明会屏蔽所有上层代码块中的变量（常量），建议使用规则来规范，如对常量使用全部大写，而变量尽量小写；
在if等语句中存在隐式代码块，需要注意；
闭包函数可以理解为一个代码块，并且他可使用包含它的函数内的变量；

注意，简式变量只能在函数内部声明使用，但是它可能会覆盖函数外全局同名变量。而且你不能在一个单独的声明中重复声明一个变量，但在多变量声明中这是允许的，而且其中至少要有一个新的声明变量。重复变量需要在相同的代码块内，否则你将得到一个隐藏变量。
如果你在代码块中犯了这个错误，将不会出现编译错误，但应用运行结果可能不是你所期望。所以尽可能避免和全局变量同名。