官方文档

排序(sort)

package main

import (
    "fmt"
    "sort"
)

type Sort struct {
    m []int
}

func (s Sort) Len() int {
    return len(s.m)
}

// 表示使用什么标准进行排序
func (s Sort) Less(i int, j int) bool {
    return s.m[i] > s.m[j] 
}

func (s Sort) Swap(i, j int) {
    s.m[i], s.m[j] = s.m[j], s.m[i]
}
func main() {

    // 都是升序
    sint := []int{3,52,532,51,2}
    sort.Ints(sint)
    sfloat := []float64{3,52.4,532,52.1,2}
    sort.Float64s(sfloat)
    
    strings := []string{"dqfq", "klej", "dwqh", "aaa", "中国", "bbb"}
    sort.Strings(strings)
    s := []int{3,521,532,52,2, 52}
    sort.Ints(s)
    
    // 二分查找
    index := sort.Search(len(s), func(i int) bool {
        return s[i] == 53
    })
    fmt.Println(s, index)

    s1 := Sort{m: []int{3,52,532,51,2}}
    sort.Sort(s1)
    fmt.Println(s1)
}

文件操作(os、io)

package main

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

func main() {
    // file 是文件的地址
    var file, err = os.Open("content.text")
    fmt.Println(file)
    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()  // 关闭文件句柄
    if err != nil {
        fmt.Println(err)
    }
    // 缓冲读取
    reader := bufio.NewReader(file)
    for {
        str, err := reader.ReadString('\n') // 读到换行就结束
        if err == io.EOF { // io.EOF表示文件末尾
            break
        }
        fmt.Printf("%v", str)
    }
}

小容量文件读取

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    content, errs := ioutil.ReadFile("content.text")

    if errs != nil {
        fmt.Println(errs)
    }
    fmt.Println(string(content))
}

写入文件

const (
    // Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
    O_RDONLY int = syscall.O_RDONLY // open the file read-only. 只读
    O_WRONLY int = syscall.O_WRONLY // open the file write-only. 只写
    O_RDWR   int = syscall.O_RDWR   // open the file read-write. 读写
    // The remaining values may be or'ed in to control behavior.
    O_APPEND int = syscall.O_APPEND // append data to the file when writing. 追加
    O_CREATE int = syscall.O_CREAT  // create a new file if none exists. 创建
    O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist. 文件是否存在
    O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O. 同步IO
    O_TRUNC  int = syscall.O_TRUNC  // truncate regular writable file when opened. 如果可能,清空文件
)
package main

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

func main() {
    file, err := os.OpenFile("hello.log", os.O_RDWR | os.O_APPEND | os.O_CREATE, 0666)

    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

    str := "world  \n"
    writer := bufio.NewWriter(file) // 写入缓冲
    for i := 1; i <= 5; i++ {
        //n1, _ := file.WriteString(str) // 直接写入文件
        n1, _ := writer.WriteString(str)
        fmt.Println(n1)
    }
    writer.Flush() // 缓冲写入文件
}

Json

序列化

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name string `json:"my_name"` // 反射机制,{"my_name":"Sam","my_age":18,"my_height":182}
    Age int `json:"my_age"`
    Height int `json:"my_height"`
}

func main() {
    // 构造体转json
    stu := Student{"Sam", 18, 182}
    data, err := json.Marshal(&stu)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(string(data))

    // 集合转json
    m := make(map[string]string)
    m["name"] = "Sam"
    m["age"] = "18"
    data, err := json.Marshal(m)

    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(string(data))

    // 切片转json
    s := make([]int, 4)
    for i, _  := range s {
        s[i] = rand.Intn(100)
    }
    data, err := json.Marshal(s)

    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(string(data))
}

反序列化

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name string `json:"my_name"` // 反射机制,{"my_name":"Sam","my_age":18,"my_height":182}
    Age int `json:"my_age"`
    Height int `json:"my_height"`
}

func main(){
    // 需要注意结构体是否反射
    str := "{\"my_name\":\"Sam\",\"my_age\":18,\"my_height\":182}"

    var p Student
    err := json.Unmarshal([]byte(str), &p)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(p, p.Age)
    
    // 集合
    m := make(map[string]string)
    str := "{\"age\":\"18\",\"name\":\"Sam\"}"
    err := json.Unmarshal([]byte(str), &m)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("%v \n", m)

    // 切片
    s := make([]string ,4)
    str := "[\"sam\",\"18\"]"
    err := json.Unmarshal([]byte(str), &s)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(s[0])
}

时间(time)

package main

import (
    "fmt"
    "time"
)
func main() {

    now := time.Now() // 返回Time构造体

    fmt.Printf("%T,  %v \n", now, now)

    fmt.Println(now.Year()) // 年
    fmt.Printf("%T, %v \n", now.Month(), now.Month()) // 月
    fmt.Println(int(now.Month())) // 月
    fmt.Println(now.Day()) // 日
    fmt.Println(now.Hour()) // 时
    fmt.Println(now.Minute()) // 分
    fmt.Println(now.Second()) // 秒
    y, m, d := now.Date() // 同时获取年月日
    fmt.Println(y,int(m),d)

    date := fmt.Sprintf("%d-%d-%d %d:%d:%d \n", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
    fmt.Println(date)

    fmt.Printf("%v \n", now.Format("2020/09/15 13:42:00"))

    fmt.Println(now.Unix()) // 时间戳
    fmt.Println(now.UnixNano()) // 毫秒
}

字符串(strings)

package main

import (
    "fmt"
    "strings"
)

func main() {

    var str = "!!!hello,中国,中文!!!"
    fmt.Println(strings.Count(str, "l")) // strings.Count(str, substr) 统计子字符串出现的次数
    fmt.Println(strings.EqualFold("abc", "ABC")) // strings.EqualFold(str1, str2) 不区分大小写,对比字符是否相等
    
    fmt.Println(strings.Index(str, "中")) //strings.Index(str, substr) 返回子字符串第一次出现的索引位置
    fmt.Println(strings.LastIndex(str, "中文")) // strings.LastIndex(str, substr) 返回子字符串最后一次出现的索引位置
    
    fmt.Println(strings.Replace(str, "中文", "你好", 15))  // strings.Replace(str, old, new, index) 子字符串替换 index = -1 表示全部替换
    
    fmt.Println(strings.Split(str, ",")) // strings.Split(str, substr) 根据子字符串切割,返回数组
    fmt.Println(strings.ToUpper(str)) // strings.ToUpper(str) 英文字母转大写
    str = strings.ToUpper(str)
    fmt.Println(strings.ToLower(str)) // strings.ToLower(str) 英文字母转小写
    str = strings.ToLower(str)
    fmt.Println(strings.TrimSpace(str)) // strings.TrimSpace(str) 剔除字符串两边的空格
    
    fmt.Println(strings.Trim(str, "!")) // strings.Trim(str, cutstr) 剔除两边指定字符串
    fmt.Println(strings.TrimLeft(str, "!")) // strings.TrimLeft(str, cutstr) 剔除左边指定字符串
    fmt.Println(strings.TrimRight(str, "!")) // strings.TrimRight(str, cutstr) 剔除右边指定字符串
    
    fmt.Println(strings.HasPrefix(str, "!")) // strings.HasPrefix(str, prefix) 验证字符串是否以指定字符串开头
    fmt.Println(strings.HasSuffix(str, "!")) // strings.HasSuffix(str, suffix) 验证字符串是否以指定字符串结尾
}

Redis

redigo

  • 安装
    go get github.com/garyburd/redigo/redis
package main

import (
    "fmt"
    "github.com/garyburd/redigo/redis"
)

func main() {
    //conn, err := redis.Dial("tcp", "127.0.0.1:6379")
    conn, err := redis.DialURL("redis://127.0.0.1:6379")
    if err != nil {
        fmt.Println("conn err =", err)
        return
    }

    defer conn.Close()

    // key-value 键值对
    rs, err := conn.Do("Setex", "name", 1, "Sam")
    if err != nil {
        fmt.Println("set err = ", err)
        return
    }
    fmt.Println(rs) // ok
    rs, err = conn.Do("Get", "name") // 返回接口,断言byte切片
    if err != nil {
        fmt.Println("get err = ", err)
        return
    }
    if rs == nil {
        fmt.Println("数据失效")
        return
    }
    fmt.Println(string(rs.([]byte)))
    
    conn.Send("Get", "name")
    conn.Flush()
    rs, err = conn.Receive()
    if err != nil {
        fmt.Println("get err = ", err)
        return
    }
    if rs == nil {
        fmt.Println("数据失效")
        return
    }
    fmt.Println(string(rs.([]byte)))

    // list 列表
    conn.Do("Lpush", "testlist", "Sam")
    conn.Do("Lpush", "testlist", "Kobe")
    conn.Do("Lpush", "testlist", "Alen")

    // 获取列表长度
    llen, _ := redis.Int(conn.Do("llen", "testlist"))
    
    rs, _ = redis.Values(conn.Do("lrange", "testlist", 0, llen))
    
    for _, v := range rs {
        fmt.Println(string(v.([]byte)))
    }

    // hash 哈希表
    conn.Do("hset", "test_hash", "height", 180)
    rs, _ = redis.Strings(conn.Do("hgetall", "test_hash"))

    for k, v := range rs {
        fmt.Println(k, v)
    }
}
最后修改:2020 年 10 月 18 日 02 : 08 PM
如果觉得我的文章对你有用,请随意赞赏