官方文档

排序（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)
	}
}

其他

切片去重

func RemoveRepElement(res, oldData interface{}) {
	temp := map[string]struct{}{}
	newValue := reflect.ValueOf(res)
	if newValue.Kind() != reflect.Ptr {
		panic("类型不是指针")
	}
	oldValue := reflect.ValueOf(oldData)
	if oldValue.Kind() != reflect.Slice {
		panic("类型不是切片")
	}
	direct := reflect.Indirect(newValue)
	newType := reflect.TypeOf(res).Elem()

	for i := 0; i < oldValue.Len(); i++ {
		if newType.Elem().Kind() != oldValue.Index(i).Kind() {
			panic("类型错误")
		}
		key := fmt.Sprint(oldValue.Index(i))
		if _, ok := temp[key]; !ok {
			temp[key] = struct{}{}
			direct.Set(reflect.Append(direct, oldValue.Index(i)))
		}
	}
}