Go 基础 01

• 交换两个整数的值

package main

import (
    "fmt"
)

func main() {
    a := 400
    b := 500

    // 交换两个整数的值
    a, b = b, a

    fmt.Println("a=", a)
    fmt.Println("b=", b)
}

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

package main

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

// main方法执行前的初始化方法
func init() {
    // 当前时间作为随机种子
    rand.Seed(time.Now().UnixNano())
}

func main() {

    for i := 0; i < 10; i++ {
        a := rand.Intn(100)
        fmt.Println(a)
    }    
}

• 字符串反转

package main

import (
    "fmt"
)

// 字符串反转
func reverse(str string) string {
    // 定义返回字符切片
    var result []byte
    // 字符串转为字符切片
    tmp := []byte(str)

    length := len(str)
    for i := 0; i < length; i++ {
        result = append(result, tmp[length-i-1])
    }
    return string(result)
}

func main() {
    str := "hello"

    result = reverse(str)
    fmt.Println(result)
}

• 修改字符串中的值

package main

import (
    "fmt"
)

func testModifyString() {
    s := "hello 中国"
    // 中文字符串修改时，使用 []rune
    // 英文字符串修改时，使用 []byte
    s1 := []rune(s)
    // 修改字符串中的值
    s1[6] = '美'
    // 切片转为字符串
    str := string(s1)
    fmt.Println(str)
}

func main() {
    testModifyString()
}

• 日期时间格式化输出

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    fmt.Println(now.Format("2006/01/02 15:04:05"))
    fmt.Println(now.Format("2006/01/02 3:04:05.000 PM"))
}

• 函数的可变参数

package main

import (
    "fmt"
)

func concat(a string, arg ...string) (result string) {
    result = a
    for i := 0; i < len(arg); i++ {
        // arg 是一个切片，可以通过 arg[index] 访问具体位置的值
        result += arg[i]
    }
    return
}

func main() {    
    result := concat("a", "b", "
")
    fmt.Println(result)
}

• 遍历二维数组

package main

import (
    "fmt"
)

// 二维数组遍历
func testArrayTraversal(a [2][5]int) {

    for row, v := range a {
        fmt.Println("row ==> ", row)
        for col, v1 := range v {
            fmt.Printf("	(%d,%d)=%d", row, col, v1)
        }
        fmt.Println()
    }
    fmt.Println()
}

func main() {
    var a [2][5]int = [...][5]int{{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}}
    testArrayTraversal(a)
}

• 遍历切片

package main

import (
    "fmt"
)

// 遍历切片
func testSlice(s []int) {
    for index, value := range s {
        fmt.Printf("s[%d] ==> %d
", index, value)
    }
}

func main() {
    arr := [...]int{9, 8, 7, 6, 5}
    // 从数组中初始化切片
    var s []int = arr[:]
    testSlice(s)
}

• map 反转

package main

import (
    "fmt"
)

// map 反转
func testMapReverse() {
    var a map[string]int
    a = make(map[string]int)

    a["a"] = 9
    a["b"] = 8
    a["c"] = 7
    fmt.Println(a)

    // 存放反转的map
    var b map[int]string
    b = make(map[int]string)

    // 反转
    for k, v := range a {
        b[v] = k
    }
    fmt.Println(b)
}

func main() {
    testMapReverse()
}

• map 排序

package main

import (
    "fmt"
    "sort"
)

// map 的排序
func testMapSort(m map[string]int) {

    // 遍历 map 并将 key 存入切片 keys 中
    var keys []string
    for k, _ := range m {
        keys = append(keys, k)
    }
    // 打印排序操作前的切片
    fmt.Println("sort before ==> ", keys)
    // 对字符切片进行排序
    sort.Strings(keys)
    // 打印排序操作后的切片
    fmt.Println("sort after  ==> ", keys)
    // 以切片的有序 value 值作为 map 的下标，遍历 map
    for _, v := range keys {
        fmt.Println(v, "==>", m[v])
    }
    return
}

func main() {
    var m map[string]int
    m = make(map[string]int)

    m["a"] = 9
    m["b"] = 8
    m["c"] = 7
    m["A"] = 6
    m["B"] = 5
    m["C"] = 4
    testMapSort(m)
}

（ Over ）