# 第一部分 概述

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

[GO每日一库]go-version

# 第一部分 概述

`gopsutil`是一个用于获取系统和进程信息的`Go`语言库。它可以帮助开发者轻松地访问系统级别的资源信息，包括 CPU、内存、磁盘、网络等。这些信息对于监控系统性能、分析应用程序行为以及故障排查非常有用。



**主要特点**

 - **跨平台支持**：支持多种操作系统，包括 Windows、Linux 和 macOS。
 - **简单易用**：提供了简洁的 API，方便快速集成到 Go 应用中。
 - **实时监控**：可以获取实时的系统资源使用情况，适合做系统监控和性能分析。

**常用模块**

 - **CPU**：获取 CPU 使用率、核心信息等。
 - **内存**：获取物理内存和虚拟内存的使用情况。
 - **磁盘**：获取磁盘使用情况，包括读写速率和使用百分比。
 - **网络**：获取网络流量信息和网络接口统计。
 - **进程**：获取系统中运行的进程信息，如 PID、名称、状态等。

**应用场景**

 - **系统监控工具**
 - **性能分析和调优**
 - **自动化运维脚本**
 - **故障排查和诊断工具**


项目地址：[https://github.com/shirou/gopsutil](https://github.com/shirou/gopsutil)

# 第二部分 常用操作

## 2.1 CPU

### 2.1.1 CPU信息

代码片段：

```go
info, _ := cpu.Info()
pretty, _ := json.MarshalIndent(info, "", "  ")
println("Info:", string(pretty))
```

运行结果：

```
Info: [
  {
    "cpu": 0,
    "vendorId": "GenuineIntel",
    "family": "198",
    "model": "",
    "stepping": 0,
    "physicalId": "BFEBFBFF000806EA",
    "coreId": "",
    "cores": 8,
    "modelName": "Intel(R) Core(TM) i7-8650U CPU @ 1.90GHz",
    "mhz": 2112,
    "cacheSize": 0,
    "flags": [],
    "microcode": ""
  }
]
```

### 2.1.2 CPU核心数

代码片段：

```go
cpuNumber, _ := cpu.Counts(true)
println("CPU逻辑数量: ", cpuNumber)
cpuNumber, _ = cpu.Counts(false)
println("CPU物理核心: ", cpuNumber)
```

运行结果：

```
CPU逻辑数量:  8
CPU物理核心:  4
```

### 2.1.3 CPU使用率

代码片段：

```go
cpuPercent, _ := cpu.Percent(time.Second, false)
println("CPU使用率: ", cpuPercent[0])
```

运行结果：

```
CPU使用率:  +1.523438e+001
```

## 2.2 DISK

### 2.2.1 分区信息

代码片段：

```go
diskPart, _ := disk.Partitions(false)
for _, dp := range diskPart {
	diskUsed, _ := disk.Usage(dp.Mountpoint)
	fmt.Printf("路径: %s, 分区总大小: %d, 剩余大小: %d, 文件系统类型: %s, 分区使用率: %.3f%%\n",
		diskUsed.Path,
		diskUsed.Total,
		diskUsed.Free,
		dp.Fstype,
		diskUsed.UsedPercent,
	)
}
```

运行结果：

```
路径: C:, 分区总大小: 254792429568, 剩余大小: 16384618496, 文件系统类型: NTFS, 分区使用率: 93.569%
路径: D:, 分区总大小: 124688269312, 剩余大小: 113836687360, 文件系统类型: exFAT, 分区使用率: 8.703%
```


### 2.2.2 IO计数

代码片段：

```go
counters, _ := disk.IOCounters()
for _, counter := range counters {
	pretty, _ := json.MarshalIndent(counter, "", "  ")
	println(string(pretty))
}
```

运行结果：

```
{
  "readCount": 300824488,
  "mergedReadCount": 0,
  "writeCount": 108395343,
  "mergedWriteCount": 0,
  "readBytes": 9078301635072,
  "writeBytes": 4770640154624,
  "readTime": 184401,
  "writeTime": 78903,
  "iopsInProgress": 0,
  "ioTime": 0,
  "weightedIO": 0,
  "name": "C:",
  "serialNumber": "",
  "label": ""
}
```

## 2.3 HOST

### 2.3.1 主机信息

代码片段：

```go
info, _ := host.Info()
pretty, _ := json.MarshalIndent(info, "", "  ")
println("Info:", string(pretty))

te := time.Unix(int64(info.BootTime), 0)
println("BootTime:", te.Format(time.DateTime))
println("Uptime:", info.Uptime)
```

运行结果：

```
Info: {
  "hostname": "DESKTOP-5NLBCER",
  "uptime": 15969905,
  "bootTime": 1713940979,
  "procs": 220,
  "os": "windows",
  "platform": "Microsoft Windows 10 Home",
  "platformFamily": "Standalone Workstation",
  "platformVersion": "21H1",
  "kernelVersion": "10.0.19043.1645 Build 19043.1645",
  "kernelArch": "x86_64",
  "virtualizationSystem": "",
  "virtualizationRole": "",
  "hostId": "c9667c87-395d-4cd8-a4b7-c00bd6ee35df"
}
BootTime: 2024-04-24 14:42:59
Uptime: 15969905
```

## 2.4 LOAD

### 2.4.1 负载

代码片段：

```go
avg, _ := load.Avg()
pretty, _ := json.MarshalIndent(avg, "", "  ")
println("Avg:", string(pretty))
misc, _ := load.Misc()
pretty, _ = json.MarshalIndent(misc, "", "  ")
println("Misc:", string(pretty))
```

运行结果：

```
Avg: {
  "load1": 0,
  "load5": 0,
  "load15": 0
}
Misc: {
  "procsTotal": 0,
  "procsCreated": 0,
  "procsRunning": 0,
  "procsBlocked": 0,
  "ctxt": 0
}
```

## 2.5 MEM

### 2.5.1 虚拟内存

代码片段：

```go
virtualMemory, _ := mem.VirtualMemory()
pretty, _ := json.MarshalIndent(virtualMemory, "", "  ")
println("VirtualMemory:", string(pretty))
```

运行结果：

```
VirtualMemory: {
  "total": 8502890496,
  "available": 796385280,
  "used": 7706505216,
  "usedPercent": 90,
  "free": 796385280,
  "active": 0,
  "inactive": 0,
  "wired": 0,
  "laundry": 0,
  "buffers": 0,
  "cached": 0,
  "writeBack": 0,
  "dirty": 0,
  "writeBackTmp": 0,
  "shared": 0,
  "slab": 0,
  "sreclaimable": 0,
  "sunreclaim": 0,
  "pageTables": 0,
  "swapCached": 0,
  "commitLimit": 0,
  "committedAS": 0,
  "highTotal": 0,
  "highFree": 0,
  "lowTotal": 0,
  "lowFree": 0,
  "swapTotal": 0,
  "swapFree": 0,
  "mapped": 0,
  "vmallocTotal": 0,
  "vmallocUsed": 0,
  "vmallocChunk": 0,
  "hugePagesTotal": 0,
  "hugePagesFree": 0,
  "hugePagesRsvd": 0,
  "hugePagesSurp": 0,
  "hugePageSize": 0,
  "anonHugePages": 0
}
```

### 2.5.2 交换内存

代码片段：

```go
swapMemory, _ := mem.SwapMemory()
pretty, _ := json.MarshalIndent(swapMemory, "", "  ")
println("SwapMemory:", string(pretty))
```

运行结果：

```
SwapMemory: {
  "total": 22425178112,
  "used": 4906590208,
  "free": 17518587904,
  "usedPercent": 21.9,
  "sin": 0,
  "sout": 0,
  "pgIn": 0,
  "pgOut": 0,
  "pgFault": 0,
  "pgMajFault": 0
}
```

## 2.6 NET

### 2.6.1 网络计数

代码片段：

```go
counters, _ := net.IOCounters(true)
pretty, _ := json.MarshalIndent(counters, "", "  ")
println(string(pretty))
```

运行结果：

```
[
  {
    "name": "以太网 3",
    "bytesSent": 435026,
    "bytesRecv": 52149,
    "packetsSent": 807,
    "packetsRecv": 467,
    "errin": 0,
    "errout": 0,
    "dropin": 0,
    "dropout": 0,
    "fifoin": 0,
    "fifoout": 0
  },
  {
    "name": "本地连接",
    "bytesSent": 0,
    "bytesRecv": 0,
    "packetsSent": 0,
    "packetsRecv": 0,
    "errin": 0,
    "errout": 0,
    "dropin": 0,
    "dropout": 0,
    "fifoin": 0,
    "fifoout": 0
  }
]
```

### 2.6.2 网络连接

代码片段：

```go
// 可填入all、tcp、udp、tcp4、udp4
info, _ := net.Connections("tcp")
pretty, _ = json.MarshalIndent(info, "", "  ")
println(string(pretty))
```

运行结果：

```
[
  {
    "fd": 0,
    "family": 2,
    "type": 1,
    "localaddr": {
      "ip": "0.0.0.0",
      "port": 135
    },
    "remoteaddr": {
      "ip": "0.0.0.0",
      "port": 0
    },
    "status": "LISTEN",
    "uids": null,
    "pid": 1448
  }
]
```

## 2.7 PROCESS

### 2.7.1 进程列表

代码片段：

```go
processes, _ := process.Processes()
for _, pro := range processes {
	name, _ := pro.Name()
	println(pro.Pid, name)
}
```

运行结果：

```
27788 wpscloudsvr.exe
27832 fsnotifier64.exe
27940 WeChatAppEx.exe
27960 svchost.exe
28316 WeChatAppEx.exe
28332 RuntimeBroker.exe
28660 WeChatAppEx.exe
28828 chrome.exe
29020 SearchApp.exe
```

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述