# 第一部分 概述
在软件开发中，版本管理是一个至关重要的环节。`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
```

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

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述