OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Go›Go教程

GO-常用包

原作者: [db:作者] 来自: [db:来源] 收藏邀请

1.打印信息print各个区别
- 格式说明
- 输人Scanf类似input
- fmt.Sprintf格式化输出
2.查看类型-TypeOf,%T
3.查看长度-len
4.类型转换
- string到int
- string到int64
- int到string
- int64到string
- float到string
- string到float64
- string到float32
- int到int64
5.十进制任意相互转换
6.查看容量-cap
7.常量定义关键字const
8.常量定义iota枚举
9.append元素追加
10.reflect反射
- 方法归纳
- 反射类型判断
- reflect.DeepEqual 判断两个map是否相等
- reflect.ValueOf 获取值信息
- reflect.TypeOf 获取类型信息
- reflect.ValueOf(a).SetInt(10) 反射修改值
11.结构体与反射
- 方法归纳
- 查看结构体类型、字段和方法
- 查看匿名字段
- 修改结构体的值
- 调用方法
- 获取字段的tag
12.time模块
- 打印当前时间戳
- str格式化时间
- 时间戳转str格式化时间
- str格式化时间转时间戳
- time.Parse格式化时间转时间戳
- time.Parse和time.Format的区别
- Format
- int型时间数字处理
- pg时间格式timestamp读取到结构体
- 示例
13.rand随机
- 从切片中随机取值
- 订单编号
- 雪花算法
14.Go语言标准库flag基本使用
15.MD5使用
16.murmurhash3非加密哈希
17.json
- strings.Join字符串拼接
- json字符串转换
- redis map转结构体
- json字符串转结构体
18.编码转换
19.操作kafka
20.操作rabitMQ
21.decimal加减乘除
- 类型转换
- 加法 Add
- 减法 Sub
- 乘法 Mul
- 除法 Div
22.in
23.排序
- 字符串排序
- 切片排序
24.math数学计算
25.strings
- strings.EqualFold 判断两个utf-8编码字符串是否相同
- strings.HasPrefix 判断s字符串是否有前缀字符串p
- strings.HasSuffix 判断s字符串是否有后缀缀字符串p
- strings.Count 判断s字符串有几个不重复的sep子串
- strings.Contains 判断s字符串是否包含字符串p
- strings.ContainsAny 判断s字符串是否包含字符p
- strings.ContainsRune 判断s字符串是否包含指定ASCII码值
- strings.IndexByte/IndexRune 判断指定ASCII码值在s字符串中的位置，不存在返回-1
- strings.Index 判断字符串p在s字符串出现的位置，不存在返回-1
- strings.IndexAny 字符串p中的任一utf-8码值在s中第一次出现的位置,没有返回-1
- strings.Title 首字母都改为大写
- strings.ToLower 所有转小写
- strings.ToUpper 所有转大写
- strings.Repeat 拷贝n个s字符串
- strings.Replace 字符串替换
- strings.Trim 返回用p包裹的中间字符串
- strings.TrimLeft 去掉左边包裹
- strings.TrimRight 去掉右边包裹
- strings.TrimSpace 去掉前后空格
- strings.TrimPrefix 返回去除s可能的前缀prefix的字符串
- strings.TrimSuffix 返回去除s可能的后缀prefix的字符串
- strings.Fields 字符串按照空格转为切片
- strings.Split 切割
- strings.SplitN 切割条件
- strings.Join 字符串拼接

1. Println 打印的每一项之间都会有回车空行，Print 没有
2. Printf是格式化输出
func main() {
    a:=10
    b:=20
    c:=30
    fmt.Println("a=", a , ",b=" , b , ",c=" , c) # a= 10 ,b= 20 ,c= 30
    fmt.Printf("a=%d,b=%d,c=%d" , a , b , c) # a=10,b=20,c=30
}
不加fmt，转成ascill码

格式说明

| 格式 | 含义 |

| | %% | 一个%字面量 | |
| | %b | 一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数 | |
| | %c | 字符型。可以把输入的数字按照ASCII码相应转换为对应的字符 | |
| | %d | 一个十进制数值(基数为10) | |
| | %e | 以科学记数法e表示的浮点数或者复数值 | |
| | %E | 以科学记数法E表示的浮点数或者复数值 | |
| | %f | 以标准记数法表示的浮点数或者复数值 | |
| | %g | 以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 | |
| | %G | 以%E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 | |
| | %o | 一个以八进制表示的数字(基数为8) | |
| | %p | 以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示 | |
| | %q | 使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字 | |
| | %s | 字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符） | |
| | %t | 以true或者false输出的布尔值 | |
| | %T | 使用Go语法输出的值的类型 | |
| | %U | 一个用Unicode表示法表示的整型码点，默认值为4个数字字符 | |
| | %v | 使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话 | |
| | %x | 以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示 | |
| | %X | 以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示 | |

输人Scanf类似input

    var v int
    fmt.Println("请输入一个整型：")
    fmt.Scanf("%d", &v)
    //fmt.Scan(&v)
    fmt.Println("v = ", v)

fmt.Sprintf格式化输出

func main() {
	name := "jeff"
	a := fmt.Sprintf("我的名字是%s", name)
	fmt.Println(a) // 我的名字是jeff
}

2.查看类型-TypeOf,%T

num := 10
reflect.TypeOf(num)  // int
fmt.Printf("type = %T", num) //type = int

3.查看长度-len

a := []int{1, 2, 3, 4, 
fmt.Println(len(a))  //5
           
           
数组：v中的元素数。
指向数组的指针：* v中的元素数（即使v为零）。
切片或map：v中的元素数量； 如果v为零，则len（v）为零。
字符串：v中的字节数。
Channel：在通道缓冲区中排队（未读）的元素数；
如果v为零，则len（v）为零。

4.类型转换

string到int

int,err := strconv.Atoi(string)

string到int64

int64, err := strconv.ParseInt(string, 10, 64)
//第二个参数为基数（2~36），
//第三个参数位大小表示期望转换的结果类型，其值可以为0, 8, 16, 32和64，
//分别对应 int, int8, int16, int32和int64

int到string

string := strconv.Itoa(int) 
//等价于
string := strconv.FormatInt(int64(int),10)

int64到string

string := strconv.FormatInt(int64,10)  
//第二个参数为基数，可选2~36
//对于无符号整形，可以使用FormatUint(i uint64, base int)

float到string

string := strconv.FormatFloat(float32,'E',-1,32)
string := strconv.FormatFloat(float64,'E',-1,64)
// 'b' (-ddddp±ddd，二进制指数)
// 'e' (-d.dddde±dd，十进制指数)
// 'E' (-d.ddddE±dd，十进制指数)
// 'f' (-ddd.dddd，没有指数)
// 'g' ('e':大指数，'f':其它情况)
// 'G' ('E':大指数，'f':其它情况)

string到float64

float,err := strconv.ParseFloat(string,64)

string到float32

float,err := strconv.ParseFloat(string,32)

int到int64

int64_ := int64(1234)

5.十进制任意相互转换

package main

import (
	"fmt"
	"math"
	"strings"
)

var chars string = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

// 10进制转任意进制
func encode(num int64) string {
	var j int64
	j = 62 // 目标进制62进制
	bytes := []byte{}
	for num > 0 {
		bytes = append(bytes, chars[num%j])
		num = num / j
	}
	reverse(bytes)
	return string(bytes)
}

// 任意进制转10进制
func decode(str string) int64 {
	var num int64
	var j float64
	j = 62  // str的进制是62进制
	n := len(str)
	for i := 0; i < n; i++ {
		pos := strings.IndexByte(chars, str[i])
		num += int64(math.Pow(j, float64(n-i-1)) * float64(pos))
	}
	return num
}

func reverse(a []byte) {
	for left, right := 0, len(a)-1; left < right; left, right = left+1, right-1 {
		a[left], a[right] = a[right], a[left]
	}
}

func main() {
	a:=encode(3929151817)
	fmt.Println(a) // 4hUjSp
	b:=decode("4hUjSp")
	fmt.Println(b) // 3929151817
}

6.查看容量-cap

li := []int{1, 2, 3, 4, 5}
fmt.Println(cap(li))  //5
li = append(li, 123)
fmt.Println(li) //[1 2 3 4 5 123]
fmt.Println(cap(li)) //10
li = append(li, 456)
fmt.Println(li) //[1 2 3 4 5 123 456]
fmt.Println(cap(li)) //10,空间还没有占完，所以还没有扩展



数组：v中的元素数（与len（v）相同）。
指向数组的指针：* v中的元素数（与len（v）相同）。
切片：切片后可以达到的最大长度；
如果v为零，则cap（v）为零。
Channel：通道缓冲容量，以元素为单位；
如果v为零，则cap（v）为零。

7.常量定义关键字const

const (
	CodeSuccess ResCode = 1000 + iota
	CodeInvalidParam
	CodeUserExist
	CodeUserNotExist
	CodeInvalidPassword
	CodeServerBusy
)

8.常量定义iota枚举

常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。

在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。

const (
	CodeSuccess ResCode = 1000 + iota
	CodeInvalidParam
	CodeUserExist
	CodeUserNotExist
	CodeInvalidPassword
	CodeServerBusy
)

const (
    x = iota // x == 0
    y = iota // y == 1
    z = iota // z == 2
    w  // 这里隐式地说w = iota，因此w == 3。其实上面y和z可同样不用"= iota"
)

const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0

const (
    h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同
)

const (
    a       = iota //a=0
    b       = "B"
    c       = iota             //c=2
    d, e, f = iota, iota, iota //d=3,e=3,f=3
    g       = iota             //g = 4
)

const (
    x1 = iota * 10 // x1 == 0
    y1 = iota * 10 // y1 == 10
    z1 = iota * 10 // z1 == 20
)

9.append元素追加

li := []int{1, 2, 3, 4}
li = append(li, 111)
fmt.Println(li)  //[1 2 3 4 111]

10.reflect反射

方法归纳

reflect.DeepEqual(m1, m2) // 判断两个map是否相等
v := reflect.ValueOf(a) // 获取值信息

t: = reflect.TypeOf 获取类型信息, 是动态的
k := t.Kind()// kind()可以获取具体类型

v.SetFloat(6.9)  //反射修改值
v.Elem().SetFloat(7.9)// Elem()获取地址指向的值

反射类型判断

reflect.Ptr  //指针
reflect.Struct //结构体


//判断是否为指针
typeInfo := reflect.TypeOf(result)
	if typeInfo.Kind() != reflect.Ptr {
		return
	}

const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Ptr
	Slice
	String
	Struct
	UnsafePointer
)

reflect.DeepEqual 判断两个map是否相等

reflect.DeepEqual(m1, m2) // 判断两个map是否相等

package main

import (
	"fmt"
	"reflect"
)

func main() {
  // m1,m2顺序不一样，做比较
	m1 := map[string]interface{}{"a": 1, "b": 2, "c": 3}
	m2 := map[string]interface{}{"a": 1, "c": 3, "b": 2}

	fmt.Println(reflect.DeepEqual(m1, m2))  // true
}

reflect.ValueOf 获取值信息

v := reflect.ValueOf(a) // 获取值信息

package main

import (
    "fmt"
    "reflect"
)

//反射获取interface值信息

func reflect_value(a interface{}) {
    v := reflect.ValueOf(a)
    fmt.Println(v)
    k := v.Kind()
    fmt.Println(k)
    switch k {
    case reflect.Float64:
        fmt.Println("a是：", v.Float())
    }
}

func main() {
    var x float64 = 3.4
    reflect_value(x)
}

//
3.4
float64
a是： 3.4

reflect.TypeOf 获取类型信息

reflect.TypeOf 获取类型信息, 是动态的
k := t.Kind()// kind()可以获取具体类型

package main

import (
   "fmt"
   "reflect"
)

//反射获取interface类型信息

func reflect_type(a interface{}) {
   t := reflect.TypeOf(a)
   fmt.Println("类型是：", t)
   // kind()可以获取具体类型
   k := t.Kind()
   fmt.Println(k)
   switch k {
   case reflect.Float64:
      fmt.Printf("a is float64\n")
   case reflect.String:
      fmt.Println("string")
   }
}

func main() {
   var x float64 = 3.4
   reflect_type(x)
}

//
类型是： float64
float64
a is float64

reflect.ValueOf(a).SetInt(10) 反射修改值

v.SetFloat(6.9)  //反射修改值
v.Elem().SetFloat(7.9)// Elem()获取地址指向的值

package main

import (
	"fmt"
	"reflect"
)

//反射修改值
func reflect_set_value(a interface{}) {
	v := reflect.ValueOf(a)
	k := v.Kind()
	switch k {
	case reflect.Float64:
		// 反射修改值
		v.SetFloat(6.9)
		fmt.Println("a is ", v.Float())
	case reflect.Ptr:
		// Elem()获取地址指向的值
		v.Elem().SetFloat(7.9)
		fmt.Println("case:", v.Elem().Float())
		// 地址
		fmt.Println(v.Pointer())
	}
}

func main() {
	var x float64 = 3.4
	// 反射认为下面是指针类型，不是float类型
	reflect_set_value(&x)
	fmt.Println("main:", x)
}

//
case: 7.9
824634957832
main: 7.9

11.结构体与反射

方法归纳

t:=reflect.TypeOf(o) //获取类型
v:=reflect.ValueOf(o) //获取值
t.NumField() //获取结构体字段个数
t.Field(i) //取每个字段
v.Field(i).Interface() //获取字段对应的值

v = v.Elem() // 获取指针指向的元素
fild := v.FieldByName("Name")  // 取字段
v.FieldByName("Age").SetInt(20)  //改年龄

m := v.MethodByName("Hello") // 获取方法
name:=v.Field(1).Interface() // 反射获取结构体字段对应的值
args := []reflect.Value{reflect.ValueOf(name)}  //构建参数
// 没参数的情况下：var args2 []reflect.Value
m.Call(args) // 调用方法，需要传入方法的参数

查看结构体类型、字段和方法

t := reflect.TypeOf(o) //获取类型
v := reflect.ValueOf(o) //获取值
count := t.NumField() //获取结构体字段个数
f := t.Field(i) //取每个字段
val := v.Field(i).Interface() //获取字段对应的值

package main

import (
	"fmt"
	"reflect"
)

// 定义结构体
type Users struct {
	Id   int
	Name string
	Age  int
}

// 绑方法
func (u Users) Hello() {
	fmt.Println("Hello word")
}

// 传入interface{}
func Poni(o interface{}) {
	//获取类型
	t := reflect.TypeOf(o)
	fmt.Println("类型：", t) //类型： main.Users
	fmt.Println("字符串类型：", t.Name())  //字符串类型： Users
	
	// 获取值
	v := reflect.ValueOf(o)
	fmt.Println(v)  //{1 jeff 18}
	
	// 可以获取所有属性
	// 获取结构体字段个数：t.NumField()
	for i := 0; i < t.NumField(); i++ {
		// 取每个字段
		f := t.Field(i)
		fmt.Println(f.Name, f.Type) //Id int
		
		// 获取字段的值信息
		// Interface()：获取字段对应的值
		val := v.Field(i).Interface()
		fmt.Println("data:", val)  // data: 1
	}
	fmt.Println("=================方法====================")
	for i := 0; i < t.NumMethod(); i++ {
		m := t.Method(i)
		fmt.Println(m.Name) // Hello
		fmt.Println(m.Type) //func(main.Users)
	}
	
}

func main() {
	u := Users{1, "jeff", 18}
	Poni(u)
}

查看匿名字段

package main

import (
	"fmt"
	"reflect"
)

// 定义结构体
type Users struct {
	Id   int
	Name string
	Age  int
}

// 匿名字段
type Boy struct {
	Users
	Addr string
}

func main() {
	m := Boy{Users{1, "jeff", 18}, "shanghai"}
	t := reflect.TypeOf(m)
	fmt.Println(t) //main.Boy
	// Anonymous：匿名
	fmt.Printf("%#v\n", t.Field(0))
	// 值信息
	fmt.Printf("%#v\n", reflect.ValueOf(m).Field(0)) //main.Users{Id:1, Name:"jeff", Age:18}
}

//

main.Boy
reflect.StructField{Name:"Users", PkgPath:"", Type:(*reflect.rtype)(0x10bb140), Tag:"", Offset:0x0, Index:[]int{0}, Anonymous:true}
main.Users{Id:1, Name:"jeff", Age:18}

修改结构体的值

v := reflect.ValueOf(o)  
v = v.Elem() // 获取指针指向的元素
f := v.FieldByName("Name")  // 取字段
v.FieldByName("Age").SetInt(20)  //改年龄

package main

import (
	"fmt"
	"reflect"
)

// 定义结构体
type Users struct {
	Id   int
	Name string
	Age  int
}

// 修改结构体值
func SetValue(o interface{}) {
	v := reflect.ValueOf(o)
	// 获取指针指向的元素
	v = v.Elem()
	// 取字段
	f := v.FieldByName("Name")
	if f.Kind() == reflect.String {
		f.SetString("chary")
	}
	//改年龄
	v.FieldByName("Age").SetInt(999)
}

func main() {
	u := Users{1, "jeff", 18}
  fmt.Println(u)  //{1 jeff 18}
	SetValue(&u)
	fmt.Println(u) //{1 chary 999}
}

//
{1 chary 20}

调用方法

m := v.MethodByName("Hello") // 获取方法
name:=v.Field(1).Interface() // 反射获取结构体字段对应的值
args := []reflect.Value{reflect.ValueOf(name)}  //构建参数
// 没参数的情况下：var args2 []reflect.Value
m.Call(args) // 调用方法，需要传入方法的参数

package main

import (
	"fmt"
	"reflect"
)

// 定义结构体
type Users struct {
	Id   int
	Name string
	Age  int
}

func (u Users) Hello(name string) {
	fmt.Println("Hello：", name)
}

func main() {
	u := Users{1, "jeff", 18}
	v := reflect.ValueOf(u)
	// 获取方法
	m := v.MethodByName("Hello")
	
	// 反射获取结构体字段对应的值
	name:=v.Field(1).Interface()
	// 构建一些参数
	args := []reflect.Value{reflect.ValueOf(name)}
	// 没参数的情况下：var args2 []reflect.Value
	// 调用方法，需要传入方法的参数
	m.Call(args)
}

//
Hello:jeff

获取字段的tag

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name string `json:"name1" db:"name2"`
}

func main() {
	var s Student
	v := reflect.ValueOf(&s)
	// 类型
	t := v.Type()
	// 获取字段
	f := t.Elem().Field(0)
	fmt.Println(f.Tag.Get("json")) //name1
	fmt.Println(f.Tag.Get("db"))  //name2
}

12.time模块

打印当前时间戳

fmt.Println(time.Now().Unix())# 1606879472

str格式化时间

time.Now() 是要格式化的时间
fmt.Println(time.Now().Format("2006-01-02 15:04:05")) # 这是个奇葩,必须是这个时间点, 据说是go诞生之日, 记忆方法:6-1-2-3-4-5
# 2020-12-02 11:25:12

时间戳转str格式化时间

str_time := time.Unix(1606879911, 0).Format("2006-01-02 15:04:05")
fmt.Println(str_time) 
# 2020-12-02 11:31:51

str格式化时间转时间戳

the_time := time.Date(2020, 12, 1, 1, 00, 0, 0,time.Local)
unix_time := the_time.Unix()
fmt.Println(unix_time)# 1606755600

time.Parse格式化时间转时间戳

the_time, err := time.Parse("2006-01-02 15:04:05", "2020-12-01 09:04:41")
if err == nil {
    unix_time := the_time.Unix()
    fmt.Println(unix_time)
  }
# 1606813481

time.Parse和time.Format的区别

在windows下，time.Parse()的时区和time.Format()的时区是一致的。但是在linux环境下，time.Parse()的默认时区是UTC（与我们使用的标准时间CST相差8个小时），time.Format()的时区默认是本地，两者如果不处理好就会导致错误。具体可以做如下一个操作，找一台linux主机，将其/etc/localtime由Shanghai更换为UTC，然后分别执行如下代码，看下输出的区别：

package mainimport "time"import "fmt"func main(){    t, err := time.Parse("2006-01-02 15:04:05", "2017-12-03 22:01:02")    //localTime, err := time.ParseInLocation("2006-01-02 15:04:05", "2017-12-03 22:01:02", time.Local)    if err != nil{        fmt.Println(err)        return    }    fmt.Println(t)    fmt.Println(time.Now())    fmt.Println(time.Now().Sub(t).Seconds())}

分别使用time.Parse和time.ParseInLocation分别算下两个时间之间的差值，看下哪一个求出的值是正确的？

Format

now := time.Now()
fmt.Println(now)  //2021-07-13 11:26:39.500074 +0800 CST m=+0.002081543
edidate := now.Format("20060102150405")
fmt.Println(edidate)  // 20210713112639

int型时间数字处理

timestamp := int64(1640534400)
now := time.Unix(timestamp, 0).Format("2006-01")

pg时间格式timestamp读取到结构体

import "time"

sqlstr := `
	select
	coalesce(id,0) as id,
	coalesce(code,'') as code,
	coalesce(name,'') as name,
	coalesce(company,'') as company,
	coalesce(updated_at,'1970-01-01'::timestamp) as updated_at
	from bike_brand
	where 1=1
	`
	sqlstr += qstr
	err := o.DbRo.QueryRow(sqlstr).Scan(&r.Id, &r.Code, &r.Name, &r.Company, &r.UpdatedAt)


type Info struct {
	Id      	int     	`json:"id"`
	Code     	string  	`json:"code"`
	Name    	string     	`json:"name"`
	Company		string		`json:"company"`
	UpdatedAt	time.Time   `json:"updated_at"`
}

示例

最后再给出一个输出当前时间年、月、日、时等不同信息的示例代码，如下：

package main
import(    
  "fmt"    
  "time"
)
func  main(){    
  t := time.Now()    
  y,m,d := t.Date()    
  today := time.Now().Format("2006-01-02")    
  datetime := time.Now().Format("2006-01-02 15:04:05")//后面的参数是固定的 否则将无法正常输出    
  fmt.Println("time is : ",t )    
  fmt.Println("y m d is : ",y,m,d )    
  fmt.Println("now is :",today)    
  fmt.Println("now is :",datetime)
}

2020-12-02 11:42:48.606258 +0800 CST m=+0.000126668
2020 December 2
2020-12-02
2020-12-02 11:42:48

13.rand随机

# 时间戳为种子
r := rand.New(rand.NewSource(time.Now().UnixNano()))
for i:=0;i<10;i++{
		fmt.Println(r.Intn(100))
	}


rand.NewSource(种子)  设置种子
rand.Intn(100) 返回一个随机的整数
rand.Float64() 返回一个64位浮点数


//step1: 设置种子数
rand.Seed(time.Now().UnixNano())
//step2：获取随机数
num4 := rand.Intn(10) // 0-9随机数
fmt.Println(num4)


r := rand.New(rand.NewSource(time.Now().UnixNano()))
res := r.Intn(right-left+1)+left  # left到right

从切片中随机取值

# 定义随机种子
r := rand.New(rand.NewSource(time.Now().UnixNano()))

lis := make([]int,0)  //定义切片
// 给切片造假数据
for i:=0;i<100;i++ {
  lis = append(lis, i)
}
fmt.Println(lis)

for i:=0;i<10;i++ {
  a := len(lis) //获取切片长度
  b := r.Intn(a) //随机获取一个长度以内的整数
  fmt.Println(lis[b])  //取值
}

订单编号

// 生产n位数字，主用作验证码
func RandomInt(length int) (str string) {
	// length 长度
	var arr []byte = []byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	size := len(arr)
	for i := 0; i < length; i++ {
		str += string(arr[r.Intn(size)])
	}
	return
}

// 订单编号
func Start(userId int, num str) string {
  // num 以什么结尾
	now := time.Now()
	uidStr := fmt.Sprintf("%04d", userId)
	return now.Format("0601021504") + uidStr + qutil.RandomInt(3) + string(orderChannel)
}

雪花算法

地址：github.com/bwmarrin/snowflake

调用一次GenID()产生一个有序且唯一的id.

如果多台机器，可以把GenID()方法做成一个服务，调用即可
注意：可以用69年，每毫秒可以产生40多万个不重复的id

package main

import (
	"fmt"
	"time"

	"github.com/bwmarrin/snowflake"
)

var node *snowflake.Node

func Init(startTime string, machineId int64) (err error) {
	var st time.Time
	st, err = time.Parse("2006-01-02", startTime)
	if err != nil {
		return
	}
	snowflake.Epoch = st.UnixNano() / 1000000
	node, err = snowflake.NewNode(machineId)
	return
}

func GenID() (id int64, err error) {
	if err := Init("2021-01-13", 1); err != nil {
		fmt.Printf("init failed,err:%V\n", err)
		return 0, err
	}
	id = node.Generate().Int64()
	return id, nil
}

func main() {
	id, err := GenID()
	fmt.Println(id)
	fmt.Println(err)
}

14.Go语言标准库flag基本使用

Go语言标准库flag基本使用

15.MD5使用

package pkg

import (
	"crypto/md5"
	"encoding/hex"
)

func MD5(str string) string {
	h := md5.New()
	str = str + "加盐加盐"
	h.Write([]byte(str)) // 需要加密的字符串为 123456
	cipherStr := h.Sum(nil)
	return hex.EncodeToString(cipherStr) // 输出加密结

}

16.murmurhash3非加密哈希

加密哈希，如MD5，SHA256等，
非加密哈希，如MurMurHash，CRC32，DJB等

能够满足这样的哈希算法有很多，这里推荐 Google 出品的 MurmurHash 算法，MurmurHash 是一种非加密型哈希函数，适用于一般的哈希检索操作。与其它流行的哈希函数相比，对于规律性较强的 key，MurmurHash 的随机分布特征表现更良好。非加密意味着着相比 MD5，SHA 这些函数它的性能肯定更高（实际上性能是 MD5 等加密算法的十倍以上），也正是由于它的这些优点，所以虽然它出现于 2008，但目前已经广泛应用到 Redis、MemCache、Cassandra、HBase、Lucene 等众多著名的软件中。

package main

import "fmt"
import "github.com/spaolacci/murmur3"

func main() {
	b := murmur3.Sum32WithSeed([]byte("hello word"),0x1234ABCD)
	fmt.Println(b) //1380922724

	foo := int64(murmur3.Sum64WithSeed([]byte("hello word"), 0x1234ABCD))
	fmt.Println(foo) //4946771540764450955
}

17.json

strings.Join字符串拼接

var NetworkSql string
for i := range in.Network {
  NetworkSql = strings.Join([]string{NetworkSql, strconv.Itoa(in.Network[i])}, ",")
}
NetworkSql = string(NetworkSql)[1:]

json字符串转换

import "encoding/json"
json.Marshal(query)  # 转换为json字符串
json.Unmarshal(strquery)  # json字符串转换为标准json


type Student struct {
	Name    string
	Age     int
	Classes []string
	Price   float32
}



func main() {

	st := &Student {
		"jeff",
		18,
		[]string{"math", "English", "Chinese"},
		9.99,
	}
	b, _ := json.Marshal(st)
	fmt.Println(string(b))  //{"Name":"jeff","Age":18,"Classes":["math","English","Chinese"],"Price":9.99}

	stb := &Student{}
	_ = json.Unmarshal([]byte(b), &stb)
	fmt.Println(stb) //&{jeff 18 [math English Chinese] 9.99}
}

redis map转结构体

package main

import (
	"encoding/json"
	"fmt"
	"github.com/go-redis/redis"
)

var rdb *redis.Client

func initClient() (err error) {
	rdb = redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1",
		Password: "", // no password set
		DB:       4,  // use default DB
	})

	_, err = rdb.Ping().Result()
	if err != nil {
		return err
	}
	return nil
}

type bike struct {
	Acc string `json:"acc"`
	CcID string `json:"cc_id"`
}

func main() {
	err := initClient()
	if err != nil {
		fmt.Println(err)
	}
	value, err2 := rdb.HGetAll("br:10066").Result()
	if err2 != nil {
		fmt.Println(err2)
	}
	//fmt.Printf("%T",value) //map[string]string
	//fmt.Println(value)
	//// 遍历每一个字段
	//a:=value["cc_id"]
	//fmt.Println(a) // 10066
	//// 每一个字段一个个初始化，怎么样可以直接传入&bike,自动初始化
	//b := bike{
	//	Cc_id: a,
	//}
	//fmt.Printf("%+v",b) // {cc_id:10066}

	//var src []map[string]string

	json_ret, err := json.Marshal(value)
	if err != nil {
		fmt.Println(err)
	}
	var bike_test bike
	err = json.Unmarshal(json_ret, &bike_test)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%+v", bike_test)
}

json字符串转结构体

type Info struct {
	Id      int    `json:"id"`
	Code    string `json:"code"`
	HwCode  string `json:"hw_code"`
	Name    string `json:"name"`
	BrandId int    `json:"brand_id"`
}

func jsonTest1()  {
	jsonStr := `{"id":2,"code":"W01","hw_code":"AA5","name":"秋月白","brand_id":1}`
	r:=Info{}
	str:=[]byte(jsonStr)
	json.Unmarshal([]byte(str),&r)
	fmt.Println(r) //{2 W01 AA5 秋月白 1}
}

例子2：[{},{},{}]

type Info struct {
	Id      int    `json:"id"`
	Code    string `json:"code"`
	HwCode  string `json:"hw_code"`
	Name    string `json:"name"`
	BrandId int    `json:"brand_id"`
}

func jsonTest2()  {
	jsonStr := `[{"id":2,"code":"W01","hw_code":"AA5","name":"秋月白","brand_id":1},{"id":3,"code":"W02","hw_code":"AA6","name":"秋月黑","brand_id":2}]`
	r:=Info{}
	list := make([]Info,0)
	var li []map[string]interface{}
	json.Unmarshal([]byte(jsonStr),&li)
	for _,v:=range li{
		arr,_:=json.Marshal(v)
		json.Unmarshal(arr,&r)
		list = append(list, r)
	}
	fmt.Println(list) // [{2 W01 AA5 秋月白 1} {3 W02 AA6 秋月黑 2}]
}

例子3：map[],redis hash

type bike struct {
	Acc string `json:"acc"`
	CcID string `json:"cc_id"`
}

func jsonTest3()  {
	err := initClient()
	if err != nil {
		fmt.Println(err)
	}
	value, err2 := rdb.HGetAll("br:10066").Result()

	if err2 != nil {
		fmt.Println(err2)
	}
	fmt.Println(value)
	json_ret, err := json.Marshal(value)
	if err != nil {
		fmt.Println(err)
	}
	var bike_test bike
	err = json.Unmarshal(json_ret, &bike_test)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%+v", bike_test)
}

18.编码转换

import "github.com/axgle/mahonia"

func main() {
	enc := mahonia.NewEncoder("utf-8")
	//converts a  string from UTF-8 to gbk encoding.
	fmt.Println(enc.ConvertString("hello,世界"))
}

19.操作kafka

http://www.topgoer.com/%E6%95%B0%E6%8D%AE%E5%BA%93%E6%93%8D%E4%BD%9C/go%E6%93%8D%E4%BD%9Ckafka/%E6%93%8D%E4%BD%9Ckafka.html

20.操作rabitMQ

http://www.topgoer.com/%E6%95%B0%E6%8D%AE%E5%BA%93%E6%93%8D%E4%BD%9C/go%E6%93%8D%E4%BD%9CRabbitMQ/

21.decimal加减乘除

初始化一个变量
d0 := decimal.NewFromFloat(0)
设置精度 为三位 四舍五入的精度
decimal.DivisionPrecision = 3

类型转换

var num1 float64 = 3.1
var num2 int = 2
d1 := decimal.NewFromFloat(num1).Sub(decimal.NewFromFloat(float64(num2)))

//类型转换
fmt.Println(d1.IntPart())
fmt.Println(d1.String())
fmt.Println(d1.Abs())

加法 Add

加法 Add，int+float

初始化一个变量
d0 := decimal.NewFromFloat(0)
设置精度 为三位 四舍五入的精度
decimal.DivisionPrecision = 3 

2.1 + 3 float和int相加
var num1 float64 = 2.1
var num2 int = 3
d1 := decimal.NewFromFloat(num1).Add(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "5.1"

加法 Add，float+float

2.1 + 3.1 (float和float相加)
var num1 float64 = 2.1
var num2 float64 = 3.1
d1 := decimal.NewFromFloat(num1).Add(decimal.NewFromFloat(num2))
fmt.Println(d1) // output: "5.2"

加法 Add，int+int

2 + 3 (int和int相加 可以直接相加) 
var num1 float64 = 2
var num2 float64 = 3
（d1 = num1+num2）
d1 := decimal.NewFromFloat(num1).Add(decimal.NewFromFloat(num2))
fmt.Println(d1) // output: "5"

减法 Sub

减法 Sub,float-int相减

3.1 - 2 float和int相减
var num1 float64 = 3.1
var num2 int = 2
d1 := decimal.NewFromFloat(num1).Sub(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "1.1"

减法 Sub,float-float相减

2.1 - 3.1 (float和float相减)
var num1 float64 = 2.1
var num2 float64 = 3.1
d1 := decimal.NewFromFloat(num1).Sub(decimal.NewFromFloat(num2))
fmt.Println(d1) // output: "-1"

减法 Sub,int-int相减

2 - 3 (int和int相减)
var num1 int = 2
var num2 int = 3
(d1 = num1 - num2)
d1 := decimal.NewFromFloat(float64(num1)).Sub(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "-1"

乘法 Mul

乘法 Mul,float*int

3.1 * 2 float和int相乘
var num1 float64 = 3.1
var num2 int = 2
d1 := decimal.NewFromFloat(num1).Mul(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "6.2"

乘法 Mul,float*float

2.1 * 3.1 (float和float相乘)
var num1 float64 = 2.1
var num2 float64 = 3.1
d1 := decimal.NewFromFloat(num1).Mul(decimal.NewFromFloat(num2))
fmt.Println(d1) // output: "6.51"

乘法 Mul,int*int

2 * 3 (int和int相乘)
var num1 int = 2
var num2 int = 3
(d1 = num1 * num2)
d1 := decimal.NewFromFloat(float64(num1)).Mul(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "6"

除法 Div

除法 Div,int/int

int 和 int 相除
2 ➗ 3 = 0.6666666666666667 
var num1 int = 2
var num2 int = 3
d1 := decimal.NewFromFloat(float64(num1)).Div(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "0.6666666666666667"

除法 Div,float64/int

float64 和 int 相除
var num1 float64 = 2.1
var num2 int = 3
d1 := decimal.NewFromFloat(num1).Div(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "0.7"

除法 Div,float64/float64

float64 和 float64 相除
2.1 ➗ 0.3 = 7
var num1 float64 = 2.1
var num2 float64 = 0.3
d2 := decimal.NewFromFloat(num1).Div(decimal.NewFromFloat(num2))
fmt.Println(d2) // output: "7"

除法 Div,int/int

int 和 int 相除 并保持3位精度
2 ➗ 3 = 0.667 
var num1 int = 2
var num2 int = 3
decimal.DivisionPrecision = 3
d1 := decimal.NewFromFloat(float64(num1)).Div(decimal.NewFromFloat(float64(num2)))
fmt.Println(d1) // output: "0.667"

22.in

func in(target int, str_array []int) bool {
	for _, element := range str_array {
		if target == element {
			return true
		}
	}
	return false
}

23.排序

字符串排序

方式一：
func reverse(str string) string {
    var result string
    strLen := len(str)
    for i := 0; i < strLen; i++ {
        result = result + fmt.Sprintf("%c", str[strLen-i-1])
    }
    return result
}

方式二：
func reverse2(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 reverse13(s string) string {
	runes := []rune(s)
	for from, to := 0, len(runes)-1; from < to; from, to = from+1, to-1 {
		runes[from], runes[to] = runes[to], runes[from]
	}
	return string(runes)
}

切片排序

r := []int{5,2,6,10,3} // []int{}
sort.Ints(r)  // 升序
sort.Sort(sort.IntSlice(r)) //升序
fmt.Println(r) // [2 3 5 6 10]


a := []float64{5.5, 2.2, 6.6, 3.3, 1.1, 4.4}
sort.Float64s(a) // 升序
sort.Sort(sort.Float64Slice(a)) // 升序
fmt.Println(a) // [1.1 2.2 3.3 4.4 5.5 6.6]


s := []string{"PHP", "golang", "python", "C", "Objective-C"}
sort.Strings(s) // 字母开头升序
sort.Sort(sort.StringSlice(s)) //字母开头升序
fmt.Println(s) // [C Objective-C PHP golang python]

逆序：
func reverse(s []int) []int {
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		s[i], s[j] = s[j], s[i]
	}
	return s
}
func main() {
	r := []int{5,2,6,10,3}
	k:=reverse(r) // 逆序
	fmt.Println(k) // [3 10 6 2 5]

	sort.Ints(r)  // 升序
	fmt.Println(r) // [2 3 5 6 10]

	k2:=reverse(r) // 逆序
	fmt.Println(k2) // [10 6 5 3 2]
}

24.math数学计算

//math包中定义的常量
func main() {
	fmt.Printf("float64的最大值是:%.f\n", math.MaxFloat64)
	fmt.Printf("float64的最小值是:%.f\n", math.SmallestNonzeroFloat64)
	fmt.Printf("float32的最大值是:%.f\n", math.MaxFloat32)
	fmt.Printf("float32的最小值是:%.f\n", math.SmallestNonzeroFloat32)
	fmt.Printf("Int8的最大值是:%d\n", math.MaxInt8)
	fmt.Printf("Int8的最小值是:%d\n", math.MinInt8)
	fmt.Printf("Uint8的最大值是:%d\n", math.MaxUint8)
	fmt.Printf("Int16的最大值是:%d\n", math.MaxInt16)
	fmt.Printf("Int16的最小值是:%d\n", math.MinInt16)
	fmt.Printf("Uint16的最大值是:%d\n", math.MaxUint16)
	fmt.Printf("Int32的最大值是:%d\n", math.MaxInt32)
	fmt.Printf("Int32的最小值是:%d\n", math.MinInt32)
	fmt.Printf("Uint32的最大值是:%d\n", math.MaxUint32)
	fmt.Printf("Int64的最大值是:%d\n", math.MaxInt64)
	fmt.Printf("Int64的最小值是:%d\n", math.MinInt64)
	fmt.Printf("圆周率默认为:%.200f\n", math.Pi)
}


func main() {
	/*
	   取绝对值,函数签名如下:
	       func Abs(x float64) float64
	*/
	fmt.Printf("[-3.14]的绝对值为:[%.2f]\n", math.Abs(-3.14))

	/*
	   取x的y次方，函数签名如下:
	       func Pow(x, y float64) float64
	*/
	fmt.Printf("[2]的16次方为:[%.f]\n", math.Pow(2, 16))

	/*
	   取余数，函数签名如下:
	       func Pow10(n int) float64
	*/
	fmt.Printf("10的[3]次方为:[%.f]\n", math.Pow10(3))

	/*
	   取x的开平方，函数签名如下:
	       func Sqrt(x float64) float64
	*/
	fmt.Printf("[64]的开平方为:[%.f]\n", math.Sqrt(64))

	/*
	   取x的开立方，函数签名如下:
	       func Cbrt(x float64) float64
	*/
	fmt.Printf("[27]的开立方为:[%.f]\n", math.Cbrt(27))

	/*
	   向上取整，函数签名如下:
	       func Ceil(x float64) float64
	*/
	fmt.Printf("[3.14]向上取整为:[%.f]\n", math.Ceil(3.14))

	/*
	   向下取整，函数签名如下:
	       func Floor(x float64) float64
	*/
	fmt.Printf("[8.75]向下取整为:[%.f]\n", math.Floor(8.75))

	/*
	   取余数，函数签名如下:
	       func Floor(x float64) float64
	*/
	fmt.Printf("[10/3]的余数为:[%.f]\n", math.Mod(10, 3))

	/*
	   分别取整数和小数部分,函数签名如下:
	       func Modf(f float64) (int float64, frac float64)
	*/
	Integer, Decimal := math.Modf(3.14159265358979)
	fmt.Printf("[3.14159265358979]的整数部分为:[%.f],小数部分为:[%.14f]\n", Integer, Decimal)

}

25.strings

strings.EqualFold 判断两个utf-8编码字符串是否相同

func main()  {
	s:="jeff"
	t:="jeff"
  k:= "chary"
	fmt.Println(strings.EqualFold(s,t))  // true
  fmt.Println(strings.EqualFold(s,k))  // false
}

strings.HasPrefix 判断s字符串是否有前缀字符串p

func main()  {
	s:="jeff"
	fmt.Println(strings.HasPrefix(s,"j"))  //true
	fmt.Println(strings.HasPrefix(s,"e"))  //false
}

strings.HasSuffix 判断s字符串是否有后缀缀字符串p

func main()  {
	s:="jeff"
	fmt.Println(strings.HasSuffix(s,"f"))  //true
	fmt.Println(strings.HasSuffix(s,"j"))  //false
}

strings.Count 判断s字符串有几个不重复的sep子串

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Count(s,"f"))  // 2
	fmt.Println(strings.Count(s,"kkk"))  // 0
}

strings.Contains 判断s字符串是否包含字符串p

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Contains(s,"word"))  //true
	fmt.Println(strings.Contains(s,"kkk"))  //false
}

strings.ContainsAny 判断s字符串是否包含字符p

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.ContainsAny(s,"word"))  //true
	fmt.Println(strings.ContainsAny(s,"kkk"))  //false
}

strings.ContainsRune 判断s字符串是否包含指定ASCII码值

a-z：97-122
A-Z：65-90
0-9：48-57

func main()  {
	s:="aaa hello word jeff"
	fmt.Println(strings.ContainsRune(s,97))  //true
	fmt.Println(strings.ContainsRune(s,98))  //false
}

strings.IndexByte/IndexRune 判断指定ASCII码值在s字符串中的位置，不存在返回-1

a-z：97-122
A-Z：65-90
0-9：48-57
func main()  {
	s:="hello word jeff aaa"
	fmt.Println(strings.IndexByte(s,97))  // 16
  fmt.Println(strings.IndexByte(s,'a'))  // 16
	fmt.Println(strings.IndexByte(s,98))  // -1
}

strings.Index 判断字符串p在s字符串出现的位置，不存在返回-1

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Index(s,"word"))  // 6
	fmt.Println(strings.Index(s,"h"))  // 1
	fmt.Println(strings.Index(s,"kkk"))  // -1
}

strings.IndexAny 字符串p中的任一utf-8码值在s中第一次出现的位置,没有返回-1

func main()  {
	s:="hello word jeff aaa"
	fmt.Println(strings.IndexAny(s,"ekkk"))  // 1
	fmt.Println(strings.IndexAny(s,"kkk"))  // -1
}

strings.Title 首字母都改为大写

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Title(s))  //Hello Word Jeff
  fmt.Println(strings.ToTitle(s))  //Hello Word Jeff  标题版
}

strings.ToLower 所有转小写

func main()  {
	s:="HELLO WORD JEFF"
	fmt.Println(strings.ToLower(s))  //hello word jeff
}

strings.ToUpper 所有转大写

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.ToUpper(s))  //HELLO WORD JEFF
}

strings.Repeat 拷贝n个s字符串

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Repeat(s,2))  //hello word jeffhello word jeff
}

strings.Replace 字符串替换

返回将s中前n个不重叠old子串都替换为new的新字符串，如果n<0会替换所有old子串。
func main()  {
	s:="hello word jeff"
  //前面1个"h"替换为“k”
	fmt.Println(strings.Replace(s,"h","k",1))  //kello word jeff
  
  //所有的"o"替换为"k"
  fmt.Println(strings.Replace(s,"o","k",-1))  //hellk wkrd jeff
}

strings.Trim 返回用p包裹的中间字符串

func main()  {
	s:="!!!hello word jeff !!!"
	fmt.Println(strings.Trim(s,"!"))  //hello word jeff
}

strings.TrimLeft 去掉左边包裹

func main()  {
	s:="!!!hello word jeff !!!"
	fmt.Println(strings.TrimLeft(s,"!"))  //hello word jeff !!!
}

strings.TrimRight 去掉右边包裹

func main()  {
	s:="!!!hello word jeff !!!"
	fmt.Println(strings.TrimRight(s,"!"))  //!!!hello word jeff
}

strings.TrimSpace 去掉前后空格

func main()  {
	s:="   hello word jeff  "
	fmt.Println(strings.TrimSpace(s))  //hello word jeff
}

strings.TrimPrefix 返回去除s可能的前缀prefix的字符串

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.TrimPrefix(s,"hello"))  // word jeff
	fmt.Println(strings.TrimPrefix(s,"word"))  //hello word jeff
}

strings.TrimSuffix 返回去除s可能的后缀prefix的字符串

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.TrimSuffix(s,"jeff"))  //hello word
	fmt.Println(strings.TrimPrefix(s,"word"))  //hello word jeff
}

strings.Fields 字符串按照空格转为切片

func main()  {
	s:="hello word jeff"
	fmt.Println(strings.Fields(s))  //[hello word jeff]
}

strings.Split 切割

func main()  {
   s:="hello,word,jeff"
   fmt.Println(strings.Split(s,","))  //[hello word jeff]
}

strings.SplitN 切割条件

func main()  {
   s:="hello word jeff"
   fmt.Println(strings.SplitN(s,"",3))  //[h e llo word jeff]
}

strings.Join 字符串拼接

func main()  {
	s:= []string{"hello", "word", "jeff"}
	fmt.Println(strings.Join(s,","))  //hello,word,jeff
}


var NetworkSql string
for i := range in.Network {
  NetworkSql = strings.Join([]string{NetworkSql, strconv.Itoa(in.Network[i])}, ",")
}
NetworkSql = string(NetworkSql)[1:]


func main()  {
	var k string
	s:= []int{1, 2, 3}
	for i:= range(s){
		k = strings.Join([]string{ k,strconv.Itoa(i)},",")
	}
	fmt.Println(k) // ,0,1,2
}

鲜花

握手

雷人

路过

鸡蛋

该文章已有0人参与评论

请发表评论

全部评论

专题导读

More+

goprotobuf安装发布时间：2022-07-10

go使用第三方json替换原版json发布时间：2022-07-10

客服电话

电子邮件

GO-常用包

格式说明

输人Scanf类似input

fmt.Sprintf格式化输出

2.查看类型-TypeOf,%T

3.查看长度-len

4.类型转换

string到int

string到int64

int到string

int64到string

float到string

string到float64

string到float32

int到int64

5.十进制任意相互转换

6.查看容量-cap

7.常量定义关键字const

8.常量定义iota枚举

9.append元素追加

10.reflect反射

方法归纳

反射类型判断

reflect.DeepEqual 判断两个map是否相等

reflect.ValueOf 获取值信息

reflect.TypeOf 获取类型信息

reflect.ValueOf(a).SetInt(10) 反射修改值

11.结构体与反射

方法归纳

查看结构体类型、字段和方法

查看匿名字段

修改结构体的值

调用方法

获取字段的tag

12.time模块

打印当前时间戳

str格式化时间

时间戳转str格式化时间

str格式化时间转时间戳

time.Parse格式化时间转时间戳

time.Parse和time.Format的区别

Format

int型时间数字处理

pg时间格式timestamp读取到结构体

示例

13.rand随机

从切片中随机取值

订单编号

雪花算法

14.Go语言标准库flag基本使用

15.MD5使用

16.murmurhash3非加密哈希

17.json

strings.Join字符串拼接

json字符串转换

redis map转结构体

json字符串转结构体

例子2：[{},{},{}]

例子3：map[],redis hash

18.编码转换

19.操作kafka

20.操作rabitMQ

21.decimal加减乘除

类型转换

加法 Add

减法 Sub

乘法 Mul

除法 Div

22.in

23.排序

字符串排序

切片排序

24.math数学计算

25.strings

strings.EqualFold 判断两个utf-8编码字符串是否相同

strings.HasPrefix 判断s字符串是否有前缀字符串p

strings.HasSuffix 判断s字符串是否有后缀缀字符串p

strings.Count 判断s字符串有几个不重复的sep子串