Go 基础 01

交换两个整数的值

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main() {
 8     a := 400
 9     b := 500
10 
11     // 交换两个整数的值
12     a, b = b, a
13 
14     fmt.Println("a=", a)
15     fmt.Println("b=", b)
16 }

随机生成10 个 100 以内的整数

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "math/rand"
 6     "time"
 7 )
 8 
 9 // main方法执行前的初始化方法
10 func init() {
11     // 当前时间作为随机种子
12     rand.Seed(time.Now().UnixNano())
13 }
14 
15 func main() {
16 
17     for i := 0; i < 10; i++ {
18         a := rand.Intn(100)
19         fmt.Println(a)
20     }    
21 }

字符串反转

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 // 字符串反转
 8 func reverse(str string) string {
 9     // 定义返回字符切片
10     var result []byte
11     // 字符串转为字符切片
12     tmp := []byte(str)
13 
14     length := len(str)
15     for i := 0; i < length; i++ {
16         result = append(result, tmp[length-i-1])
17     }
18     return string(result)
19 }
20 
21 func main() {
22     str := "hello"
23 
24     result = reverse(str)
25     fmt.Println(result)
26 }

修改字符串中的值

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func testModifyString() {
 8     s := "hello 中国"
 9     // 中文字符串修改时，使用 []rune
10     // 英文字符串修改时，使用 []byte
11     s1 := []rune(s)
12     // 修改字符串中的值
13     s1[6] = '美'
14     // 切片转为字符串
15     str := string(s1)
16     fmt.Println(str)
17 }
18 
19 func main() {
20     testModifyString()
21 }

日期时间格式化输出

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 
 8 func main() {
 9     now := time.Now()
10     fmt.Println(now.Format("2006/01/02 15:04:05"))
11     fmt.Println(now.Format("2006/01/02 3:04:05.000 PM"))
12 }

函数的可变参数

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func concat(a string, arg ...string) (result string) {
 8     result = a
 9     for i := 0; i < len(arg); i++ {
10         // arg 是一个切片，可以通过 arg[index] 访问具体位置的值
11         result += arg[i]
12     }
13     return
14 }
15 
16 func main() {    
17     result := concat("a", "b", "\n")
18     fmt.Println(result)
19 }

遍历二维数组

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 // 二维数组遍历
 8 func testArrayTraversal(a [2][5]int) {
 9 
10     for row, v := range a {
11         fmt.Println("row ==> ", row)
12         for col, v1 := range v {
13             fmt.Printf("\t(%d,%d)=%d", row, col, v1)
14         }
15         fmt.Println()
16     }
17     fmt.Println()
18 }
19 
20 func main() {
21     var a [2][5]int = [...][5]int{{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}}
22     testArrayTraversal(a)
23 }

遍历切片

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 // 遍历切片
 8 func testSlice(s []int) {
 9     for index, value := range s {
10         fmt.Printf("s[%d] ==> %d\n", index, value)
11     }
12 }
13 
14 func main() {
15     arr := [...]int{9, 8, 7, 6, 5}
16     // 从数组中初始化切片
17     var s []int = arr[:]
18     testSlice(s)
19 }

map 反转

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 // map 反转
 8 func testMapReverse() {
 9     var a map[string]int
10     a = make(map[string]int)
11 
12     a["a"] = 9
13     a["b"] = 8
14     a["c"] = 7
15     fmt.Println(a)
16 
17     // 存放反转的map
18     var b map[int]string
19     b = make(map[int]string)
20 
21     // 反转
22     for k, v := range a {
23         b[v] = k
24     }
25     fmt.Println(b)
26 }
27 
28 func main() {
29     testMapReverse()
30 }

map 排序

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "sort"
 6 )
 7 
 8 // map 的排序
 9 func testMapSort(m map[string]int) {
10 
11     // 遍历 map 并将 key 存入切片 keys 中
12     var keys []string
13     for k, _ := range m {
14         keys = append(keys, k)
15     }
16     // 打印排序操作前的切片
17     fmt.Println("sort before ==> ", keys)
18     // 对字符切片进行排序
19     sort.Strings(keys)
20     // 打印排序操作后的切片
21     fmt.Println("sort after  ==> ", keys)
22     // 以切片的有序 value 值作为 map 的下标，遍历 map
23     for _, v := range keys {
24         fmt.Println(v, "==>", m[v])
25     }
26     return
27 }
28 
29 func main() {
30     var m map[string]int
31     m = make(map[string]int)
32 
33     m["a"] = 9
34     m["b"] = 8
35     m["c"] = 7
36     m["A"] = 6
37     m["B"] = 5
38     m["C"] = 4
39     testMapSort(m)
40 }

（ Over ）

猜你喜欢