文章目录：
[TOC]

## 不要使用 + 和 fmt.Sprintf 操作字符串

不要使用 `+` 和 `fmt.Sprintf` 操作字符串，虽然很方便，但是真的很慢！

我们要使用 `bytes.NewBufferString` 进行处理。

基准测试如下：

### +

```
func BenchmarkStringOperation1(b *testing.B)  {
	b.ResetTimer()
	str := ""
	for i := 0; i < b.N; i++ {
		str += "golang"
	}
}

// 输出
goos: darwin
goarch: amd64
pkg: demo/stringoperation
cpu: Intel(R) Core(TM) i7-8700B CPU @ 3.20GHz
BenchmarkStringOperation1
BenchmarkStringOperation1-12    	  353318	    114135 ns/op
PASS

Process finished with the exit code 0
```

### fmt.Sprintf

```
func BenchmarkStringOperation2(b *testing.B)  {
	b.ResetTimer()
	str := ""
	for i := 0; i < b.N; i++ {
		str = fmt.Sprintf("%s%s", str, "golang")
	}
}

// 输出
goos: darwin
goarch: amd64
pkg: demo/stringoperation
cpu: Intel(R) Core(TM) i7-8700B CPU @ 3.20GHz
BenchmarkStringOperation2
BenchmarkStringOperation2-12    	  280140	    214098 ns/op
PASS

Process finished with the exit code 0
```

### bytes.NewBufferString

```
func BenchmarkStringOperation3(b *testing.B)  {
	b.ResetTimer()
	strBuf := bytes.NewBufferString("")
	for i := 0; i < b.N; i++ {
		strBuf.WriteString("golang")
	}
}

// 输出
goos: darwin
goarch: amd64
pkg: demo/stringoperation
cpu: Intel(R) Core(TM) i7-8700B CPU @ 3.20GHz
BenchmarkStringOperation3
BenchmarkStringOperation3-12    	161292136	         8.582 ns/op
PASS

Process finished with the exit code 0
```
## 对于固定字段的键值对，不要使用 map[string]interface{}

对于固定字段的键值对，不要使用 `map[string]interface{}`!

我们要使用`临时 Struct`。

基准测试如下：

### map[string]interface{}

```
func BenchmarkStructOperation1(b *testing.B) {
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		var demo = map[string]interface{}{}
		demo["Name"] = "Tom"
		demo["Age"] = 30
	}
}

// 输出
goos: darwin
goarch: amd64
pkg: demo/structoperation
cpu: Intel(R) Core(TM) i7-8700B CPU @ 3.20GHz
BenchmarkStructOperation1
BenchmarkStructOperation1-12    	43300134	        27.97 ns/op
PASS

Process finished with the exit code 0
```

### 临时 Struct

```
func BenchmarkStructOperation2(b *testing.B) {
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		var demo struct {
			Name string
			Age  int
		}
		demo.Name = "Tom"
		demo.Age = 30
	}
}

// 输出
oos: darwin
goarch: amd64
pkg: demo/structoperation
cpu: Intel(R) Core(TM) i7-8700B CPU @ 3.20GHz
BenchmarkStructOperation2
BenchmarkStructOperation2-12    	1000000000	         0.2388 ns/op
PASS

Process finished with the exit code 0
```

## 小结

你有类似这样的注意点吗，欢迎留言~ 

下面推荐阅读的这几篇文章也是关于开发中需要知道的小技术点，更多技术细节和代码讨论，可以加入到我的星球。

### 推荐阅读

- [函数的不定参数你是这样用吗？](https://mp.weixin.qq.com/s/jvSbZ0_g_EFqaR2TmjjO8w)
- [优雅地处理错误真是一门学问啊！](https://mp.weixin.qq.com/s/W_LsZtnjGIKQ-LB6EkRgBA)
- [如何设计 API 接口，实现统一格式返回？](https://mp.weixin.qq.com/s/6c6uapjIzJC9wmjUFyZuZA)


17-分享两个在开发中需注意的小点

在开发过程中，我们有时会遇到这样的问题，将 `2020-11-08T08:18:46+08:00` 转成 `2020-11-08 08:18:46`，怎么解决这个问题？

解决这个问题，最好不要用字符串截取，或者说字符串截取是最笨的方法，这应该是时间格式化的问题。

我们先看一下 golang time 包中支持的 format 格式：

```
const (
	ANSIC       = "Mon Jan _2 15:04:05 2006"
	UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
	RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
	RFC822      = "02 Jan 06 15:04 MST"
	RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
	RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
	RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
	RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
	RFC3339     = "2006-01-02T15:04:05Z07:00"
	RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
	Kitchen     = "3:04PM"
	// Handy time stamps.
	Stamp      = "Jan _2 15:04:05"
	StampMilli = "Jan _2 15:04:05.000"
	StampMicro = "Jan _2 15:04:05.000000"
	StampNano  = "Jan _2 15:04:05.000000000"
)
```

我们找到了 `RFC3339` ，那就很简单了，我们封装一个方法 `RFC3339ToCSTLayout`，见下面代码。

```
package timeutil

import "time"

var (
	cst *time.Location
)

// CSTLayout China Standard Time Layout
const CSTLayout = "2006-01-02 15:04:05"

func init() {
	var err error
	if cst, err = time.LoadLocation("Asia/Shanghai"); err != nil {
		panic(err)
	}
}

// RFC3339ToCSTLayout convert rfc3339 value to china standard time layout
func RFC3339ToCSTLayout(value string) (string, error) {
	ts, err := time.Parse(time.RFC3339, value)
	if err != nil {
		return "", err
	}

	return ts.In(cst).Format(CSTLayout), nil
}

```

## 运行一下

```
RFC3339Str := "2020-11-08T08:18:46+08:00"
cst, err := timeutil.RFC3339ToCSTLayout(RFC3339Str)
if err != nil {
	fmt.Println(err)
}
fmt.Println(cst)
```

输出：

```
2020-11-08 08:18:46
```

## 小结

同理，若遇到 `RFC3339Nano`、`RFC822`、`RFC1123` 等格式，也可以使用类似的方法，只需要在 `time.Parse()` 中指定时间格式即可。

15-time

**文章目录：**
[TOC]

## 前言

为什么需要了解逃逸分析？

因为我们想要提升程序性能，通过逃逸分析我们能够知道变量是分配到堆上还是栈上，如果分配到栈上，内存的分配和释放都是由编译器进行管理，分配和释放的速度非常快，如果分配到堆上，堆不像栈那样可以自动清理，它会引起频繁地进行垃圾回收（`GC`），而垃圾回收会占用比较大的系统开销。

## 什么是逃逸分析？

> 在编译程序优化理论中，逃逸分析是一种确定指针动态范围的方法，简单来说就是分析在程序的哪些地方可以访问到该指针。

简单的说，它是在对变量放到堆上还是栈上进行分析，该分析在编译阶段完成。如果一个变量超过了函数调用的生命周期，也就是这个变量在函数外部存在引用，编译器会把这个变量分配到堆上，这时我们就说这个变量发生逃逸了。

## 如何确定是否逃逸？

```
go run -gcflags '-m -l' main.go
```

## 可能出现逃逸的场景

### 01

```
package main

type Student struct {
	Name interface{}
}

func main()  {
	stu := new(Student)
	stu.Name = "tom"

}
```

分析结果：

```
go run -gcflags '-m -l' 01.go
# command-line-arguments
./01.go:8:12: new(Student) does not escape
./01.go:9:11: "tom" escapes to heap
```

`interface{}` 赋值，会发生逃逸，优化方案是将类型设置为固定类型，例如：`string`

```
package main

type Student struct {
	Name string
}

func main()  {
	stu := new(Student)
	stu.Name = "tom"

}
```

分析结果：

```
go run -gcflags '-m -l' 01.go
# command-line-arguments
./01.go:8:12: new(Student) does not escape
```

### 02

```
package main

type Student struct {
	Name string
}

func GetStudent() *Student {
	stu := new(Student)
	stu.Name = "tom"
	return stu
}

func main() {
	GetStudent()
}

```

分析结果：

```
go run -gcflags '-m -l' 02.go
# command-line-arguments
./02.go:8:12: new(Student) escapes to heap
```

返回指针类型，会发生逃逸，优化方案视情况而定。

函数传递指针和传值哪个效率高吗？我们知道传递指针可以减少底层值的拷贝，可以提高效率，但是如果拷贝的数据量小，由于指针传递会产生逃逸，可能会使用堆，也可能会增加 `GC` 的负担，所以传递指针不一定是高效的。

不要盲目使用变量指针作为参数，虽然减少了复制，但变量逃逸的开销可能更大。

### 03

```
package main

func main() {
	nums := make([]int, 10000, 10000)

	for i := range nums {
		nums[i] = i
	}
}
```

分析结果：

```
go run -gcflags '-m -l' 03.go
# command-line-arguments
./03.go:4:14: make([]int, 10000, 10000) escapes to heap
```

栈空间不足，会发生逃逸，优化方案尽量设置容量，如果容量实在过大那就没办法了。

## 小结

1. 逃逸分析是编译器在静态编译时完成的。
2. 逃逸分析后可以确定哪些变量可以分配在栈上，栈的性能好。

以上，希望对你能够有所帮助。

## 推荐阅读

- [Go - 使用 sync.Pool 来减少 GC 压力](https://mp.weixin.qq.com/s/0NVp59uI8h9WTp68wtb7XQ)
- [Go - 使用 options 设计模式](https://mp.weixin.qq.com/s/jvSbZ0_g_EFqaR2TmjjO8w)
- [Go - json.Unmarshal 遇到的小坑](https://mp.weixin.qq.com/s/ykZCZb9IAXJaKAx_cO7YjA)
- [Go - 两个在开发中需注意的小点](https://mp.weixin.qq.com/s/-QCG61vh6NVJUWz6tOY7Gw)
- [Go - time.RFC3339 时间格式化](https://mp.weixin.qq.com/s/1pFVaMaWItp8zCXotQ9iBg)

19-基于逃逸分析来提升程序性能

## 概述

最近掉进需求坑了，刚爬上来，评估排期出现了严重问题，下面三张图很符合当时的心境。

谈需求

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/11_go_1.jpeg)

估排期

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/11_go_2.jpeg)

开始干

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/11_go_3.jpeg)

为啥会这样，我简单总结了下：

- 与第三方对接。
- 跨团队对接。
- 首次用 Go 做项目。
- 业务流程没屡清楚就出排期（大坑）。
- 需求调整后未进行调整排期（大坑）。

有了这次经验，后期关于如何评估排期也可以和大家唠唠。

废话不多说了，进入今天主题。

今天给大家分享用 Go 如何解析 JSON 数据，包含三种情况，强类型解析、弱类型解析、返回结构不确定 等。

## JSON 结构

比如，请求了手机归属地的接口，json 数据返回如下：

```
{
    "resultcode": "200",
    "reason": "Return Successd!",
    "result": {
        "province": "浙江",
        "city": "杭州",
        "areacode": "0571",
        "zip": "310000",
        "company": "中国移动",
        "card": ""
    }
}
```

思路是这样的：

1.先将 json 转成 struct。

2.然后 `json.Unmarshal()` 即可。

json 转 struct ，自己手写就太麻烦了，有很多在线的工具可以直接用，我用的这个：

https://mholt.github.io/json-to-go/

在左边贴上 json 后面就生成 struct 了。

用代码实现下：

```
type MobileInfo struct {
	Resultcode string `json:"resultcode"`
	Reason     string `json:"reason"`
	Result     struct {
		Province string `json:"province"`
		City     string `json:"city"`
		Areacode string `json:"areacode"`
		Zip      string `json:"zip"`
		Company  string `json:"company"`
		Card     string `json:"card"`
	} `json:"result"`
}

func main() {
	jsonStr := `
		{
			"resultcode": "200",
			"reason": "Return Successd!",
			"result": {
				"province": "浙江",
				"city": "杭州",
				"areacode": "0571",
				"zip": "310000",
				"company": "中国移动",
				"card": ""
			}
		}
	`

	var mobile MobileInfo
	err := json.Unmarshal([]byte(jsonStr), &mobile)
	if err != nil {
		fmt.Println(err.Error())
	}
	fmt.Println(mobile.Resultcode)
	fmt.Println(mobile.Reason)
	fmt.Println(mobile.Result.City)
}
```

输出：

```
200
Return Successd!
杭州
```

完美解析。

到这问题还没结束，思考下这些问题：

如果 json 格式的数据类型不确定怎么办？

如果 json 格式的数据 result 中参数不固定怎么办？

思路是这样的：

去 github 上找开源类库，哈哈，我使用的是这个：

https://github.com/mitchellh/mapstructure

咱们一起学习下，先解决第一个问题，数据类型不确定怎么办？

先定义一个 string 类型的 resultcode，json 却返回了 int 类型的 resultcode。

看文档有一个弱类型解析的方法 `WeakDecode()`，咱们试一下：

```
type MobileInfo struct {
	Resultcode string `json:"resultcode"`
}

func main() {
	jsonStr := `
		{
			"resultcode": 200
		}
	`

	var result map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &result)
	if err != nil {
		fmt.Println(err.Error())
	}

	var mobile MobileInfo
	err = mapstructure.WeakDecode(result, &mobile)
	if err != nil {
		fmt.Println(err.Error())
	}

	fmt.Println(mobile.Resultcode)
}
```

输出：

200

第一个问题已解决。

再解决第二个问题，result 中参数不固定怎么办？

这个就不用上面的例子了，看下官方提供的例子 `Example (EmbeddedStruct)` 。

```
type Family struct {
	LastName string
}
type Location struct {
	City string
}
type Person struct {
	Family    `mapstructure:",squash"`
	Location  `mapstructure:",squash"`
	FirstName string
}

func main() {
	input := map[string]interface{}{
		"FirstName": "Mitchell",
		"LastName":  "Hashimoto",
		"City":      "San Francisco",
	}

	var result Person
	err := mapstructure.Decode(input, &result)
	if err != nil {
		panic(err)
	}

	fmt.Println(result.FirstName)
	fmt.Println(result.LastName)
	fmt.Println(result.City)
}
```

输出：

```
Mitchell
Hashimoto
San Francisco
```

使用的是 mapstructure 包，struct tag 标识不要写 json，要写 mapstructure。

其他情况自己探索吧，比如： `Example (Tags)`。

## go-gin-api 系列文章

- [7. 路由中间件 - 签名验证](https://mp.weixin.qq.com/s/0cozELotcpX3Gd6WPJiBbQ)
- [6. 路由中间件 - Jaeger 链路追踪（实战篇）](https://mp.weixin.qq.com/s/Ea28475_UTNaM9RNfgPqJA)
- [5. 路由中间件 - Jaeger 链路追踪（理论篇）](https://mp.weixin.qq.com/s/28UBEsLOAHDv530ePilKQA)
- [4. 路由中间件 - 捕获异常](https://mp.weixin.qq.com/s/SconDXB_x7Gan6T0Awdh9A)
- [3. 路由中间件 - 日志记录](https://mp.weixin.qq.com/s/eTygPXnrYM2xfrRQyfn8Tg)
- [2. 规划项目目录和参数验证](https://mp.weixin.qq.com/s/11AuXptWGmL5QfiJArNLnA)
- [1. 使用 go modules 初始化项目](https://mp.weixin.qq.com/s/1XNTEgZ0XGZZdxFOfR5f_A)


11-解析 JSON 数据

在 Go 语言中，一个 struct 实现了某个接口里的所有方法，就叫做这个 struct 实现了该接口。

下面写一个 Demo 实现一下，先写一个 Study interface{}，里面需要实现 4 个方法 Listen、Speak、Read、Write，然后再写一个 study struct{}，去全部实现里面的方法，然后分享一下代码心得。

## 代码示例

```
// main.go

package main

import (
	"demo/study"
	"fmt"
)

func main() {
	name := "Tom"
	s, err := study.New(name)
	if err != nil {
		fmt.Println(err)
	}

	fmt.Println(s.Listen("english"))
	fmt.Println(s.Speak("english"))
	fmt.Println(s.Read("english"))
	fmt.Println(s.Write("english"))
}

// 输出
Tom 听 english
Tom 说 english
Tom 读 english
Tom 写 english
```

```
// study.go

package study

import "github.com/pkg/errors"

var _ Study = (*study)(nil)

type Study interface {
	Listen(msg string) string
	Speak(msg string) string
	Read(msg string) string
	Write(msg string) string
}

type study struct {
	Name string
}

func (s *study) Listen(msg string) string {
	return s.Name + " 听 " + msg
}

func (s *study) Speak(msg string) string {
	return s.Name + " 说 " + msg
}

func (s *study) Read(msg string) string {
	return s.Name + " 读 " + msg
}

func (s *study) Write(msg string) string {
	return s.Name + " 写 " + msg
}

func New(name string) (Study, error) {
	if name == "" {
		return nil, errors.New("name required")
	}

	return &study{
		Name: name,
	}, nil
}


```

## 代码解释

#### 一、

```
var _ Study = (*study)(nil)
```

要求 `*study` 去实现 `Study`，若 `Study` 接口被更改或未全部实现时，在编译时就会报错。

#### 二、

```
type study struct {
	Name string
}
```

之所以定义为私有的结构体，是因为不想在其他地方被使用，比如后面将 `Name` 改成 `UserName` 只需要在本包内修改即可。

#### 三、

```
func New(name string) (Study, error) {
	if name == "" {
		return nil, errors.New("name required")
	}

	return &study{
		Name: name,
	}, nil
}
```

在其他地方调用 `New()` 使用 `Study` 包时，仅对外暴露了 4 个方法，别人只管调用就好了，内部实现别人无需关心。

