## 1.问题现象描述

使用 `json.Unmarshal()`，反序列化时，出现了科学计数法，参考代码如下：

```
jsonStr := `{"number":1234567}`
result := make(map[string]interface{})
err := json.Unmarshal([]byte(jsonStr), &result)
if err != nil {
	fmt.Println(err)
}
fmt.Println(result)

// 输出
// map[number:1.234567e+06]
```

这个问题不是必现，只有当数字的位数大于 6 位时，才会变成了科学计数法。

## 2.问题影响描述

当数据结构未知，使用 `map[string]interface{}` 来接收反序列化结果时，如果数字的位数大于 6 位，都会变成科学计数法，用到的地方都会受到影响。

## 3.引起问题的原因

从 `encoding/json` 可以找到答案，看一下这段注释：

```
// To unmarshal JSON into an interface value,
// Unmarshal stores one of these in the interface value:
//
//	bool, for JSON booleans
//	float64, for JSON numbers
//	string, for JSON strings
//	[]interface{}, for JSON arrays
//	map[string]interface{}, for JSON objects
//	nil for JSON null
```

是因为当 `JSON` 中存在一个比较大的数字时，它会被解析成 `float64` 类型，就有可能会出现科学计数法的形式。

## 4.问题的解决方案

**方案一**

强制类型转换，参考代码如下：

```
jsonStr := `{"number":1234567}`
result := make(map[string]interface{})
err := json.Unmarshal([]byte(jsonStr), &result)
if err != nil {
	fmt.Println(err)
}
fmt.Println(int(result["number"].(float64)))

// 输出
// 1234567
```

**方案二**

尽量避免使用 `interface`，对 `json` 字符串结构定义结构体，快捷方法可使用在线工具：`https://mholt.github.io/json-to-go/`。

```
type Num struct {
	Number int `json:"number"`
}

jsonStr := `{"number":1234567}`
var result Num
err := json.Unmarshal([]byte(jsonStr), &result)
if err != nil {
	fmt.Println(err)
}
fmt.Println(result)

// 输出
// {1234567}
```

**方案三**

使用 `UseNumber()` 方法。

```
jsonStr := `{"number":1234567}`
result := make(map[string]interface{})
d := json.NewDecoder(bytes.NewReader([]byte(jsonStr)))
d.UseNumber()
err := d.Decode(&result)
if err != nil {
	fmt.Println(err)
}
fmt.Println(result)

// 输出
// map[number:1234567]
```

这时一定要注意 `result["number"]` 的数据类型！

```
fmt.Println(fmt.Sprintf("type: %v", reflect.TypeOf(result["number"])))

// 输出
// type: json.Number
```

通过代码可以看出 `json.Number` 其实就是字符串类型：

```
// A Number represents a JSON number literal.
type Number string
```

如果转换其他类型，参考如下代码：

```
// 转成 int64
numInt, _ := result["number"].(json.Number).Int64()
fmt.Println(fmt.Sprintf("value: %v, type: %v", numInt, reflect.TypeOf(numInt)))

// 输出
// value: 1234567, type: int64

// 转成 string
numStr := result["number"].(json.Number).String()
fmt.Println(fmt.Sprintf("value: %v, type: %v", numStr, reflect.TypeOf(numStr)))

// 输出
// value: 1234567, type: string
```

12-json

## 概述

defer 函数大家肯定都用过，它在声明时不会立刻去执行，而是在函数 return 后去执行的。

它的主要应用场景有异常处理、记录日志、清理数据、释放资源 等等。

这篇文章不是分享 defer 的应用场景，而是分享使用 defer 需要注意的点。

咱们先从一道题开始，一起来感受下 ...

```
func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	defer calc("A", x, calc("B", x, y))
	x = 3
	defer calc("C", x, calc("D", x, y))
	y = 4
}
```

输出什么？

...

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/10_go_1.jpeg)

接下来，先容我分享几个小例子，再进行作答。

## 执行顺序

```
func main() {

	defer fmt.Println("1")
	defer fmt.Println("2")
	defer fmt.Println("3")

	fmt.Println("main")
}
```

输出：

```
main
3
2
1
```

结论：defer 函数定义的顺序 与 实际执的行顺序是相反的，也就是最先声明的最后才执行。

## 闭包

```
func main() {

	var a = 1
	var b = 2

	defer fmt.Println(a + b)

	a = 2

	fmt.Println("main")
}
```

输出：

```
main
3
```

稍微修改一下，再看看：

```
func main() {
	var a = 1
	var b = 2

	defer func() {
		fmt.Println(a + b)
	}()

	a = 2

	fmt.Println("main")
}
```

输出：

```
main
4
```

结论：闭包获取变量相当于引用传递，而非值传递。

稍微再修改一下，再看看：

```
func main() {
	var a = 1
	var b = 2

	defer func(a int, b int) {
		fmt.Println(a + b)
	}(a, b)

	a = 2

	fmt.Println("main")
}
```

输出：

```
main
3
```

结论：传参是值复制。

还可以理解为：defer 调用的函数，参数的值在 defer 定义时就确定了，看下代码

`defer fmt.Println(a + b)`，在这时，参数的值已经确定了。

而 defer 函数内部所使用的变量的值需要在这个函数运行时才确定，看下代码

`defer func() { fmt.Println(a + b) }()`，a 和 b 的值在函数运行时，才能确定。

## Return

#### 一

```
func t1() int {
	a := 1
	defer func() {
		a++
	}()
	return a
}
```

输出：1

#### 二

```
func t2() (a int) {
	defer func() {
		a++
	}()
	return 1
}
```

输出：2

#### 三

```
func t3() (b int) {
	a := 1
	defer func() {
		a++
	}()
	return 1
}
```

输出：1

#### 四

```
func t4() (a int) {
	defer func(a int) {
		a++
	}(a)
	return 1
}
```

输出：1

结论：return 不是原子操作。

## os.Exit

```
func main() {
	defer fmt.Println("1")
	fmt.Println("main")
	os.Exit(0)
}
```

输出：main

结论：当`os.Exit()`方法退出程序时，defer不会被执行。

## 不同协程

```
func main() {
	GoA()
	time.Sleep(1 * time.Second)
	fmt.Println("main")
}

func GoA() {
	defer (func(){
		if err := recover(); err != nil {
			fmt.Println("panic:" + fmt.Sprintf("%s", err))
		}
	})()

	go GoB()
}

func GoB() {
	panic("error")
}
```

`GoB()` panic 捕获不到。

结论：defer 只对当前协程有效。

这个问题怎么解？咱们下回再说。

接下来，咱们分析下文章开头的问题吧。

## 答案解析

先列出答案：

```
B 1 2 3
D 3 2 5
C 3 5 8
A 1 3 4
```

其实上面那道题，可以拆解为：

```
func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	tmp1 := calc("B", x, y)
	defer calc("A", x, tmp1)
	x = 3
	tmp2 := calc("D", x, y)
	defer calc("C", x, tmp2)
	y = 4
}
```

所以顺序就是：B D C A。

执行到 tmp1 时，输出：B 1 2 3。

执行到 tmp2 时，输出：D 3 2 5。

根据 defer 执行顺序原则，先声明的后执行，所以下一个该执行 C 了。

又因为传参是值赋值，所以在 A 的时候，无法用到 `x = 3` 和 `y = 4`，在 C 的时候，无法用到 `y = 4`。

执行到 C 时，输出：C 3 5 8

执行到 A 时，输出：A 1 3 4

到这，基本上 defer 就清楚了，大家可以根据自己的理解去记忆。

## 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)

10-defer 函数

## 概述

原来分享基础语法的时候，还未分享过 chan 通道，这次把它补上。

chan 可以理解为队列，遵循先进先出的规则。

在说 chan 之前，咱们先说一下 go 关键字。

在 go 关键字后面加一个函数，就可以创建一个线程，函数可以为已经写好的函数，也可以是匿名函数。

举个例子：

```
func main() {
	fmt.Println("main start")

	go func() {
		fmt.Println("goroutine")
	}()

	fmt.Println("main end")
}
```

输出：

```
main start
main end
```

为什么没有输出 goroutine ？

首先，我们清楚 Go 语言的线程是并发机制，不是并行机制。

那么，什么是并发，什么是并行？

并发是不同的代码块交替执行，也就是交替可以做不同的事情。

并行是不同的代码块同时执行，也就是同时可以做不同的事情。

举个生活化场景的例子：

你正在家看书，忽然电话来了，然后你接电话，通话完成后继续看书，这就是并发，看书和接电话交替做。

如果电话来了，你一边看书一遍接电话，这就是并行，看书和接电话一起做。

说回上面的例子，为什么没有输出 goroutine ？

main 函数是一个主线程，是因为主线程执行太快了，子线程还没来得及执行，所以看不到输出。

现在让主线程休眠 1 秒钟，再试试。

```
func main() {
	fmt.Println("main start")

	go func() {
		fmt.Println("goroutine")
	}()

	time.Sleep(1 * time.Second)

	fmt.Println("main end")
}
```

输出：

```
main start
goroutine
main end
```

这就对了。

接下来，看看如何使用 chan 。

## 声明 chan

```
// 声明不带缓冲的通道
ch1 := make(chan string)

// 声明带10个缓冲的通道
ch2 := make(chan string, 10)

// 声明只读通道
ch3 := make(<-chan string)

// 声明只写通道
ch4 := make(chan<- string)
```

注意：

不带缓冲的通道，进和出都会阻塞。

带缓冲的通道，进一次长度 +1，出一次长度 -1，如果长度等于缓冲长度时，再进就会阻塞。

## 写入 chan

```
ch1 := make(chan string, 10)

ch1 <- "a"
```

## 读取 chan

```
val, ok := <- ch1
// 或
val := <- ch1
```

## 关闭 chan 

```
close(chan)
```

注意：

- close 以后不能再写入，写入会出现 panic
- 重复 close 会出现 panic
- 只读的 chan 不能 close
- close 以后还可以读取数据


## 示例

```
func main() {
	fmt.Println("main start")
	ch := make(chan string)
	ch <- "a" // 入 chan
	go func() {
		val := <- ch // 出 chan
		fmt.Println(val)
	}()
	fmt.Println("main end")
}
```

输出：

```
main start
fatal error: all goroutines are asleep - deadlock!
```

What ? 这是为啥，刚开始就出师不利呀？

因为，定义的是一个无缓冲的 chan，赋值后就陷入了阻塞。

怎么解决它？

声明一个有缓冲的 chan。

```
func main() {
	fmt.Println("main start")
	ch := make(chan string, 1)
	ch <- "a" // 入 chan
	go func() {
		val := <- ch // 出 chan
		fmt.Println(val)
	}()
	fmt.Println("main end")
}
```

输出：

```
main start
main end
```

为啥没有输出 a , 和前面一样，主线程执行太快了，加个休眠 1 秒钟，再试试。

```
func main() {
	fmt.Println("main start")
	ch := make(chan string, 1)
	ch <- "a" // 入 chan
	go func() {
		val := <- ch // 出 chan
		fmt.Println(val)
	}()
	time.Sleep(1 * time.Second)
	fmt.Println("main end")
}
```

输出：

```
main start
a
main end
```

这就对了。

再看一个例子：

```
func main() {
	fmt.Println("main start")
	ch := make(chan string)
	go func() {
		ch <- "a" // 入 chan
	}()
	go func() {
		val := <- ch // 出 chan
		fmt.Println(val)
	}()
	time.Sleep(1 * time.Second)
	fmt.Println("main end")
}
```

输出：

```
main start
a
main end
```

再看一个例子：

```
func producer(ch chan string) {
	fmt.Println("producer start")
	ch <- "a"
	ch <- "b"
	ch <- "c"
	ch <- "d"
	fmt.Println("producer end")
}

func main() {
	fmt.Println("main start")
	ch := make(chan string, 3)
	go producer(ch)

	time.Sleep(1 * time.Second)
	fmt.Println("main end")
}
```

输出：

```
main start
producer start
main end
```

带缓冲的通道，如果长度等于缓冲长度时，再进就会阻塞。

再看一个例子：

```
func producer(ch chan string) {
	fmt.Println("producer start")
	ch <- "a"
	ch <- "b"
	ch <- "c"
	ch <- "d"
	fmt.Println("producer end")
}

func customer(ch chan string) {
	for {
		msg := <- ch
		fmt.Println(msg)
	}
}

func main() {
	fmt.Println("main start")
	ch := make(chan string, 3)
	go producer(ch)
	go customer(ch)

	time.Sleep(1 * time.Second)
	fmt.Println("main end")
}
```

输出：

```
main start
producer start
producer end
a
b
c
d
main end
```

就到这吧。



09-chan 通道

## 概述

学习了一些基础语法，开始学习写函数了，分享几个自己写的函数。

- MD5
- 获取当前时间戳
- 获取当前时间字符串
- 生成签名

## 函数定义

```
func function_name(input1 type1, input2 type2) (type1, type2) {
   // 函数体
   // 返回多个值
   return value1, value2
}
```

- 函数用 `func` 声明。
- 函数可以有一个或多个参数，需要有参数类型，用 `,` 分割。
- 函数可以有一个或多个返回值，需要有返回值类型，用 `,` 分割。
- 函数的参数是可选的，返回值也是可选的。

## 值传递

传递参数时，将参数复制一份传递到函数中，对参数进行调整后，不影响参数值。

Go 语言默认是值传递。

## 引用传递

传递参数时，将参数的地址传递到函数中，对参数进行调整后，影响参数值。

这个是 [Go - Struct 结构体](https://mp.weixin.qq.com/s/PB3dTnu4DKw7S1-rZD9nmQ)的例子：

```
//demo_13.go
package main

import (
    "encoding/json"
    "fmt"
)

type Result struct {
    Code    int    `json:"code"`
    Message string `json:"msg"`
}

func main() {
    var res Result
    res.Code    = 200
    res.Message = "success"
    toJson(&res)
    
    setData(&res)
    toJson(&res)
}

func setData (res *Result) {
    res.Code    = 500
    res.Message = "fail"
}

func toJson (res *Result) {
    jsons, errs := json.Marshal(res)
    if errs != nil {
        fmt.Println("json marshal error:", errs)
    }
    fmt.Println("json data :", string(jsons))
}
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/08-函数/8_go_0.png)

## MD5

```
// MD5 方法
func MD5(str string) string {
	s := md5.New()
	s.Write([]byte(str))
	return hex.EncodeToString(s.Sum(nil))
}

str := "12345"
fmt.Printf("MD5(%s): %s\n", str, MD5(str))
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/08-函数/8_go_1.png)

## 获取当前时间字符串

```
// xxxx-xx-xx xx:xx:xx
func getTimeStr() string {
	return time.Now().Format("2006-01-02 15:04:05")
}

fmt.Printf("current time str : %s\n", getTimeStr())
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/08-函数/8_go_2.png)

## 获取当前时间戳

```
// 获取当前时间戳
func getTimeInt() int64 {
	return time.Now().Unix()
}

fmt.Printf("current time str : %s\n", getTimeStr())
fmt.Printf("current time unix : %d\n", getTimeInt())
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/08-函数/8_go_3.png)

## 生成签名

```
//demo_26.go
package main

import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"sort"
)

func main() {
	params := map[string]interface{} {
		"name" : "Tom",
		"pwd"  : "123456",
		"age"  : 30,
	}
	fmt.Printf("sign : %s\n", createSign(params))
}

// MD5 方法
func MD5(str string) string {
	s := md5.New()
	s.Write([]byte(str))
	return hex.EncodeToString(s.Sum(nil))
}

// 生成签名
func createSign(params map[string]interface{}) string {
	var key []string
	var str = ""
	for k := range params {
		key   = append(key, k)
	}
	sort.Strings(key)
	for i := 0; i < len(key); i++ {
		if i == 0 {
			str = fmt.Sprintf("%v=%v", key[i], params[key[i]])
		} else {
			str = str + fmt.Sprintf("&xl_%v=%v", key[i], params[key[i]])
		}
	}
	// 自定义密钥
	var secret = "123456789"

	// 自定义签名算法
	sign := MD5(MD5(str) + MD5(secret))
	return sign
}
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/08-函数/8_go_4.png)

对应 PHP 生成签名方法：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/08-函数/8_go_5.png)

有兴趣的可以在签名方法中，增加时间戳 和 secret 在配置文件中读取。

08-函数

## 概述

前几篇文章分享了 array 数组、slice 切片、map 集合，这篇文章分享如何循环获取里面的元素，同时也是对前几篇文章的复习。

本篇文章会用到的关键字 for、range、break、continue、goto、switch。

## 循环 array

```
//demo_18.go
package main

import (
	"fmt"
)

func main() {
	person := [3] string {"Tom", "Aaron", "John"}
	fmt.Printf("len=%d cap=%d array=%v\n", len(person), cap(person), person)
	
	fmt.Println("")

	//循环
	for k, v := range person {
		fmt.Printf("person[%d]: %s\n", k, v)
	}

	fmt.Println("")

	for i := range person {
		fmt.Printf("person[%d]: %s\n", i, person[i])
	}

	fmt.Println("")

	for i := 0; i < len(person); i++ {
		fmt.Printf("person[%d]: %s\n", i, person[i])
	}

	fmt.Println("")

	//使用空白符
	for _, name := range person {
		fmt.Println("name :", name)
	}
}
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/07-循环/7_go_1.png)

## 循环 slice

```
//demo_19.go
package main

import (
	"fmt"
)

func main() {
	person := [] string {"Tom", "Aaron", "John"}
	fmt.Printf("len=%d cap=%d slice=%v\n", len(person), cap(person), person)

	fmt.Println("")

	//循环
	for k, v := range person {
		fmt.Printf("person[%d]: %s\n", k, v)
	}

	fmt.Println("")

	for i := range person {
		fmt.Printf("person[%d]: %s\n", i, person[i])
	}

	fmt.Println("")

	for i := 0; i < len(person); i++ {
		fmt.Printf("person[%d]: %s\n", i, person[i])
	}

	fmt.Println("")

	//使用空白符
	for _, name := range person {
		fmt.Println("name :", name)
	}
}
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/07-循环/7_go_2.png)

## 循环 map

```
//demo_20.go
package main

import (
	"fmt"
)

func main() {
	person := map[int]string{
		1 : "Tom",
		2 : "Aaron",
		3 : "John",
	}

	fmt.Printf("len=%d map=%v\n", len(person), person)

	fmt.Println("")

	//循环
	for k, v := range person {
		fmt.Printf("person[%d]: %s\n", k, v)
	}

	fmt.Println("")

	for i := range person {
		fmt.Printf("person[%d]: %s\n", i, person[i])
	}

	fmt.Println("")

	for i := 1; i <= len(person); i++ {
		fmt.Printf("person[%d]: %s\n", i, person[i])
	}

	fmt.Println("")

	//使用空白符
	for _, name := range person {
		fmt.Println("name :", name)
	}
}
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/07-循环/7_go_3.png)

## break

跳出当前循环，可⽤于 for、switch、select。

```
//demo_21.go
package main

import "fmt"

func main() {
	for i := 1; i <= 10; i++ {
		if i == 6 {
			break
		}
		fmt.Println("i =", i)
	}
}
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/07-循环/7_go_4.png)

## continue

跳过本次循环，只能用于 for。

```
//demo_22.go
package main

import "fmt"

func main() {
	for i := 1; i <= 10; i++ {
		if i == 6 {
			continue
		}
		fmt.Println("i =", i)
	}
}

```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/07-循环/7_go_5.png)

## goto

改变函数内代码执行顺序，不能跨函数使用。

```
//demo_23.go
package main

import "fmt"

func main() {
	fmt.Println("begin")

	for i := 1; i <= 10; i++ {
		if i == 6 {
			goto END
		}
		fmt.Println("i =", i)
	}

	END :
		fmt.Println("end")
}
```

运行结果：

![](https://github.com/xinliangnote/Go/blob/master/00-基础语法/images/07-循环/7_go_6.png)

## switch

```
//demo_24.go
package main

import "fmt"

func main() {
	i := 1
	fmt.Printf("当 i = %d 时：\n", i)

	switch i {
		case 1:
			fmt.Println("输出 i =", 1)
		case 2:
			fmt.Println("输出 i =", 2)
		case 3:
			fmt.Println("输出 i =", 3)
			fallthrough
		case 4,5,6:
			fmt.Println("输出 i =", "4 or 5 or 6")
		default:
			fmt.Println("输出 i =", "xxx")
	}
}
```

运行结果：

当 i = 1 时：输出 i = 1

当 i = 2 时：输出 i = 2

当 i = 3 时：

输出 i = 3

输出 i = 4 or 5 or 6

当 i = 4 时：输出 i = 4 or 5 or 6

当 i = 7 时：输出 i = xxx

**结论：**

- 默认每个 case 带有 break
- case 中可以有多个选项
- fallthrough 不跳出，并执行下一个 case


