# 第一部分 概述

[`JSON-RPC 2.0`](https://www.jsonrpc.org/specification)是一种基于`JSON`（`JavaScript Object Notation`）的远程过程调用（`RPC`）协议。它是一种轻量级的、无状态的、跨语言的通信协议，常用于客户端与服务端之间的交互。





# 第二部分 基本特点

- **简单直观**：消息结构清晰，仅由JSON对象组成。
- **双向通信**：支持客户端调用服务端方法，服务端也可通知客户端。
- **无状态**：协议本身不维护会话状态。
- **支持批量请求**：允许在一个JSON数组中发送多个请求，提升效率。
- **错误处理**：定义了标准的错误对象，便于排查和处理异常。

# 第三部分 消息格式

在`JSON-RPC 2.0`中，有以下三种主要的消息类型：
- **请求对象（Request Object）**
- **响应对象（Response Object）**
- **通知对象（Notification Object）**

## 3.1 请求对象

用于客户端调用服务端的方法，结构如下：
```json
{
  "jsonrpc": "2.0",
  "method": "methodName",
  "params": ["param1", "param2"],
  "id": 1
}
```

- `jsonrpc`：协议版本，固定为`2.0`。
- `method`：调用的远程方法名。
- `params`：方法参数，可以是数组或对象。
- `id`：唯一标识请求的ID，用于匹配响应。可为数字、字符串或`null`。

**示例：**
```json
{
  "jsonrpc": "2.0",
  "method": "add",
  "params": [4, 5],
  "id": 123
}
```

## 3.2 响应对象

用于服务端返回结果或错误信息，结构如下：

**成功响应：**
```json
{
  "jsonrpc": "2.0",
  "result": 9,
  "id": 123
}
```
- `jsonrpc`：协议版本。
- `result`：调用方法的返回结果。
- `id`：与请求对象中的`id`一致，用于匹配响应。

**错误响应：**
```json
{
  "jsonrpc": "2.0",
  "error": {
    "code": -32600,
    "message": "Invalid Request",
    "data": "Additional information if available"
  },
  "id": null
}
```
- `error`：包含错误信息的对象。
  - `code`：标准错误码。
  - `message`：错误描述信息。
  - `data`：可选的额外错误信息。
- `id`：如果无法解析请求或无法响应，则`id`设为`null`。

---

## 3.3 通知对象

通知是一种特殊的请求，不需要响应。用于不关心结果的场景，例如日志记录等。

**通知对象示例：**
```json
{
  "jsonrpc": "2.0",
  "method": "logMessage",
  "params": ["User logged in"]
}
```
- 没有`id`字段。
- 不会有响应对象返回。

# 第四部分 错误码列表

`JSON-RPC 2.0`定义了一组标准错误码：

| 错误码    | 错误类型               | 描述                                |
|-------------|-----------------------|------------------------------------|
| -32700      | Parse Error            | 无法解析 JSON 数据                 |
| -32600      | Invalid Request        | 请求对象无效                       |
| -32601      | Method Not Found       | 方法不存在或不可用                 |
| -32602      | Invalid Params         | 参数无效                           |
| -32603      | Internal Error         | 服务端内部错误                     |
| -32000~-32099| Server Error           | 自定义服务器错误                    |

# 第五部分 批量请求与响应

`JSON-RPC 2.0`支持在一个请求中发送多个调用，服务端也会以数组形式返回响应。

**批量请求示例：**
```json
[
  {
    "jsonrpc": "2.0",
    "method": "add",
    "params": [1, 2],
    "id": 1
  },
  {
    "jsonrpc": "2.0",
    "method": "subtract",
    "params": [5, 3],
    "id": 2
  }
]
```

**批量响应示例：**
```json
[
  {
    "jsonrpc": "2.0",
    "result": 3,
    "id": 1
  },
  {
    "jsonrpc": "2.0",
    "result": 2,
    "id": 2
  }
]
```

如果某个请求是通知或者出错，也会在响应中反映：
```json
[
  {
    "jsonrpc": "2.0",
    "result": 3,
    "id": 1
  },
  {
    "jsonrpc": "2.0",
    "error": {
      "code": -32601,
      "message": "Method not found"
    },
    "id": 2
  }
]
```

# 第六部分 示例场景

**场景1：简单调用**
客户端请求服务端进行加法运算：
```json
{
  "jsonrpc": "2.0",
  "method": "add",
  "params": [10, 20],
  "id": 100
}
```
服务端返回结果：
```json
{
  "jsonrpc": "2.0",
  "result": 30,
  "id": 100
}
```

---

**场景2：错误处理**
客户端请求一个不存在的方法：
```json
{
  "jsonrpc": "2.0",
  "method": "unknownMethod",
  "params": [],
  "id": 101
}
```
服务端返回错误：
```json
{
  "jsonrpc": "2.0",
  "error": {
    "code": -32601,
    "message": "Method not found"
  },
  "id": 101
}
```

**场景3：通知**
客户端发送通知，不需要返回结果：
```json
{
  "jsonrpc": "2.0",
  "method": "notifyEvent",
  "params": ["EventData"]
}
```
服务端不会返回任何响应。


# 第七部分 总结

`JSON-RPC 2.0`提供了一种简洁、灵活且强大的通信方式，特别适用于：
- 分布式系统中的服务调用  
- 微服务架构下的跨语言交互  
- 物联网设备与后端服务的通信  

通过`JSON-RPC 2.0`，可以高效地管理远程方法调用、错误处理和批量操作，提升系统的整体性能和可靠性。

JSON-RPC 2.0协议详解

# 第一部分 概述

`tablewriter`是一个用于在终端中生成`ASCII`表格的`Go`语言库。它提供了丰富的功能，包括自动填充、支持多行内容、对齐设置、自定义分隔符、数字和百分比的自动对齐等。此外，它还能直接从`CSV`文件读取数据，支持自定义脚注，并允许合并相同的单元格内容。



主要功能：

 - **自动填充**：根据内容自动调整列宽，确保表格对齐美观。
 - **多行支持**：单元格内支持多行文本，适用于展示较长内容。
 - **对齐设置**：可设置文本左对齐、右对齐或居中对齐，满足不同展示需求。
 - **自定义分隔符**：允许自定义行、列和中心的分隔符，增强表格的可读性。
 - **数字与百分比自动对齐**：针对数字和百分比内容，提供自动对齐功能，方便数据比较。
 - **直接读取 CSV 文件**：可直接从 CSV 文件读取数据并生成表格，简化数据展示流程。
 - **自定义脚注**：支持在表格底部添加自定义脚注，提供额外信息。
 - **合并相同单元格内容**：对于连续相同的单元格内容，可选择合并，提升表格简洁性。

项目地址：[https://github.com/olekukonko/tablewriter](https://github.com/olekukonko/tablewriter)

# 第二部分 常用操作

## 2.1 基本示例

示例代码：

```go
data := [][]string{
    []string{"A", "The Good", "500"},
    []string{"B", "The Very very Bad Man", "288"},
    []string{"C", "The Ugly", "120"},
    []string{"D", "The Gopher", "800"},
}

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Name", "Sign", "Rating"})

for _, v := range data {
    table.Append(v)
}
table.Render() // Send output
```

显示效果：

```
+------+-----------------------+--------+
| NAME |         SIGN          | RATING |
+------+-----------------------+--------+
|  A   |       The Good        |    500 |
|  B   | The Very very Bad Man |    288 |
|  C   |       The Ugly        |    120 |
|  D   |      The Gopher       |    800 |
+------+-----------------------+--------+
```

## 2.2 无边框/页脚/批量追加

示例代码：

```go
data := [][]string{
    []string{"1/1/2014", "Domain name", "2233", "$10.98"},
    []string{"1/1/2014", "January Hosting", "2233", "$54.95"},
    []string{"1/4/2014", "February Hosting", "2233", "$51.00"},
    []string{"1/4/2014", "February Extra Bandwidth", "2233", "$30.00"},
}

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Date", "Description", "CV2", "Amount"})
table.SetFooter([]string{"", "", "Total", "$146.93"}) // Add Footer
table.EnableBorder(false)                             // Set Border to false
table.AppendBulk(data)                                // Add Bulk Data
table.Render()
```

显示效果：

```

    DATE   |       DESCRIPTION        |  CV2  | AMOUNT
-----------+--------------------------+-------+----------
  1/1/2014 | Domain name              |  2233 | $10.98
  1/1/2014 | January Hosting          |  2233 | $54.95
  1/4/2014 | February Hosting         |  2233 | $51.00
  1/4/2014 | February Extra Bandwidth |  2233 | $30.00
-----------+--------------------------+-------+----------
                                        TOTAL | $146 93
                                      --------+----------

```

## 2.3 从CSV读取数据

示例代码：

```go
table, _ := tablewriter.NewCSV(os.Stdout, "testdata/test_info.csv", true)
table.SetAlignment(tablewriter.ALIGN_LEFT)   // Set Alignment
table.Render()
```

显示效果：

```
+----------+--------------+------+-----+---------+----------------+
|  FIELD   |     TYPE     | NULL | KEY | DEFAULT |     EXTRA      |
+----------+--------------+------+-----+---------+----------------+
| user_id  | smallint(5)  | NO   | PRI | NULL    | auto_increment |
| username | varchar(10)  | NO   |     | NULL    |                |
| password | varchar(100) | NO   |     | NULL    |                |
+----------+--------------+------+-----+---------+----------------+
```

## 2.4 自定义分隔符

示例代码

```go
table, _ := tablewriter.NewCSV(os.Stdout, "testdata/test.csv", true)
table.SetRowLine(true)         // Enable row line

// Change table lines
table.SetCenterSeparator("*")
table.SetColumnSeparator("╪")
table.SetRowSeparator("-")

table.SetAlignment(tablewriter.ALIGN_LEFT)
table.Render()
```

显示效果

```
*------------*-----------*---------*
╪ FIRST NAME ╪ LAST NAME ╪   SSN   ╪
*------------*-----------*---------*
╪ John       ╪ Barry     ╪ 123456  ╪
*------------*-----------*---------*
╪ Kathy      ╪ Smith     ╪ 687987  ╪
*------------*-----------*---------*
╪ Bob        ╪ McCornick ╪ 3979870 ╪
*------------*-----------*---------*
```

## 2.5 Markdown格式

示例代码

```go
data := [][]string{
	[]string{"1/1/2014", "Domain name", "2233", "$10.98"},
	[]string{"1/1/2014", "January Hosting", "2233", "$54.95"},
	[]string{"1/4/2014", "February Hosting", "2233", "$51.00"},
	[]string{"1/4/2014", "February Extra Bandwidth", "2233", "$30.00"},
}

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Date", "Description", "CV2", "Amount"})
table.SetBorders(tablewriter.Border{Left: true, Top: false, Right: true, Bottom: false})
table.SetCenterSeparator("|")
table.AppendBulk(data) // Add Bulk Data
table.Render()
```

显示效果：

```
|   DATE   |       DESCRIPTION        | CV2  | AMOUNT |
|----------|--------------------------|------|--------|
| 1/1/2014 | Domain name              | 2233 | $10.98 |
| 1/1/2014 | January Hosting          | 2233 | $54.95 |
| 1/4/2014 | February Hosting         | 2233 | $51.00 |
| 1/4/2014 | February Extra Bandwidth | 2233 | $30.00 |
```

## 2.6 相同单元格合并

示例代码：

```go
data := [][]string{
  []string{"1/1/2014", "Domain name", "1234", "$10.98"},
  []string{"1/1/2014", "January Hosting", "2345", "$54.95"},
  []string{"1/4/2014", "February Hosting", "3456", "$51.00"},
  []string{"1/4/2014", "February Extra Bandwidth", "4567", "$30.00"},
}

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Date", "Description", "CV2", "Amount"})
table.SetFooter([]string{"", "", "Total", "$146.93"})
table.SetAutoMergeCells(true)
table.SetRowLine(true)
table.AppendBulk(data)
table.Render()
```

显示效果：

```
+----------+--------------------------+-------+---------+
|   DATE   |       DESCRIPTION        |  CV2  | AMOUNT  |
+----------+--------------------------+-------+---------+
| 1/1/2014 | Domain name              |  1234 | $10.98  |
+          +--------------------------+-------+---------+
|          | January Hosting          |  2345 | $54.95  |
+----------+--------------------------+-------+---------+
| 1/4/2014 | February Hosting         |  3456 | $51.00  |
+          +--------------------------+-------+---------+
|          | February Extra Bandwidth |  4567 | $30.00  |
+----------+--------------------------+-------+---------+
|                                       TOTAL | $146 93 |
+----------+--------------------------+-------+---------+
```

## 2.7 相同单元格合并（指定要合并的列索引）

示例代码：

```go
data := [][]string{
  []string{"1/1/2014", "Domain name", "1234", "$10.98"},
  []string{"1/1/2014", "January Hosting", "1234", "$10.98"},
  []string{"1/4/2014", "February Hosting", "3456", "$51.00"},
  []string{"1/4/2014", "February Extra Bandwidth", "4567", "$30.00"},
}

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Date", "Description", "CV2", "Amount"})
table.SetFooter([]string{"", "", "Total", "$146.93"})
table.SetAutoMergeCellsByColumnIndex([]int{2, 3})
table.SetRowLine(true)
table.AppendBulk(data)
table.Render()
```

显示效果：

```
+----------+--------------------------+-------+---------+
|   DATE   |       DESCRIPTION        |  CV2  | AMOUNT  |
+----------+--------------------------+-------+---------+
| 1/1/2014 | Domain name              |  1234 | $10.98  |
+----------+--------------------------+       +         +
| 1/1/2014 | January Hosting          |       |         |
+----------+--------------------------+-------+---------+
| 1/4/2014 | February Hosting         |  3456 | $51.00  |
+----------+--------------------------+-------+---------+
| 1/4/2014 | February Extra Bandwidth |  4567 | $30.00  |
+----------+--------------------------+-------+---------+
|                                       TOTAL | $146.93 |
+----------+--------------------------+-------+---------+
```


## 2.8 带颜色的表格

示例代码：

```go
data := [][]string{
	[]string{"1/1/2014", "Domain name", "2233", "$10.98"},
	[]string{"1/1/2014", "January Hosting", "2233", "$54.95"},
	[]string{"1/4/2014", "February Hosting", "2233", "$51.00"},
	[]string{"1/4/2014", "February Extra Bandwidth", "2233", "$30.00"},
}

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Date", "Description", "CV2", "Amount"})
table.SetFooter([]string{"", "", "Total", "$146.93"}) // Add Footer
table.EnableBorder(false)                                // Set Border to false

table.SetHeaderColor(tablewriter.Colors{tablewriter.Bold, tablewriter.BgGreenColor},
	tablewriter.Colors{tablewriter.FgHiRedColor, tablewriter.Bold, tablewriter.BgBlackColor},
	tablewriter.Colors{tablewriter.BgRedColor, tablewriter.FgWhiteColor},
	tablewriter.Colors{tablewriter.BgCyanColor, tablewriter.FgWhiteColor})

table.SetColumnColor(tablewriter.Colors{tablewriter.Bold, tablewriter.FgHiBlackColor},
	tablewriter.Colors{tablewriter.Bold, tablewriter.FgHiRedColor},
	tablewriter.Colors{tablewriter.Bold, tablewriter.FgHiBlackColor},
	tablewriter.Colors{tablewriter.Bold, tablewriter.FgBlackColor})

table.SetFooterColor(tablewriter.Colors{}, tablewriter.Colors{},
	tablewriter.Colors{tablewriter.Bold},
	tablewriter.Colors{tablewriter.FgHiRedColor})

table.AppendBulk(data)
table.Render()
```

运行效果：

![Table with Color](https://cloud.githubusercontent.com/assets/6460392/21101956/bbc7b356-c0a1-11e6-9f36-dba694746efc.png)

## 2.8 带颜色的表格单元格


:::tip{title="提示"}
`func Rich`设置的单元格颜色优先于列颜色。
:::

示例代码：

```go
data := [][]string{
	[]string{"Test1Merge", "HelloCol2 - 1", "HelloCol3 - 1", "HelloCol4 - 1"},
	[]string{"Test1Merge", "HelloCol2 - 2", "HelloCol3 - 2", "HelloCol4 - 2"},
	[]string{"Test1Merge", "HelloCol2 - 3", "HelloCol3 - 3", "HelloCol4 - 3"},
	[]string{"Test2Merge", "HelloCol2 - 4", "HelloCol3 - 4", "HelloCol4 - 4"},
	[]string{"Test2Merge", "HelloCol2 - 5", "HelloCol3 - 5", "HelloCol4 - 5"},
	[]string{"Test2Merge", "HelloCol2 - 6", "HelloCol3 - 6", "HelloCol4 - 6"},
	[]string{"Test2Merge", "HelloCol2 - 7", "HelloCol3 - 7", "HelloCol4 - 7"},
	[]string{"Test3Merge", "HelloCol2 - 8", "HelloCol3 - 8", "HelloCol4 - 8"},
	[]string{"Test3Merge", "HelloCol2 - 9", "HelloCol3 - 9", "HelloCol4 - 9"},
	[]string{"Test3Merge", "HelloCol2 - 10", "HelloCol3 -10", "HelloCol4 - 10"},
}

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Col1", "Col2", "Col3", "Col4"})
table.SetFooter([]string{"", "", "Footer3", "Footer4"})
table.EnableBorder(false)

table.SetHeaderColor(tablewriter.Colors{tablewriter.Bold, tablewriter.BgGreenColor},
	tablewriter.Colors{tablewriter.FgHiRedColor, tablewriter.Bold, tablewriter.BgBlackColor},
	tablewriter.Colors{tablewriter.BgRedColor, tablewriter.FgWhiteColor},
	tablewriter.Colors{tablewriter.BgCyanColor, tablewriter.FgWhiteColor})

table.SetColumnColor(tablewriter.Colors{tablewriter.Bold, tablewriter.FgHiBlackColor},
	tablewriter.Colors{tablewriter.Bold, tablewriter.FgHiRedColor},
	tablewriter.Colors{tablewriter.Bold, tablewriter.FgHiBlackColor},
	tablewriter.Colors{tablewriter.Bold, tablewriter.FgBlackColor})

table.SetFooterColor(tablewriter.Colors{}, tablewriter.Colors{},
	tablewriter.Colors{tablewriter.Bold},
	tablewriter.Colors{tablewriter.FgHiRedColor})

colorData1 := []string{"TestCOLOR1Merge", "HelloCol2 - COLOR1", "HelloCol3 - COLOR1", "HelloCol4 - COLOR1"}
colorData2 := []string{"TestCOLOR2Merge", "HelloCol2 - COLOR2", "HelloCol3 - COLOR2", "HelloCol4 - COLOR2"}

for i, row := range data {
	if i == 4 {
		table.Rich(colorData1, []tablewriter.Colors{tablewriter.Colors{}, tablewriter.Colors{tablewriter.Normal, tablewriter.FgCyanColor}, tablewriter.Colors{tablewriter.Bold, tablewriter.FgWhiteColor}, tablewriter.Colors{}})
		table.Rich(colorData2, []tablewriter.Colors{tablewriter.Colors{tablewriter.Normal, tablewriter.FgMagentaColor}, tablewriter.Colors{}, tablewriter.Colors{tablewriter.Bold, tablewriter.BgRedColor}, tablewriter.Colors{tablewriter.FgHiGreenColor, tablewriter.Italic, tablewriter.BgHiCyanColor}})
	}
	table.Append(row)
}

table.SetAutoMergeCells(true)
table.Render()

```

运行效果：

![Table cells with Color](https://user-images.githubusercontent.com/9064687/63969376-bcd88d80-ca6f-11e9-9466-c3d954700b25.png)

## 2.9 设置表格标题

示例代码：

```go
data := [][]string{
    []string{"A", "The Good", "500"},
    []string{"B", "The Very very Bad Man", "288"},
    []string{"C", "The Ugly", "120"},
    []string{"D", "The Gopher", "800"},
}

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Name", "Sign", "Rating"})
table.SetCaption(true, "Movie ratings.")

for _, v := range data {
    table.Append(v)
}
table.Render() // Send output
```


:::note{title="注"}
标题文本会根据渲染表格的总宽度自动换行。
:::

运行效果：

```
+------+-----------------------+--------+
| NAME |         SIGN          | RATING |
+------+-----------------------+--------+
|  A   |       The Good        |    500 |
|  B   | The Very very Bad Man |    288 |
|  C   |       The Ugly        |    120 |
|  D   |      The Gopher       |    800 |
+------+-----------------------+--------+
Movie ratings.
```

## 2.10 设置 NoWhiteSpace 和 TablePadding 选项

示例代码：

```go
data := [][]string{
    {"node1.example.com", "Ready", "compute", "1.11"},
    {"node2.example.com", "Ready", "compute", "1.11"},
    {"node3.example.com", "Ready", "compute", "1.11"},
    {"node4.example.com", "NotReady", "compute", "1.11"},
}

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"Name", "Status", "Role", "Version"})
table.SetAutoWrapText(false)
table.SetAutoFormatHeaders(true)
table.SetHeaderAlignment(tablewriter.ALIGN_LEFT)
table.SetAlignment(tablewriter.ALIGN_LEFT)
table.SetCenterSeparator("")
table.SetColumnSeparator("")
table.SetRowSeparator("")
table.SetHeaderLine(false)
table.EnableBorder(false)
table.SetTablePadding("\t") // pad with tabs
table.SetNoWhiteSpace(true)
table.AppendBulk(data) // Add Bulk Data
table.Render()
```

运行效果：

```
NAME             	STATUS  	ROLE   	VERSION 
node1.example.com	Ready   	compute	1.11   	
node2.example.com	Ready   	compute	1.11   	
node3.example.com	Ready   	compute	1.11   	
node4.example.com	NotReady	compute	1.11   	
```

[GO每日一库]tablewriter

# 第一部分 概述
在软件开发中，版本管理是一个至关重要的环节。`Semantic Versioning`（语义化版本控制）是一种广泛采用的版本管理规范，它通过明确的版本号规则来帮助开发者更好地理解和管理软件的更新。今天，我们将介绍一个在Go语言中实现`Semantic Versioning`的库——`semver`。




## 1.1 什么是Semantic Versioning？

`Semantic Versioning`（语义化版本控制）是一种版本号的命名规范，它通过三个数字（`主版本号`、`次版本号`和`修订号`）来表示软件的版本。例如，`1.0.0`表示主版本号为1，次版本号为0，修订号为0。这种规范有助于开发者理解版本之间的差异，例如：
 - 主版本号变化（如1.0.0到2.0.0）表示有不兼容的API修改。
 - 次版本号变化（如1.0.0到1.1.0）表示添加了向下兼容的功能。
 - 修订号变化（如1.0.0到1.0.1）表示进行了向下兼容的问题修正。

## 1.2 semver库简介

`semver`是一个用`Go`语言编写的`Semantic Versioning`库，它完全覆盖了`Semantic Versioning`规范的`2.0.0`版本。这个库提供了丰富的功能，包括版本解析、比较、范围匹配等，帮助开发者在`Go`项目中更好地管理版本。

功能特点
 - **完全规范兼容**：完全符合Semantic Versioning规范。
 - **无反射和正则表达式**：不使用反射和正则表达式，提高了性能和可读性。
 - **高测试覆盖率**：测试覆盖率超过99%，确保了库的稳定性和可靠性。
 - **可读性强的解析**/验证错误：提供了清晰的错误信息，便于调试。
 - **快速**：性能优化，适合高性能要求的场景。
 - **仅使用标准库**：不依赖外部库，减少了依赖管理的复杂性。
 - **使用值而不是指针**：提高了代码的可读性和安全性。
 - **丰富的功能**：包括解析、验证、比较、范围匹配等。

项目地址：[https://github.com/blang/semver](https://github.com/blang/semver)

使用`semver`解析的版本号需要遵循[SemVer](https://semver.org/)规范，在之前的博文中介绍的[[GO每日一库]go-version](https://blog.jianggujin.com/post/14)与`semver`属于同类型库，可以对比选择后使用。

# 第二部分 常用操作

## 2.1 版本比较

在代码中使用`semver`库非常直观。例如，解析一个版本号并进行比较：

```go
v1, err := semver.Make("1.0.0-beta")
v2, err := semver.Make("2.0.0-beta")
if v1.Compare(v2) < 0 {
    fmt.Println("v1 is less than v2")
}
```

## 2.2 版本范围

在`semver`库中，版本范围（`Range`）是一个强大的功能，允许定义一组条件，这些条件指定了哪些版本号满足该范围。版本范围由多个条件组成，每个条件由一个操作符和一个版本号构成。
`semver`库支持以下操作符：
 - **<1.0.0**：小于`1.0.0`
 - **<=1.0.0**：小于或等于`1.0.0`
 - **>1.0.0**：大于`1.0.0`
 - **>=1.0.0**：大于或等于`1.0.0`
 - **1.0.0, =1.0.0, ==1.0.0**：等于`1.0.0`
 - **!1.0.0, !=1.0.0**：不等于`1.0.0`，排除版本`1.0.0`

注意，操作符和版本号之间的空格会被优雅地容忍。

版本范围的连接，版本范围可以通过逻辑`AND`和逻辑`OR`连接多个范围。`AND`的优先级高于`OR`，且不支持使用括号来改变优先级。
逻辑AND
 - **>1.0.0 <2.0.0**：匹配两个范围之间的版本，例如`1.1.1`和`1.8.7`，但不匹配`1.0.0`或`2.0.0`。
 - **>1.0.0 <3.0.0 !2.0.3-beta.2**：匹配`1.0.0`和`3.0.0`之间的所有版本，但排除`2.0.3-beta.2`。
逻辑OR
 - **<2.0.0 || >=3.0.0**：匹配`1.x.x`和`3.x.x`，但不匹配`2.x.x`。
组合使用AND和OR
 - **>1.0.0 <2.0.0 || >3.0.0 !4.2.1**：匹配`1.2.3`、`1.9.9`、`3.1.1`，但不匹配`4.2.1`、`2.1.1`。

### 2.2.1 版本范围的使用示例

```go
// 解析一个版本号
v, err := semver.Parse("1.2.3")
if err != nil {
    fmt.Printf("Error parsing version: %q", err)
    return
}

// 解析一个版本范围
expectedRange, err := semver.ParseRange(">1.0.0 <2.0.0 || >=3.0.0")
if err != nil {
    fmt.Printf("Error parsing range: %q", err)
    return
}

// 检查版本是否满足范围
if expectedRange(v) {
    fmt.Println("Version matches the range")
} else {
    fmt.Println("Version does not match the range")
}
```

### 2.2.2 版本范围的解析和匹配

`semver`库提供了`ParseRange`函数来解析版本范围，并通过调用范围对象的`Match`方法来检查某个版本是否满足该范围。以下是一些具体的例子：

#### 2.2.2.1 简单的版本范围

```go
v, err := semver.Parse("1.2.3")
expectedRange, err := semver.ParseRange(">1.0.0 <2.0.0")
if expectedRange(v) {
    fmt.Println("Version matches the range")
} else {
    fmt.Println("Version does not match the range")
}
```

#### 2.2.2.2 复杂的版本范围

```go
v, err := semver.Parse("2.0.3-beta.2")
expectedRange, err := semver.ParseRange(">1.0.0 <3.0.0 !2.0.3-beta.2")
if expectedRange(v) {
    fmt.Println("Version matches the range")
} else {
    fmt.Println("Version does not match the range")
}
```

#### 2.2.2.3 组合使用AND和OR

```go
v, err := semver.Parse("3.1.1")
expectedRange, err := semver.ParseRange(">1.0.0 <2.0.0 || >3.0.0 !4.2.1")
if expectedRange(v) {
    fmt.Println("Version matches the range")
} else {
    fmt.Println("Version does not match the range")
}
```

[GO每日一库]semver

# 第一部分 概述

`go-humanize`是一个`Go`语言库，旨在将`数字`、`时间`、`容量`等转换为更易于人类理解的形式。它通过提供一系列格式化函数，帮助开发者将技术性的数据转换成人类可读的格式。





`go-humanize`提供以下功能
 - **容量转换**：将字节转换为更易读的单位，如KB、MB、GB等。例如，humanize.Bytes(52854982)会输出53MB。
 - **时间转换**：将时间戳转换为相对时间，如7 hours ago或3 days from now。例如，humanize.Time(someTimeInstance)会输出类似7 hours ago的字符串。
 - **千分位转换**：在数字中添加逗号，使其更易于阅读。例如，humanize.Comma(1000000000)会输出1,000,000,000。
 - **序数转换**：将数字转换为序数形式，如1st、2nd、3rd等。例如，humanize.Ordinal(193)会输出193rd。
 - **浮点数转换**：将浮点数转换为千分位形式，如humanize.Commaf(834142.32)会输出834,142.32。
- **大数字处理**：支持大数字的处理，如humanize.BigBytes和humanize.BigComma函数。
 - **自定义相对时间**：允许自定义相对时间的格式，通过humanize.CustomRelTime函数。

`go-humanize`通过这些功能，使得日志输出、用户界面或任何需要展示数字和时间的场景更加直观和易于理解。

项目地址：[https://github.com/dustin/go-humanize](https://github.com/dustin/go-humanize)

# 第二部分 常用操作

## 2.1 容量

根据喜好可以将`82854982`形如`83 MB`或`79 MiB`格式的字符串。

```go
// 生成SI大小的人类可读表示
// That file is 83 MB.
fmt.Printf("That file is %s.\n", humanize.Bytes(82854982))
// 生成IEC大小的人类可读表示
// That file is 79 MB.
fmt.Printf("That file is %s.\n", humanize.IBytes(82854982))
```

## 2.2 时间

将时间格式话为相对时间字符串。

```go
// This was touched 7 hours ago.
fmt.Printf("This was touched %s.", humanize.Time(time.Now().Add(-7*time.Hour))) 
```

## 2.3 千分位

将数字转换为千分位格式字符串

    0 -> 0
    100 -> 100
    1000 -> 1,000
    1000000000 -> 1,000,000,000
    -100000 -> -100,000


```go
// You owe $6,582,491.
fmt.Printf("You owe $%s.\n", humanize.Comma(6582491))
```


## 2.4 序数

将数字转换为序数格式字符串

    0 -> 0th
    1 -> 1st
    2 -> 2nd
    3 -> 3rd
    4 -> 4th
    [...]


```go
// You are my 193rd best friend.
fmt.Printf("You're my %s best friend.", humanize.Ordinal(193))
```


## 2.5 Ftoa

更好的float64格式化方式，可以将小数部分多余的`0`移除。

```go
fmt.Printf("%f", 2.24)                // 2.240000
fmt.Printf("%s", humanize.Ftoa(2.24)) // 2.24
fmt.Printf("%f", 2.0)                 // 2.000000
fmt.Printf("%s", humanize.Ftoa(2.0))  // 2
```

## 国际单位制

将数字格式化为国际单位制字符串。

```go
humanize.SI(0.00000000223, "M") // 2.23 nM
```

[GO每日一库]go-humanize

# 第一部分 概述

`snowflake` 是一个`Go`语言包，提供以下功能：

 - 一个非常简单的`Twitter`雪花（`Snowflake`）ID生成器。
 - 解析已有雪花ID的方法。
 - 将雪花ID转换为其他多种数据类型以及反向转换的方法。
 - JSON的序列化/反序列化功能，便于在JSON API中使用雪花ID。
 - 单调时钟计算功能，用于防止时钟漂移。



项目地址：[https://github.com/bwmarrin/snowflake](https://github.com/bwmarrin/snowflake)

## 1.1 ID格式

默认情况下，`ID`格式遵循原始`Twitter`雪花（`Snowflake`）格式。

 - 整个`ID`是一个`63`位的整数，存储在`int64`类型中。
 - `41`位用于存储毫秒精度的时间戳，使用自定义的纪元（`epoch`）。
 - `10`位用于存储节点`ID`，范围为`0`到`1023`。
 - `12`位用于存储序列号，范围为`0`到`4095`。

## 1.2 自定义格式

可以通过设置`snowflake.NodeBits`和`snowflake.StepBits`值来调整节点`ID`和步长（即序列号）使用的位数。需要注意的是，这两个值最多只能共享`22`位空间，不必全部使用`22`位。

## 1.3 自定义纪元

默认情况下，该包使用`Twitter`的纪元，即`1288834974657`（即`2010年11月4日 01:42:54`）。可以通过将`snowflake.Epoch`设置为以毫秒为单位的时间值来定义自己的纪元。

## 1.4 自定义设置注意事项

在调用`snowflake`包中的任何函数（包括`NewNode()`）之前，需要先设置自定义的纪元或位数，否则自定义值将无法正确应用。

## 1.5 工作原理

每次生成一个ID时，执行流程如下：

 - 使用41位ID空间存储毫秒精度的时间戳。
 - 随后添加NodeID所占的位。
 - 再添加序列号，从0开始递增，每毫秒内生成的ID按序列号递增。如果在同一毫秒内生成的ID数量超出序列号上限，则生成函数将暂停至下一个毫秒。

默认的`Twitter`格式如下所示：

```
+--------------------------------------------------------------------------+
| 1 Bit Unused | 41 Bit Timestamp |  10 Bit NodeID  |   12 Bit Sequence ID |
+--------------------------------------------------------------------------+
```

在默认设置下，每个节点ID每毫秒最多可以生成`4096`个唯一`ID`。

# 第二部分 常用操作

代码片段：

```go
// 创建一个新的节点并设置节点编号为1
node, _ := snowflake.NewNode(1)

// 生成一个ID
id := node.Generate()

// Print out the ID in a few different ways.
println("Int64  ID: ", id)
println("String ID: ", id)
println("Base2  ID: ", id.Base2())
println("Base64 ID: ", id.Base64())

println("ID Time  : ", id.Time())

println("ID Node  : ", id.Node())

println("ID Step  : ", id.Step())

println("ID       : ", node.Generate().Int64())
```

运行结果：

```
Int64  ID:  1851456523897671680
String ID:  1851456523897671680
Base2  ID:  1100110110001101100011110011000101000000000000001000000000000
Base64 ID:  MTg1MTQ1NjUyMzg5NzY3MTY4MA==
ID Time  :  1730256608353
ID Node  :  1
ID Step  :  0
ID       :  1851456523897671681
```

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述