# 第一部分 概述

`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
```

[GO每日一库]snowflake

# 第一部分 概述

`go-version`是一个 Go 语言的库，用于处理和比较版本号。它可以解析版本号字符串并提供版本比较的功能，非常适合需要管理和比较软件版本的场景。



**作用**
 - **版本解析**：将版本号字符串解析为结构化数据，便于进行比较。
 - **版本比较**：提供多种比较方法，可以判断一个版本是否大于、小于或等于另一个版本。
 - **版本规范化**：可以将版本号标准化，确保版本格式一致。

**使用场景**
 - **依赖管理**：在处理项目依赖时，检查依赖库的版本是否符合要求。
 - **软件更新**：比较当前软件版本与最新版本，以决定是否需要更新。
 - **API 版本控制**：在开发 API 时，根据版本号管理不同版本的接口。


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

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

# 第二部分 常用操作

## 2.1 解析版本号

代码片段：

```go
for _, item := range []string{"v1.2.9", "1.2", "1.5+metadata", "1.4-beta"} {
	ver, _ := version.NewVersion(item)
	println("==================")
	println("String", ver.String())
	println("Original", ver.Original())
	println("Prerelease", ver.Prerelease())
	println("Metadata", ver.Metadata())
}
```

运行结果：

```
==================
String 1.2.9
Original v1.2.9
Prerelease 
Metadata 
==================
String 1.2.0
Original 1.2
Prerelease 
Metadata 
==================
String 1.5.0+metadata
Original 1.5+metadata
Prerelease 
Metadata metadata
==================
String 1.4.0-beta
Original 1.4-beta
Prerelease beta
Metadata 
```

## 2.2 比较版本号

代码片段：

```go
v1, _ := version.NewVersion("1.2")
v2, _ := version.NewVersion("1.5+metadata")

println("GreaterThanOrEqual", v1.GreaterThanOrEqual(v2))
println("GreaterThan", v1.GreaterThan(v2))
println("Equal", v1.Equal(v2))
println("LessThanOrEqual", v1.LessThanOrEqual(v2))
println("LessThan", v1.LessThan(v2))
println("Compare", v1.Compare(v2))
```

运行结果：

```
GreaterThanOrEqual false
GreaterThan false
Equal false
LessThanOrEqual true
LessThan true
Compare -1
```

## 2.3 版本约束

代码片段：

```go
v1, _ := version.NewVersion("1.2")

// Constraints example.
constraints, _ := version.NewConstraint(">= 1.0, < 1.4")
if constraints.Check(v1) {
	println(v1.String(), "satisfies constraints", constraints.String())
} else {
	println(v1.String(), "unsatisfied constraints", constraints.String())
}
```

运行结果：

```
1.2.0 satisfies constraints >= 1.0, < 1.4
```

## 2.4 排序

代码片段：

```go
versionsRaw := []string{"1.1", "0.7.1", "1.4-beta", "1.4", "2"}
versions := make([]*version.Version, len(versionsRaw))
for i, raw := range versionsRaw {
	v, _ := version.NewVersion(raw)
	versions[i] = v
}
sort.Sort(version.Collection(versions))

for _, item := range versions {
	println(item.String())
}
```

运行结果：

```
0.7.1
1.1.0
1.4.0-beta
1.4.0
2.0.0
```

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述