Go语言学习之3 流程控制、函数

主要内容：

1. strings和strconv使用
2. Go中的时间和日期类型
3. 指针类型
4. 流程控制
5. 函数详解

1. strings和strconv使用

//strings
1. strings.HasPrefix(s string, prefix string) bool：判断字符串s是否以prefix开头 。
2. strings.HasSuffix(s string, suffix string) bool：判断字符串s是否以suffix结尾。
3. strings.Index(s string, str string) int：判断str在s中首次出现的位置，如果没有
4. strings.LastIndex(s string, str string) int：判断str在s中最后出现的位置，如果没有
5. strings.Replace(str string, old string, new string, n int)string：字符串替换
6. strings.Count(str string, substr string)int：字符串计数
7. strings.Repeat(str string, count int)string：重复count次str
8. strings.ToLower(str string)string：转为小写
9. strings.ToUpper(str string)string：转为大写
10. strings.TrimSpace(str string) string：去掉字符串首尾空白字符
    strings.Trim(str string, cut string) string：去掉字符串首尾cut字符
    strings.TrimLeft(str string, cut string) string：去掉字符串首cut字符
    strings.TrimRight(str string, cut string) string：去掉字符串首cut字符
11. strings.Fields(str string) []string：返回str空格分隔的所有子串的slice
    strings.Split(str string, split string) []string：返回str split分隔的所有子串的slice
12. strings.Join(s1 []string, sep string) string：用sep把s1中的所有元素链接起来

//strconv
13. strconv.Itoa(i int) string：把一个整数i转成字符串
14. strconv.Atoi(str string)(int, error)：把一个字符串转成整数

例子：

package main 

import (
    "fmt"
    "strings"
    "strconv"
)

func main() {
    var res bool
    //HasPrefix
    res = strings.HasPrefix("https://www.baidu.com", "https://") //true
    fmt.Printf("%v
", res)
    res = strings.HasPrefix("https://www.baidu.com", "albaba") //false
    fmt.Printf("%v
", res)

    //HasSuffix
    res = strings.HasSuffix("/root/temp/", "/") //true
    fmt.Printf("%v
", res)
    res = strings.HasSuffix("/root/temp/", "=") //false
    fmt.Printf("%v
", res)

    var result int
    //Index
    result = strings.Index("hahahelloworld", "he") //4
    fmt.Printf("%v
", result)
    
    //LastIndex
    result = strings.LastIndex("hahahelloworldhe", "he") //14
    fmt.Printf("%v
", result)

    var result2 string
    //Replace
    result2 = strings.Replace("hahahelloworldhe", "ha", "HA", 1) //HAhahelloworldhe
    fmt.Printf("%v
", result2)
    result2 = strings.Replace("hahahelloworldhe", "ha", "HA", -1) //HAHAhelloworldhe
    fmt.Printf("%v
", result2)

    //Count
    result = strings.Count("hahahelloworldhe", "ha") //2
    fmt.Printf("%v
", result)

    //Repeat
    result2 = strings.Repeat("ha", 3) //hahaha
    fmt.Printf("%v
", result2)
    
    //ToLower
    result2 = strings.ToLower("heLLo") //hello
    fmt.Printf("%v
", result2)

    //ToUpper
    result2 = strings.ToUpper("hello") //HELLO
    fmt.Printf("%v
", result2)

    //TrimSpace
    result2 = strings.TrimSpace("   hello   ") //hello
    fmt.Printf("%v
", result2)

    //Trim
    result2 = strings.Trim("123hello123", "123") //hello
    fmt.Printf("%v
", result2)

    //TrimLeft
    result2 = strings.TrimLeft("123hello123", "123") //hello123
    fmt.Printf("%v
", result2)

    //TrimRight
    result2 = strings.TrimRight("123hello123", "123") //123hello
    fmt.Printf("%v
", result2)

    var result3 []string
    //Fields
    result3 = strings.Fields("root temp work")
    for i := 0; i < len(result3); i++ {
        fmt.Printf("%v
", result3[i])
    }
    
    //Split
    result3 = strings.Split("/root/temp/work", "/")
    for i := 0; i < len(result3); i++ {
        fmt.Printf("%v
", result3[i])
    }

    //Join
    result3 = [] string{"root", "temp", "work"}
    result2 = strings.Join(result3, "/") // root/temp/work
    fmt.Println(result2)

    //Itoa
    num := 123
    result2 = strconv.Itoa(num) // root/temp/work
    fmt.Printf("%s
", result2) // 123

    //Atoi
    str := "12345"
    number, err := strconv.Atoi(str) // root/temp/work
    if err != nil {
        fmt.Printf("Can not convert %s to int
", str)
        return
    }
    fmt.Printf("%d
", number) // 12345
}

练习1：判断一个url是否以http://开头，如果不是，则加上http://。
练习2：判断一个路径是否以"/"结尾，如果不是，则加上/。

package main 

import (
    "fmt"
    "strings"
)

func urlProcess(url string) string {
    res := strings.HasPrefix(url, "http://")
    if !res {
        url = fmt.Sprintf("http://%s", url)
    }
    return url
}

func pathProcess(path string) string {
    res := strings.HasSuffix(path, "/")
    if !res {
        path = fmt.Sprintf("%s/", path)
    }
    return path
}

func main() {
    var (
        url string
        path string        
    )

    fmt.Println("Input url and path >>")
    fmt.Scanf("%s%s", &url, &path)

    url = urlProcess(url)
    path = pathProcess(path)

    fmt.Println("url: ", url)
    fmt.Println("path: ", path)
}

练习3：写一个函数返回一个字符串在另一个字符串的首次出现和最后出现位置。

package main 

import (
    "fmt"
    "strings"
)

func strIndex(str string, substr string)(int, int) {
    var startIndex, endIndex int

    startIndex = strings.Index(str, substr)
    endIndex = strings.LastIndex(str, substr)

    return startIndex, endIndex
}

func main() {
    var str, substr string
    fmt.Println("Input a string >> ")
    fmt.Scanf("%s%s", &str, &substr)

    start, end := strIndex(str, substr)
    if start < 0 {
        fmt.Printf("Can not find %s in %s.
", substr, str)
    } else {
        fmt.Printf("First find %s in %s %d index.
", substr, str, start)
    }

    if end < 0 {
        fmt.Printf("Can not find %s in %s.
", substr, str)
    } else {
        fmt.Printf("Last find %s in %s %d index.
", substr, str, end)
    }
}

练习4：写一个函数分别演示Replace、Count、Repeat、ToLower、ToUpper的用法。
练习5：写一个函数分别演示TrimSpace、Trim、TrimLeft、TrimRight、Field、Split、以及Join的用法。
练习6：写一个函数分别演示Itoa、Atoi的用法。

2. Go中的时间和日期类型

1. time包
2. time.Time类型，用来表示时间
3. 获取当前时间， now := time.Now()
4. time.Now().Day()，time.Now().Minute()，time.Now().Month()，time.Now().Year()
5. 格式化，fmt.Printf("%02d/%02d%02d %02d:%02d:%02d", now.Year()…)
6. time.Duration用来表示纳秒
7. 一些常量：
    const (
         Nanosecond Duration = 1
         Microsecond = 1000 * Nanosecond
         Millisecond = 1000 * Microsecond
         Second = 1000 * Millisecond
         Minute = 60 * Second
         Hour = 60 * Minute
    )
8. 格式化：
    now := time.Now()
    fmt.Println(now.Format(“02/1/2006 15:04”))
    fmt.Println(now.Format(“2006/1/02 15:04”))
    fmt.Println(now.Format(“2006/1/02”))

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

package main 

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now.Format("02/1/2006 15:04")) // 12/2/2019 18:13
    fmt.Println(now.Format("2006/1/02 15:04")) // 2019/2/12 18:13
    fmt.Println(now.Format("2006/1/02")) // 2019/2/12
}

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

package main 

import (
    "fmt"
    "time"
)

func costTime() {
    for i := 0; i < 100000000; i++ {

    }
}

func main() {
    start := time.Now().UnixNano() // ns
    costTime()
    end := time.Now().UnixNano()

    fmt.Printf("cost:%d us
", (end-start)/1000)
}

3. 指针类型

1. 普通类型，变量存的就是值，也叫值类型
2. 获取变量的地址，用&，比如： var a int, 获取a的地址：&a
3. 指针类型，变量存的是一个地址，这个地址存的才是值
4. 获取指针类型所指向的值，使用：*，比如：var *p int, 使用*p获取p指向的值

练习8：写一个程序，获取一个变量的地址，并打印到终端。
练习9：写一个函数，传入一个int类型的指针，并在函数中修改所指向的值。在main函数中调用这个函数，并把修改前后的值打印到终端，观察结果。

package main 

import (
    "fmt"
)

func test(num int) {
    fmt.Printf("In the test add %v
", &num)
}

func changeNum(num *int) {
    *num = 100
}

func main() {
    var num int = 10
    fmt.Printf("In the main add %v
", &num) //In the main add 0xc04203c1d0
    test(num) // In the test add 0xc04203c1d8
    fmt.Printf("num = %d
", num)  // num = 10
    changeNum(&num)
    fmt.Printf("num = %d
", num) //num = 100
}

4. 流程控制

1. If / else分支判断

单个分支

if condition1 {
}

两个分支

if condition1 {    
} else {
}

多个分支

if condition1 {
} else if condition2 {
} else if condition3 {
} else {
}

注意：下面这种写法是错误的

if condition1 {
}
else {
}

练习10：写一个程序，从终端读取输入，并转成整数，如果转成整数出错，则输出 "can not convert to int"，并返回。否则输出该整数。

package main 

import (
    "fmt"
    "strconv"
)

func main() {
    var str string
    fmt.Println("Input a number >>")
    fmt.Scanf("%s", &str)
    number, err := strconv.Atoi(str)
    if err != nil {
        fmt.Printf("Can not convert %s to int
", str)
        return
    }
    fmt.Printf("%d", number)
}

2. switch case语句
语法:
       switch var {
           case var1:
           case var2:
           case var3:
           default:
       }

特别注意：go语言中和C语言不一样，在case后面没有break语句。

switch var {
           case var1:
                {
                    语句
                    break;
                }
                
           case var2:
                {
                    语句
                    break;
                }
           case var3:
                {
                    语句
                    break;
                }
           default:
                    语句
       }

写法1：

var num int = 2
switch num {
    case 0:
        fmt.Println("0")
    case 1:
        fmt.Println("1")
    case 2:
        fmt.Println("2")
    default:
        fmt.Printf("%d
", num)
}

写法2：跨越case的fallthrough

var i = 0
switch i {
case 0:
    fmt.Println("0") // 会执行
    fallthrough
case 1:
    fmt.Println("1") // 由于上面fallthrough 所以会执行
case 2:
    fmt.Println("2")
default:
     fmt.Println("default")
}

注意：加上fallthrough则当前case语句执行完成之后会紧接着执行相邻的第一条case。

写法3：

var i = 0
switch i {
   //两个case合并
    case 0, 1:
        fmt.Println("0 or 1")
    case 2:
        fmt.Println("2")
    default:
        fmt.Println("def")
}

写法4：

var i = 0
switch {
    case i > 0 && i < 10:
        fmt.Println("i > 0 and i < 10")
    case i >= 10 && i < 20:
        fmt.Println("i > 10 and i < 20")
    default:
        fmt.Println("default")
}

写法5：

switch i := 15; {
    case i > 0 && i < 10:
        fmt.Println("i > 0 and i < 10")
    case i >= 10 && i < 20:
        fmt.Println("i > 10 and i < 20")
    default:
        fmt.Println("def")
}

注意： i := 15; 后面的分号(;)

 练习11：猜数字，写一个程序，随机生成一个0到100的整数n，然后用户在终端，输入数字，如果和n相等，则提示用户猜对了。如果不相等，则提示用户，大于或小于n。

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    var n int
    n = rand.Intn(100)

    for {
        var input int
        fmt.Println("Input your guess >> ")
        //注意后面的
作用，如果没有的话，则输入的数和
        fmt.Scanf("%d
", &input)
        flag := false
        switch {
        case input == n:
            fmt.Println("you are right")
            flag = true
        case input > n:
            fmt.Println("bigger")
        case input < n:
            fmt.Println("less")
        }

        if flag {
            break
        }
    }
}

3. for 语句

写法1：

for 初始化语句; 条件判断; 变量修改 {
}
//例如
for i := 0; i < 100; i++ {
    fmt.Printf("i=%d
", i)
}

练习12：写一个程序，在终端打印如下图形。

A
AA
AAA
AAAA
AAAAA

package main 

import (
    "fmt"
)

func main() {
    var row int
    fmt.Println("Input row number >>")
    fmt.Scanf("%d", &row)
    for i := 0; i < row; i++ {
        for j := 0; j <= i; j++ {
            fmt.Printf("A")
        }
        fmt.Println()
    }
}

写法2：

for  条件 {
}

例如：下面三个条件为真都是死循环

for i > 0 {
    fmt.Println("i > 0")
}

for true {
    fmt.Println("i > 0")
}

for {
    fmt.Println("i > 0")
}

4. for range 语句

写法3：用来遍历数组、slice、map、chan

str := "hello world,中国" //汉字占3个字节
    for i, v := range str {
        fmt.Printf("index = %d val = %c byteLen = %d
", i, v, len([] byte(string(v))))
    }

5. break、continue语句

package main

import "fmt"

func main() {
    str := "hello world,中国"
    for i, v := range str {
        if i > 2 {
            continue
        }
        if (i > 3) {
            break  
        }
    
        fmt.Printf("index[%d] val[%c] len[%d]
", i, v, len([]byte(string(v))))
    }
}

//输出：
//index[0] val[h] len[1]
//index[1] val[e] len[1]
//index[2] val[l] len[1]

break 语句可以结束 for、switch 和 select 的代码块。break 语句还可以在语句后面添加标签，表示退出某个标签对应的代码块，标签要求必须定义在对应的 for、switch 和 select 的代码块上。例如：

package main
import "fmt"
func main() {
OuterLoop:
    for i := 0; i < 2; i++ {
        for j := 0; j < 5; j++ {
            switch j {
            case 2:
                fmt.Println(i, j)
                break OuterLoop
            case 3:
                fmt.Println(i, j)
                break OuterLoop
            }
        }
    }
}

//输出 说明第10行的break OuterLoop直接跳出外层循环
//0 2

continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用。在 continue 语句后添加标签时，表示开始标签对应的循环。例如：

package main
import "fmt"
func main() {
OuterLoop: //代码说明：第 10 行将结束当前循环，开启下一次的外层循环，而不是第 10 行的内循环。
    for i := 0; i < 2; i++ {
        for j := 0; j < 5; j++ {
            switch j {
            case 2:
                fmt.Println(i, j)
                continue OuterLoop
            }
        }
    }
}

//输出：
//0 2
//1 2

6. goto 和 label 语句

goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go 语言中使用 goto 语句能简化一些代码的实现过程。

package main

func main() {
    i := 0
HERE:
    print(i)
    i++
    if i == 5 {
        return
    }
    goto HERE
}

//输出：
//01234

 5. 函数

1. 声明语法：func 函数名 (参数列表) [(返回值列表)] {}

//无参数，无返回值
func add() {
}

//有参数，无返回值
func add(a int, b int) {
}

//有参数，一个返回值
func add(a int, b int) int {
}

//有参数，两个返回值
func add(a int, b int) (int, int) {
}

//有参数，两个返回值
func add(a, b int) (int, int) {
}

2. golang函数特点：
    a. 不支持重载，一个包不能有两个名字一样的函数
    b. 函数是一等公民，函数也是一种类型，一个函数可以赋值给变量

package main

import "fmt"

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

func main() {
    c := add  //将函数add的地址赋值给变量c
    fmt.Println(c) //0x4888e0

    sum := c(10, 20)
    fmt.Println(sum)
    // if (c == add) {  //invalid operation: c == add (func can only be compared to nil)
    //     fmt.Println("c equal add")
    // }
}

    c. 匿名函数

package main

import "fmt"

var (
    //add存放的是匿名函数的地址
    add = func(a int, b int) int {
        return a + b
    }
    
    //sub_res存放的是匿名函数执行的结果100
    sub_res = func(a int, b int) int {
        return a - b
    }(200, 100) 
)

func test(a, b int) int {
    //mult存放的是匿名函数的地址
    mult := func(m int, n int) int {
        return m*n
    }
    return mult(a, b)
}

func main() {
    fmt.Println(add(100, 200))  //300
    fmt.Println(sub_res)  //100
        fmt.Println(test(200, 300))  //60000
}

    d. 多返回值

使用type定义函数类型： type type_name func 函数名 (参数列表) [(返回值列表)]，例如：

package main

import "fmt"

//定义函数类型
type add_func func(int, int) int

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

// error 因为上面定义的函数类型add_func接收两个参数，下面定义三个参数。
// func add(a, b, c int) int {
//     return a + b
// }

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

func operator(op add_func, a int, b int) int {
    return op(a, b)
}

func main() {
    c := add
    fmt.Println(c)
    sum := operator(c, 100, 200)
    fmt.Println(sum)  //300

    res := operator(sub, 100, 200)
    fmt.Println(res)  //-100
}

3. 函数参数传递方式：
    1). 值传递
    2). 引用传递
    注意1：无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。引用传递是地址的拷贝，一般来说，地址拷贝更为高效。而值拷贝取决                   于拷贝的对象大小，对象越大，则性能越低。
    注意2：map、slice、chan、指针、interface默认以引用的方式传递。

4. 命名返回值的名字

package main 

import "fmt"

func add(a, b int) (sum int) {
    sum = a + b
    return
}

// 等价于
// func add(a, b int) int {
//     sum = a + b
//     return sum
// }

func calc(a, b int) (sum int, avg int) {
    sum = a + b
    avg = (a +b)/2
    return
}

// 等价于
// func calc(a, b int) (int, int) {
//     sum = a + b
//     avg = (a +b)/2
//     return sum, avg
// }


func main() {
    add_res := add(100, 200)
    fmt.Println(add_res) //300
    sum, avg := calc(100, 200)
        fmt.Println(sum) //300
        fmt.Println(avg) //150
}

5. _标识符，用来忽略返回值

package main 

import "fmt"

func calc(a, b int) (sum int, avg int) {
    sum = a + b
    avg = (a +b)/2
    return
}

func main() {
    sum, _ := calc(100, 200)
    fmt.Println(sum) //300
}

6. 可变参数

注意：其中arg是一个slice，通过len(arg)来判断传递参数的个数，通过arg[index]依次访问所有参数。

//0个或多个参数
func add(arg…int) int {
}

//1个或多个参数
func add(a int, arg…int) int {
}

//2个或多个参数
func add(a int, b int, arg…int) int {
}

练习14：写一个函数add，支持1个或多个int相加，并返回相加结果。
练习15：写一个函数concat，支持1个或多个string相拼接，并返回结果。

package main

import "fmt"

func add(a int, arg ...int) int {
    var sum int = a
    for i := 0; i < len(arg); i++ {
        sum += arg[i]
    }

    return sum
}

func concat(a string, arg ...string) (result string) {
    result = a
    for i := 0; i < len(arg); i++ {
        result += arg[i]
    }

    return
}

func main() {
    sum := add(10, 3, 3, 3, 3)
    fmt.Println(sum) //22

    res := concat("hello", " ", "world")
    fmt.Println(res) //hello world
}

7. defer用途
    1）. 当函数返回时，执行defer语句。因此，可以用来做资源清理。
    2）. 多个defer语句，按先进后出的方式执行。
    3）. defer语句中的变量，在defer声明时就决定了。

package main 

import "fmt"

func test() {
    i := 0
    defer fmt.Println(i)
    i++
    return
} 

func main() {
    test() // 0
}

package main 

import "fmt"

 func test() {
    for i := 0; i < 5; i++ {
        defer fmt.Printf("%d ", i)
    } 
} 


func main() {
    test() // 4 3 2 1 0
}

defer几个常用用途：

(1). 关闭文件句柄

func read() {
    file := open(filename)
    defer file.Close()
    
    //文件操作
}

(2). 锁资源释放

func read() {
    mc.Lock()
    defer mc.Unlock()
    //其他操作
}

(3). 数据库连接释放

func read() {
    conn := openDatabase()
    defer conn.Close()
    //其他操作
}

练习：

1.编写程序，在终端输出九九乘法表。

package main 

import "fmt"

func mutil() {
    for i := 1; i <= 9; i++ {
        for j := 1; j <= i; j++ {
            fmt.Printf("%d*%d=%d	", i, j, i*j)
        }
        fmt.Printf("
")
    }
}

func main() {
    mutil()
}

2.一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3编程找出1000以内的所有完数。

package main 

import "fmt"

func isPerfNum(num int) bool {
    res := 0
    for i := 1; i < num; i++ {
        if num % i == 0 {
            res += i
        }
    }

    return res == num
}

func process(n int) {
    for i := 1; i <= n; i++ {
        if isPerfNum(i) {
            fmt.Println(i)
        } 
    }
}

func main() {
    var num int
    fmt.Println("Input a number >> ")
    fmt.Scanf("%d", &num)
    process(num)
}

3.输入一个字符串，判断其是否为回文。回文字符串是指从左到右读和从右到左读完全相同的字符串。

package main 

import (
    "fmt"
)

func isPalindNum(str string) bool {
    flag := true
    for i := 0; i <= int(len(str)/2); i++ {
        if str[i] != str[len(str)-i-1] {
            flag = false
            break
        }
    }

    return flag
}

func main() {
    var str string
    fmt.Println("Input a string >> ")
    fmt.Scanf("%s", &str)
    if isPalindNum(str) {
        fmt.Printf("%s is a palindrome number.", str)
    }
}

package main 

import (
    "fmt"
)

func isPalindNum(str string) bool {
    temp := [] rune(str) //注意这块的处理
    flag := true
    for i := 0; i <= int(len(temp)/2); i++ {
        if temp[i] != temp[len(temp)-i-1] {
            flag = false
            break
        }
    }

    return flag
}

func main() {
    var str string
    fmt.Println("Input a string >> ")
    fmt.Scanf("%s", &str)
    if isPalindNum(str) {
        fmt.Printf("%s is a palindrome number.", str)
    }
}

4.输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

package main 

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

func count(str string) (charCount, spaceCount, numberCount, otherCount int) {
    t := [] rune(str)
    for _, v := range t {
        switch {
            case v >= 'A' && v <= 'Z':
                fallthrough
            case v >= 'a' && v <= 'z':
                charCount++
            case v == ' ':
                spaceCount++
            case v >= '0' && v <= '9':
                numberCount++
            default:
                otherCount++
        }
    }
    return
}


func main() {
    reader := bufio.NewReader(os.Stdin)
    result, _, err := reader.ReadLine()
    if err != nil {
        fmt.Println("read from console err:", err)
        return
    }
    cc, sc, nc, oc := count(string(result)) //注意：result为type []byte，因此需要强制转换为string类型
    fmt.Printf("charCount = %d, spaceCount = %d, numberCount = %d, otherCount = %d", cc, sc, nc, oc)
}

5. 计算两个大数相加的和，这两个大数会超过int64的表示范围。

package main 

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

func add(str1, str2 string) (result string) {
    var left int = 0  //进位

    if len(str1) == 0 || len(str2) == 0 {
        result = "0"
        return
    }

    index1 := len(str1) - 1
    index2 := len(str2) - 1
    //处理重合部分
    for index1 >= 0 && index2 >= 0 {
        c1 := str1[index1] - '0'
        c2 := str2[index2] - '0'

        sum := int(c1) + int(c2) + left
        if sum >= 10 {
            left = 1
        } else {
            left = 0
        }

        c3 := (sum%10) + '0'
        result = fmt.Sprintf("%c%s", c3, result)

        index1--
        index2--
    }

    //处理str1长度大于str2情况
    for index1 >= 0 {
        c1 := str1[index1] - '0'

        sum := int(c1) + left
        if sum >= 10 {
            left = 1
        } else {
            left = 0
        }

        c3 := (sum%10) + '0'
        result = fmt.Sprintf("%c%s", c3, result)

        index1--
    }

    //处理str1长度小于str2情况
    for index2 >= 0 {
        c2 := str2[index2] - '0'

        sum := int(c2) + left
        if sum >= 10 {
            left = 1
        } else {
            left = 0
        }

        c3 := (sum%10) + '0'
        result = fmt.Sprintf("%c%s", c3, result)

        index2--
    }

    //处理str1长度等于str2情况
    if left == 1 {
        result = fmt.Sprintf("1%s", result)
    }
    return
}

func main() {
    fmt.Println("please input a+b >>")
    //从console端读取数据
    reader := bufio.NewReader(os.Stdin)
    result, _, err := reader.ReadLine()
    if err != nil {
        fmt.Println("read from console err:", err)
        return
    }
    
    //获取加数与被加数
    strSlice := strings.Split(string(result), "+")
    if len(strSlice) != 2 {
        fmt.Println("please input a+b")
        return
    }

    //去除左右空格
    str1 := strings.TrimSpace(strSlice[0])
    str2 := strings.TrimSpace(strSlice[1])
    fmt.Println(add(str1, str2))
}

补充：rune数据类型

例1：

package main

import "fmt"

func main() {

    var str = "hello 你好"
    fmt.Println("len(str):", len(str)) //len(str): 12
}

为何输出12？

golang中string底层是通过byte数组实现的。中文字符在unicode下占2个字节，在utf-8编码下占3个字节，而golang默认编码是utf-8。因此输出12。

例2：

package main

import "fmt"

func main() {

    var str = "hello 你好"
    fmt.Println("len(str):", len(str)) //len(str): 12

    temp := [] rune(str)
    fmt.Println("len(temp):", len(temp)) //len(temp): 8
}

现在来看rune数据类型官方解释：

 rune is an alias for int32 and is equivalent to int32 in all ways. It is used, by convention, to distinguish character values from integer values.

rune是int32的别名，几乎在所有方面等同于int32，它用来区分字符值和整数值。type rune = int32。

如果我们预期想得到一个字符串的长度，而不是字符串底层占得字节长度，该怎么办？

例3：

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {

    var str = "hello 你好"
    // 方法1：
    //golang中的unicode/utf8包提供了用utf-8获取长度的方法
    fmt.Println("RuneCountInString:", utf8.RuneCountInString(str))  //RuneCountInString: 8

    //方法2：
    //通过rune类型处理unicode字符
    temp := [] rune(str)
    fmt.Println("rune:", len(temp))  //rune: 8
}

例4：

package main

import (
    "fmt"
)

func main() {

    var str = "hello 你好"
    for i := 0; i < len(str); i++ {
        fmt.Println(str[i])
    }

    fmt.Println("--------")

    temp := [] rune(str)
    for i := 0; i < len(temp); i++ {
        fmt.Println(temp[i])
    }
}

//输出结果
// 104
// 101
// 108
// 108
// 111
// 32
// 228
// 189
// 160
// 229
// 165
// 189
// --------
// 104
// 101
// 108
// 108
// 111
// 32
// 20320
// 22909

总结：

golang中一个byte数据类型与rune相似，它们都是用来表示字符类型的变量类型。它们的不同在于：
(1). byte 等同于int8，常用来处理ascii字符。
(2). rune 等同于int32,常用来处理unicode或utf-8字符。

参考文献：

• https://www.jianshu.com/p/4fbf529926ca