Go的一些基本操作

一些常用的基本操作

注意 ：后面的show = fmt.Println

---

一、对时间的操作

// 测试时间的一些操作
func testTime() {
	now := time.Now()
	t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)

	show(t.Year(), t.Day(), t.Month(), t.Hour())
	show(t)
	// 将时间按照对应的格式转化 类似于YYY-MMM那种  但是go 的是固定这个时间
	show(t.Format("2006-01-02 15:04:05"))
	show(now.Unix())
	// 字符串转 time.Time 类型
	t3, err := time.Parse("2006-01-02 15:04:05", "2006-01-02 15:04:05")
	if err != nil {
		show(err.Error)
	}
	show(t3)
	// 时间做差
	show(t.Sub(now))
}

运行结果：
2022 27 March 1
2022-03-27 01:25:36 +0000 UTC
2022-03-27 01:25:36
1651917278
2006-01-02 15:04:05 +0000 UTC
-992h29m2.8780566s

---

二、字符串的基本操作？

// 字符串的一些基本操作
func testString() {
	a := "hello"

	show(strings.Contains(a, "ll"))
	show(strings.Count(a, "l"))

	show(strings.HasPrefix(a, "he"))
	show(strings.HasSuffix(a, "lo"))
	show(strings.Join([]string{"he", "llo"}, "-"))
	show(strings.Repeat(a, 2))
	// 最后一个参数为替换的个数，如果小于零就不限制替换的个数
	show(strings.Replace(a, "e", "E", -1))
	// 字符串的大小写转化
	show(strings.ToLower(a))
	show(strings.ToUpper(a))
	b := "你好"
	// 展现的是字节的长度
	show(len(b))
}

运行结果：
true
2
true
true
he-llo
hellohello
hEllo
hello
HELLO
6

三、字符串转数字

// 字符串转数字
func TestNumber() {
	f, _ := strconv.ParseFloat("1.234", 64)
	show(f)

	n, _ := strconv.ParseInt("111", 10, 64)
	show(n)

	n, _ = strconv.ParseInt("0x10", 0, 64)
	show(n)

	// string 转 int
	ss, _ := strconv.Atoi("123")
	show(ss)

	ss, err := strconv.Atoi("AAA")
	if err != nil {
		show(err.Error)
	}
	show(ss)
}

运行结果：
1.234
111
16
123
0xe77c80
0

---

四、JSON数据的处理

type userInfo struct {
	Name  string
	Age   int `json:"age"`
	Hobby []string
}

// json 的序列化与解析
func TestJson() {
	a := userInfo{"wang", 18, []string{"Go", "Game"}}
	buf, err := json.Marshal(a)
	if err != nil {
		panic(err)
	}
	show(string(buf))
	buf, err = json.MarshalIndent(a, "", "\t")
	if err != nil {
		panic(err)
	}
	show(string(buf))

	var b userInfo
	err = json.Unmarshal(buf, &b)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%#v\n", b)
}

运行结果:

五、range 的基本使用和坑

// range 的使用和坑
func TestRange() {
	a := []string{"a", "b", "c"}

	// range 的基本使用
	for index, val := range a {
		show(index, val)
	}
	// 坑出现的地方
	// 这里并不会出现无限循环的情况
	// 说明在对a 进行range操作的时候会先对a进行一次值拷贝
	for _, val := range a {
		a = append(a, val)
	}
	show(a)
	// 其中的index 和 val 的地址是不变的
	for index, val := range a {
		show(&index, &val)
	}
}

输出结果：
0 a
1 b
2 c
[a b c a b c]
0xc000016108 0xc00004c390
0xc000016108 0xc00004c390
0xc000016108 0xc00004c390
0xc000016108 0xc00004c390
0xc000016108 0xc00004c390
0xc000016108 0xc00004c390

结论： range 的原理大致是先对可迭代对象先进行一次值拷贝，然后在遍历的时候将数值拷贝给给定的index和val 的地址里面（且不发生变化，这样应该可以减少重复创建和销毁内存操作带来的消耗）

六、格式化输出

// 一些格式化输出的操作
func TestPrint() {
	type point struct {
		x, y int
	}

	s := "yyw"
	n := 123
	p := point{12, 232}
	fmt.Println(s, n) // hello
	fmt.Println(p)    // {1,2}

	fmt.Printf("p=%v\n", p)
	fmt.Printf("p=%+v\n", p)
	fmt.Printf("p=%#v\n", p)

	nn := 2.7543
	fmt.Printf("%v\n", nn)
	fmt.Printf("%.2f\n", nn)
}

运行结果：
yyw 123
{12 232}
p={12 232}
p={x:12 y:232}
p=main.point{x:12, y:232}
2.7543
2.7543
2.75

七字符串的多种拼接方式

// 字符串拼接的多种方式
func TestStringJoint() {
	str := "abcde"
	repeat := 100000

	// 直接使用 + 去拼接
	fn1 := func() {
		a := ""
		for i := 0; i < repeat; i++ {
			a += str
		}
		fmt.Println(len(a))
	}
	time.Sleep(time.Second * 5)
	start := time.Now()
	fn1()
	show(time.Since(start))

	// 使用 Repeat 拼接
	fn2 := func() {
		strings.Repeat(str, repeat)
		// fmt.Println(len(b))
	}
	time.Sleep(time.Second * 5)
	start = time.Now()
	fn2()
	show(time.Since(start))

	// 使用 strings.Builder 进行拼接
	fn3 := func() {
		var sw strings.Builder
		for i := 0; i < repeat; i++ {
			sw.WriteString(str)
		}
		// fmt.Println(len(sw.String()))
	}
	time.Sleep(time.Second * 5)
	start = time.Now()
	fn3()
	show(time.Since(start))

	// 使用字节的方法进行拼接
	fn4 := func() {
		buf := make([]byte, len(str)*repeat)
		for i := 0; i < repeat; i++ {
			buf = append(buf, str...)
		}
		// fmt.Println(len(string(buf)))
	}
	time.Sleep(time.Second * 5)
	start = time.Now()
	fn4()
	show(time.Since(start))

}

运行结果：
7.1576304s
0s
1.0023ms
0s

结果的比较： 还没有对第二种方法进行比较，不过一般后三种方法的性能是第一种方法的几百倍，然后第四种方法优于第三种方法,第二种方法和第四种应该相当还没有进行测试。

还有其他的关于go高性能操作比较的可以参考 https://geektutu.com/post/hpg-string-concat.html

八、reflect 的基本使用

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name string `json:"name" redis:"Name"`
	Age  int    `json:"age"`
	Sex  string `json:"sex"`
}

// 初始化Person类型
func InitPerson() *Person {
	return &Person{"ywh", 0, "无性别"}
}

func main() {
	a := *InitPerson()
	typeofA := reflect.TypeOf(a)


	fmt.Println(typeofA.NumField())
	for i := 0; i < typeofA.NumField(); i++ {
		fmt.Println("第", i, "个字段 -> ", typeofA.Field(i))
		fmt.Printf("第%d个字段的Name是%s\n", i, typeofA.Field(i).Name)
		fmt.Printf("第%d个字段的Tag是%s\n", i, typeofA.Field(i).Tag)
		fmt.Printf("第%d个字段的PkgPath  -> %s\n", i, typeofA.Field(i).PkgPath)
		fmt.Printf("第%d个字段的Offset   -> %c\n", i, typeofA.Field(i).Offset)
		fmt.Printf("第%d个字段的Index是%d\n", i, typeofA.Field(i).Index)
		break
	}
	// struct中的value以数组的形式返回
	// reflect.ValueOf
	vals := reflect.ValueOf(a)
	fmt.Printf("%T\n", vals)
	for i := 0; i < vals.NumField(); i++ {
		fmt.Printf("第%d个字段的值是%v\n", i, vals.Field(i))
	}
}

输出的结果
values -> {ywh 0 无性别}
3
第 0 个字段 -> {Name string json:“name” redis:“Name” 0 [0] false}
第0个字段的Name是Name
第0个字段的Tag是json:“name” redis:“Name”
第0个字段的PkgPath ->
第0个字段的Offset ->
第0个字段的Index是[0]
reflect.Value
第0个字段的值是ywh
第1个字段的值是0
第2个字段的值是无性别

方法名	作用
ValueOf	获取对应数据的上的值，并且以数组的形式返回
TypeOf	获取对应的struct上设定的字段信包含Name(字段名)、Tag(设定的标签)、Index（字段的索引）