Go语言学习之3 流程控制、函数
生活随笔
收集整理的這篇文章主要介紹了
Go语言学习之3 流程控制、函数
小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.
主要內容：
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中首次出現(xiàn)的位置，如果沒有 4. strings.LastIndex(s string, str string) int：判斷str在s中最后出現(xiàn)的位置，如果沒有 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空格分隔的所有子串的slicestrings.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)：把一個字符串轉成整數例子：
1 package main 2 3 import ( 4 "fmt" 5 "strings" 6 "strconv" 7 ) 8 9 func main() { 10 var res bool 11 //HasPrefix 12 res = strings.HasPrefix("https://www.baidu.com", "https://") //true 13 fmt.Printf("%v\n", res) 14 res = strings.HasPrefix("https://www.baidu.com", "albaba") //false 15 fmt.Printf("%v\n", res) 16 17 //HasSuffix 18 res = strings.HasSuffix("/root/temp/", "/") //true 19 fmt.Printf("%v\n", res) 20 res = strings.HasSuffix("/root/temp/", "=") //false 21 fmt.Printf("%v\n", res) 22 23 var result int 24 //Index 25 result = strings.Index("hahahelloworld", "he") //4 26 fmt.Printf("%v\n", result) 27 28 //LastIndex 29 result = strings.LastIndex("hahahelloworldhe", "he") //14 30 fmt.Printf("%v\n", result) 31 32 var result2 string 33 //Replace 34 result2 = strings.Replace("hahahelloworldhe", "ha", "HA", 1) //HAhahelloworldhe 35 fmt.Printf("%v\n", result2) 36 result2 = strings.Replace("hahahelloworldhe", "ha", "HA", -1) //HAHAhelloworldhe 37 fmt.Printf("%v\n", result2) 38 39 //Count 40 result = strings.Count("hahahelloworldhe", "ha") //2 41 fmt.Printf("%v\n", result) 42 43 //Repeat 44 result2 = strings.Repeat("ha", 3) //hahaha 45 fmt.Printf("%v\n", result2) 46 47 //ToLower 48 result2 = strings.ToLower("heLLo") //hello 49 fmt.Printf("%v\n", result2) 50 51 //ToUpper 52 result2 = strings.ToUpper("hello") //HELLO 53 fmt.Printf("%v\n", result2) 54 55 //TrimSpace 56 result2 = strings.TrimSpace(" hello ") //hello 57 fmt.Printf("%v\n", result2) 58 59 //Trim 60 result2 = strings.Trim("123hello123", "123") //hello 61 fmt.Printf("%v\n", result2) 62 63 //TrimLeft 64 result2 = strings.TrimLeft("123hello123", "123") //hello123 65 fmt.Printf("%v\n", result2) 66 67 //TrimRight 68 result2 = strings.TrimRight("123hello123", "123") //123hello 69 fmt.Printf("%v\n", result2) 70 71 var result3 []string 72 //Fields 73 result3 = strings.Fields("root temp work") 74 for i := 0; i < len(result3); i++ { 75 fmt.Printf("%v\n", result3[i]) 76 } 77 78 //Split 79 result3 = strings.Split("/root/temp/work", "/") 80 for i := 0; i < len(result3); i++ { 81 fmt.Printf("%v\n", result3[i]) 82 } 83 84 //Join 85 result3 = [] string{"root", "temp", "work"} 86 result2 = strings.Join(result3, "/") // root/temp/work 87 fmt.Println(result2) 88 89 //Itoa 90 num := 123 91 result2 = strconv.Itoa(num) // root/temp/work 92 fmt.Printf("%s\n", result2) // 123 93 94 //Atoi 95 str := "12345" 96 number, err := strconv.Atoi(str) // root/temp/work 97 if err != nil { 98 fmt.Printf("Can not convert %s to int\n", str) 99 return 100 } 101 fmt.Printf("%d\n", number) // 12345 102 } example練習1：判斷一個url是否以http://開頭，如果不是，則加上http://。
練習2：判斷一個路徑是否以"/"結尾，如果不是，則加上/。
練習3：寫一個函數返回一個字符串在另一個字符串的首次出現(xiàn)和最后出現(xiàn)位置。
1 package main 2 3 import ( 4 "fmt" 5 "strings" 6 ) 7 8 func strIndex(str string, substr string)(int, int) { 9 var startIndex, endIndex int 10 11 startIndex = strings.Index(str, substr) 12 endIndex = strings.LastIndex(str, substr) 13 14 return startIndex, endIndex 15 } 16 17 func main() { 18 var str, substr string 19 fmt.Println("Input a string >> ") 20 fmt.Scanf("%s%s", &str, &substr) 21 22 start, end := strIndex(str, substr) 23 if start < 0 { 24 fmt.Printf("Can not find %s in %s.\n", substr, str) 25 } else { 26 fmt.Printf("First find %s in %s %d index.\n", substr, str, start) 27 } 28 29 if end < 0 { 30 fmt.Printf("Can not find %s in %s.\n", substr, str) 31 } else { 32 fmt.Printf("Last find %s in %s %d index.\n", substr, str, end) 33 } 34 } 練習3練習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形式。
1 package main 2 3 import ( 4 "fmt" 5 "time" 6 ) 7 8 func main() { 9 now := time.Now() 10 fmt.Println(now.Format("02/1/2006 15:04")) // 12/2/2019 18:13 11 fmt.Println(now.Format("2006/1/02 15:04")) // 2019/2/12 18:13 12 fmt.Println(now.Format("2006/1/02")) // 2019/2/12 13 } 練習6練習7：寫一個程序，統(tǒng)計一段代碼的執(zhí)行耗時，單位精確到微秒。
1 package main 2 3 import ( 4 "fmt" 5 "time" 6 ) 7 8 func costTime() { 9 for i := 0; i < 100000000; i++ { 10 11 } 12 } 13 14 func main() { 15 start := time.Now().UnixNano() // ns 16 costTime() 17 end := time.Now().UnixNano() 18 19 fmt.Printf("cost:%d us\n", (end-start)/1000) 20 } 練習73. 指針類型
1. 普通類型，變量存的就是值，也叫值類型
2. 獲取變量的地址，用&，比如： var a int, 獲取a的地址：&a
3. 指針類型，變量存的是一個地址，這個地址存的才是值
4. 獲取指針類型所指向的值，使用：*，比如：var *p int, 使用*p獲取p指向的值
練習8：寫一個程序，獲取一個變量的地址，并打印到終端。
練習9：寫一個函數，傳入一個int類型的指針，并在函數中修改所指向的值。在main函數中調用這個函數，并把修改前后的值打印到終端，觀察結果。
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"，并返回。否則輸出該整數。
1 package main 2 3 import ( 4 "fmt" 5 "strconv" 6 ) 7 8 func main() { 9 var str string 10 fmt.Println("Input a number >>") 11 fmt.Scanf("%s", &str) 12 number, err := strconv.Atoi(str) 13 if err != nil { 14 fmt.Printf("Can not convert %s to int\n", str) 15 return 16 } 17 fmt.Printf("%d", number) 18 } 練習102. switch case語句
語法:
? ? ? ?switch var {
? ? ? ? ? ?case var1:
? ? ? ? ? ?case var2:
? ? ? ? ? ?case var3:
? ? ? ? ? ?default:
? ? ? ?}
特別注意：go語言中和C語言不一樣，在case后面沒有break語句。
1 switch var { 2 case var1: 3 { 4 語句 5 break; 6 } 7 8 case var2: 9 { 10 語句 11 break; 12 } 13 case var3: 14 { 15 語句 16 break; 17 } 18 default: 19 語句 20 } C語言寫法寫法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\n", num) }寫法2：跨越case的fallthrough
var i = 0 switch i { case 0:fmt.Println("0") // 會執(zhí)行 fallthrough case 1:fmt.Println("1") // 由于上面fallthrough 所以會執(zhí)行 case 2:fmt.Println("2") default:fmt.Println("default") }注意：加上fallthrough則當前case語句執(zhí)行完成之后會緊接著執(zhí)行相鄰的第一條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。
1 package main 2 3 import ( 4 "fmt" 5 "math/rand" 6 ) 7 8 func main() { 9 var n int 10 n = rand.Intn(100) 11 12 for { 13 var input int 14 fmt.Println("Input your guess >> ") 15 //注意后面的\n作用，如果沒有的話，則輸入的數和 16 fmt.Scanf("%d\n", &input) 17 flag := false 18 switch { 19 case input == n: 20 fmt.Println("you are right") 21 flag = true 22 case input > n: 23 fmt.Println("bigger") 24 case input < n: 25 fmt.Println("less") 26 } 27 28 if flag { 29 break 30 } 31 } 32 } 練習113. for 語句
寫法1：
for 初始化語句; 條件判斷; 變量修改 { } //例如 for i := 0; i < 100; i++ {fmt.Printf("i=%d\n", i) }練習12：寫一個程序，在終端打印如下圖形。
A AA AAA AAAA AAAAA 1 package main 2 3 import ( 4 "fmt" 5 ) 6 7 func main() { 8 var row int 9 fmt.Println("Input row number >>") 10 fmt.Scanf("%d", &row) 11 for i := 0; i < row; i++ { 12 for j := 0; j <= i; j++ { 13 fmt.Printf("A") 14 } 15 fmt.Println() 16 } 17 } 練習12寫法2：
for 條件 { }例如：下面三個條件為真都是死循環(huán)
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個字節(jié)for i, v := range str {fmt.Printf("index = %d val = %c byteLen = %d\n", i, v, len([] byte(string(v))))}5.?break、continue語句
package mainimport "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]\n", 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 OuterLoopcase 3:fmt.Println(i, j)break OuterLoop}}} }//輸出 說明第10行的break OuterLoop直接跳出外層循環(huán) //0 2continue 語句可以結束當前循環(huán)，開始下一次的循環(huán)迭代過程，僅限在 for 循環(huán)內使用。在 continue 語句后添加標簽時，表示開始標簽對應的循環(huán)。例如：
package main import "fmt" func main() { OuterLoop: //代碼說明：第 10 行將結束當前循環(huán)，開啟下一次的外層循環(huán)，而不是第 10 行的內循環(huán)。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 26.?goto 和 label 語句
goto 語句通過標簽進行代碼間的無條件跳轉。goto 語句可以在快速跳出循環(huán)、避免重復退出上有一定的幫助。Go 語言中使用 goto 語句能簡化一些代碼的實現(xiàn)過程。
package mainfunc 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. 函數是一等公民，函數也是一種類型，一個函數可以賦值給變量
? ? c. 匿名函數
1 package main 2 3 import "fmt" 4 5 var ( 6 //add存放的是匿名函數的地址 7 add = func(a int, b int) int { 8 return a + b 9 } 10 11 //sub_res存放的是匿名函數執(zhí)行的結果100 12 sub_res = func(a int, b int) int { 13 return a - b 14 }(200, 100) 15 ) 16 17 func test(a, b int) int { 18 //mult存放的是匿名函數的地址 19 mult := func(m int, n int) int { 20 return m*n 21 } 22 return mult(a, b) 23 } 24 25 func main() { 26 fmt.Println(add(100, 200)) //300 27 fmt.Println(sub_res) //100 28 fmt.Println(test(200, 300)) //60000 29 } 匿名函數? ? d. 多返回值
使用type定義函數類型：?type type_name func 函數名 (參數列表) [(返回值列表)]，例如：
1 package main 2 3 import "fmt" 4 5 //定義函數類型 6 type add_func func(int, int) int 7 8 func add(a, b int) int { 9 return a + b 10 } 11 12 // error 因為上面定義的函數類型add_func接收兩個參數，下面定義三個參數。 13 // func add(a, b, c int) int { 14 // return a + b 15 // } 16 17 func sub(a, b int) int { 18 return a - b 19 } 20 21 func operator(op add_func, a int, b int) int { 22 return op(a, b) 23 } 24 25 func main() { 26 c := add 27 fmt.Println(c) 28 sum := operator(c, 100, 200) 29 fmt.Println(sum) //300 30 31 res := operator(sub, 100, 200) 32 fmt.Println(res) //-100 33 } 定義函數類型3. 函數參數傳遞方式：
? ? 1). 值傳遞
? ? 2). 引用傳遞
? ? 注意1：無論是值傳遞，還是引用傳遞，傳遞給函數的都是變量的副本，不過，值傳遞是值的拷貝。引用傳遞是地址的拷貝，一般來說，地址拷貝更為高效。而值拷貝取決? ? ? ? ? ? ? ? ? ?于拷貝的對象大小，對象越大，則性能越低。
? ? 注意2：map、slice、chan、指針、interface默認以引用的方式傳遞。
4. 命名返回值的名字
1 package main 2 3 import "fmt" 4 5 func add(a, b int) (sum int) { 6 sum = a + b 7 return 8 } 9 10 // 等價于 11 // func add(a, b int) int { 12 // sum = a + b 13 // return sum 14 // } 15 16 func calc(a, b int) (sum int, avg int) { 17 sum = a + b 18 avg = (a +b)/2 19 return 20 } 21 22 // 等價于 23 // func calc(a, b int) (int, int) { 24 // sum = a + b 25 // avg = (a +b)/2 26 // return sum, avg 27 // } 28 29 30 func main() { 31 add_res := add(100, 200) 32 fmt.Println(add_res) //300 33 sum, avg := calc(100, 200) 34 fmt.Println(sum) //300 35 fmt.Println(avg) //150 36 } 命名返回值的名字5. _標識符，用來忽略返回值
1 package main 2 3 import "fmt" 4 5 func calc(a, b int) (sum int, avg int) { 6 sum = a + b 7 avg = (a +b)/2 8 return 9 } 10 11 func main() { 12 sum, _ := calc(100, 200) 13 fmt.Println(sum) //300 14 } 忽略返回值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相拼接，并返回結果。
7. defer用途
? ? 1）. 當函數返回時，執(zhí)行defer語句。因此，可以用來做資源清理。
? ? 2）. 多個defer語句，按先進后出的方式執(zhí)行。
? ? 3）. defer語句中的變量，在defer聲明時就決定了。
defer幾個常用用途：
(1). 關閉文件句柄
1 func read() { 2 file := open(filename) 3 defer file.Close() 4 5 //文件操作 6 } 關閉文件句柄(2). 鎖資源釋放
1 func read() { 2 mc.Lock() 3 defer mc.Unlock() 4 //其他操作 5 } 鎖資源釋放(3). 數據庫連接釋放
1 func read() { 2 conn := openDatabase() 3 defer conn.Close() 4 //其他操作 5 } 數據庫連接釋放練習：
1.編寫程序，在終端輸出九九乘法表。
1 package main 2 3 import "fmt" 4 5 func mutil() { 6 for i := 1; i <= 9; i++ { 7 for j := 1; j <= i; j++ { 8 fmt.Printf("%d*%d=%d\t", i, j, i*j) 9 } 10 fmt.Printf("\n") 11 } 12 } 13 14 func main() { 15 mutil() 16 } 練習12.一個數如果恰好等于它的因子之和，這個數就稱為“完數”。例如6=1＋2＋3編程找出1000以內的所有完數。
1 package main 2 3 import "fmt" 4 5 func isPerfNum(num int) bool { 6 res := 0 7 for i := 1; i < num; i++ { 8 if num % i == 0 { 9 res += i 10 } 11 } 12 13 return res == num 14 } 15 16 func process(n int) { 17 for i := 1; i <= n; i++ { 18 if isPerfNum(i) { 19 fmt.Println(i) 20 } 21 } 22 } 23 24 func main() { 25 var num int 26 fmt.Println("Input a number >> ") 27 fmt.Scanf("%d", &num) 28 process(num) 29 } 練習23.輸入一個字符串，判斷其是否為回文。回文字符串是指從左到右讀和從右到左讀完全相同的字符串。
1 package main 2 3 import ( 4 "fmt" 5 ) 6 7 func isPalindNum(str string) bool { 8 flag := true 9 for i := 0; i <= int(len(str)/2); i++ { 10 if str[i] != str[len(str)-i-1] { 11 flag = false 12 break 13 } 14 } 15 16 return flag 17 } 18 19 func main() { 20 var str string 21 fmt.Println("Input a string >> ") 22 fmt.Scanf("%s", &str) 23 if isPalindNum(str) { 24 fmt.Printf("%s is a palindrome number.", str) 25 } 26 } 練習3 V1(無法處理漢字回文數) 1 package main 2 3 import ( 4 "fmt" 5 ) 6 7 func isPalindNum(str string) bool { 8 temp := [] rune(str) //注意這塊的處理 9 flag := true 10 for i := 0; i <= int(len(temp)/2); i++ { 11 if temp[i] != temp[len(temp)-i-1] { 12 flag = false 13 break 14 } 15 } 16 17 return flag 18 } 19 20 func main() { 21 var str string 22 fmt.Println("Input a string >> ") 23 fmt.Scanf("%s", &str) 24 if isPalindNum(str) { 25 fmt.Printf("%s is a palindrome number.", str) 26 } 27 } 練習3 V2(完整版)4.輸入一行字符，分別統(tǒng)計出其中英文字母、空格、數字和其它字符的個數。
1 package main 2 3 import ( 4 "fmt" 5 "os" 6 "bufio" 7 ) 8 9 func count(str string) (charCount, spaceCount, numberCount, otherCount int) { 10 t := [] rune(str) 11 for _, v := range t { 12 switch { 13 case v >= 'A' && v <= 'Z': 14 fallthrough 15 case v >= 'a' && v <= 'z': 16 charCount++ 17 case v == ' ': 18 spaceCount++ 19 case v >= '0' && v <= '9': 20 numberCount++ 21 default: 22 otherCount++ 23 } 24 } 25 return 26 } 27 28 29 func main() { 30 reader := bufio.NewReader(os.Stdin) 31 result, _, err := reader.ReadLine() 32 if err != nil { 33 fmt.Println("read from console err:", err) 34 return 35 } 36 cc, sc, nc, oc := count(string(result)) //注意：result為type []byte，因此需要強制轉換為string類型 37 fmt.Printf("charCount = %d, spaceCount = %d, numberCount = %d, otherCount = %d", cc, sc, nc, oc) 38 } 練習45. 計算兩個大數相加的和，這兩個大數會超過int64的表示范圍。
1 package main 2 3 import ( 4 "fmt" 5 "os" 6 "bufio" 7 "strings" 8 ) 9 10 func add(str1, str2 string) (result string) { 11 var left int = 0 //進位 12 13 if len(str1) == 0 || len(str2) == 0 { 14 result = "0" 15 return 16 } 17 18 index1 := len(str1) - 1 19 index2 := len(str2) - 1 20 //處理重合部分 21 for index1 >= 0 && index2 >= 0 { 22 c1 := str1[index1] - '0' 23 c2 := str2[index2] - '0' 24 25 sum := int(c1) + int(c2) + left 26 if sum >= 10 { 27 left = 1 28 } else { 29 left = 0 30 } 31 32 c3 := (sum%10) + '0' 33 result = fmt.Sprintf("%c%s", c3, result) 34 35 index1-- 36 index2-- 37 } 38 39 //處理str1長度大于str2情況 40 for index1 >= 0 { 41 c1 := str1[index1] - '0' 42 43 sum := int(c1) + left 44 if sum >= 10 { 45 left = 1 46 } else { 47 left = 0 48 } 49 50 c3 := (sum%10) + '0' 51 result = fmt.Sprintf("%c%s", c3, result) 52 53 index1-- 54 } 55 56 //處理str1長度小于str2情況 57 for index2 >= 0 { 58 c2 := str2[index2] - '0' 59 60 sum := int(c2) + left 61 if sum >= 10 { 62 left = 1 63 } else { 64 left = 0 65 } 66 67 c3 := (sum%10) + '0' 68 result = fmt.Sprintf("%c%s", c3, result) 69 70 index2-- 71 } 72 73 //處理str1長度等于str2情況 74 if left == 1 { 75 result = fmt.Sprintf("1%s", result) 76 } 77 return 78 } 79 80 func main() { 81 fmt.Println("please input a+b >>") 82 //從console端讀取數據 83 reader := bufio.NewReader(os.Stdin) 84 result, _, err := reader.ReadLine() 85 if err != nil { 86 fmt.Println("read from console err:", err) 87 return 88 } 89 90 //獲取加數與被加數 91 strSlice := strings.Split(string(result), "+") 92 if len(strSlice) != 2 { 93 fmt.Println("please input a+b") 94 return 95 } 96 97 //去除左右空格 98 str1 := strings.TrimSpace(strSlice[0]) 99 str2 := strings.TrimSpace(strSlice[1]) 100 fmt.Println(add(str1, str2)) 101 } 練習5補充：rune數據類型
例1：
1 package main 2 3 import "fmt" 4 5 func main() { 6 7 var str = "hello 你好" 8 fmt.Println("len(str):", len(str)) //len(str): 12 9 } example為何輸出12？
golang中string底層是通過byte數組實現(xiàn)的。中文字符在unicode下占2個字節(jié)，在utf-8編碼下占3個字節(jié)，而golang默認編碼是utf-8。因此輸出12。
例2：
1 package main 2 3 import "fmt" 4 5 func main() { 6 7 var str = "hello 你好" 8 fmt.Println("len(str):", len(str)) //len(str): 12 9 10 temp := [] rune(str) 11 fmt.Println("len(temp):", len(temp)) //len(temp): 8 12 } example2現(xiàn)在來看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，它用來區(qū)分字符值和整數值。type rune = int32。
如果我們預期想得到一個字符串的長度，而不是字符串底層占得字節(jié)長度，該怎么辦？
例3：
1 package main 2 3 import ( 4 "fmt" 5 "unicode/utf8" 6 ) 7 8 func main() { 9 10 var str = "hello 你好" 11 // 方法1： 12 //golang中的unicode/utf8包提供了用utf-8獲取長度的方法 13 fmt.Println("RuneCountInString:", utf8.RuneCountInString(str)) //RuneCountInString: 8 14 15 //方法2： 16 //通過rune類型處理unicode字符 17 temp := [] rune(str) 18 fmt.Println("rune:", len(temp)) //rune: 8 19 } example3例4：
1 package main 2 3 import ( 4 "fmt" 5 ) 6 7 func main() { 8 9 var str = "hello 你好" 10 for i := 0; i < len(str); i++ { 11 fmt.Println(str[i]) 12 } 13 14 fmt.Println("--------") 15 16 temp := [] rune(str) 17 for i := 0; i < len(temp); i++ { 18 fmt.Println(temp[i]) 19 } 20 } 21 22 //輸出結果 23 // 104 24 // 101 25 // 108 26 // 108 27 // 111 28 // 32 29 // 228 30 // 189 31 // 160 32 // 229 33 // 165 34 // 189 35 // -------- 36 // 104 37 // 101 38 // 108 39 // 108 40 // 111 41 // 32 42 // 20320 43 // 22909 example4總結：
golang中一個byte數據類型與rune相似，它們都是用來表示字符類型的變量類型。它們的不同在于：
(1). byte 等同于int8，常用來處理ascii字符。
(2). rune 等同于int32,常用來處理unicode或utf-8字符。
參考文獻：
- https://www.jianshu.com/p/4fbf529926ca
轉載于:https://www.cnblogs.com/xuejiale/p/10364745.html
總結
以上是生活随笔為你收集整理的Go语言学习之3 流程控制、函数的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 成都欢乐谷会查包吗
- 下一篇： #191 sea（动态规划）