# 第一部分 概述

`MCP`（Model Context Protocol ）是一个开放协议，标准化了应用程序如何为大型语言模型（`LLMs`）提供上下文。可以将`MCP`想象成`AI`应用程序的`USB-C`接口。正如`USB-C`提供了连接设备与各种外设和配件的标准化方式，`MCP`提供了一种标准化方式，将`AI`模型与不同的数据源和工具连接起来。



## 1.1 为什么选择 MCP？

`MCP`可以帮助你在大型语言模型（`LLMs`）之上构建代理和复杂的工作流。`LLMs`经常需要与数据和工具集成，而`MCP`提供了以下优势：

- 一个不断增长的预构建集成列表，`LLM`可以直接连接这些集成。
- 在不同的`LLM`提供商和供应商之间切换的灵活性。
- 在基础设施内确保数据安全的最佳实践。

## 1.2 一般架构

`MCP`基于客户端-服务器架构，核心思想是主机应用程序可以连接到多个服务器：


![01.png](/static/img/c662dd16cb00be0657d80491011eced4.01.webp)

- **MCP 主机**：应用程序如`Claude`、`IDE`或`AI`工具，通常需要通过`MCP`协议访问数据。
- **MCP 客户端**：这些客户端与服务器保持直接连接，用于处理实际的协议通信。
- **MCP 服务器**：轻量级程序，每个程序通过标准化的模型上下文协议暴露特定的功能。
- **本地数据源**：计算机上的文件、数据库和服务，MCP 服务器可以安全地访问这些数据。
- **远程服务**：通过互联网可访问的外部系统（例如，通过`API`），`MCP`服务器可以连接到这些服务。

## 1.3 基于MCP的集成架构

![640.webp](/static/img/882d7ad1f11bf158dc90d41b0d1e0daf.640.webp)

相对于`LLM`应用直连外部资源，这里主要多了一个中间层（`MCP Server`），以及连接这个中间层的（`MCP Client`）。

# 第二部分 MCP概念

## 2.1 核心架构

`MCP`建立在一个灵活且可扩展的架构之上，能够实现大型语言模型（`LLM`）应用程序与集成之间的无缝通信。

`MCP`采用`客户端`-`服务器`架构，其中：
 - **Hosts**：是发起连接的LLM应用程序（例如Claude Desktop或IDE）。
 - **Clients**：在宿主应用程序内与服务器保持一对一连接。
 - **Servers**：向客户端提供上下文、工具和提示。


![02.png](/static/img/d13c8dc38790c0f8725dc0e5153ad905.02.webp)

### 2.1.1 核心组件

- **协议层**：协议层负责消息封装、请求/响应关联以及高级通信模式。
- **传输层**：传输层负责客户端与服务器之间的实际通信。`MCP`支持多种传输机制：
    - 标准输入/输出传输（`Stdio transport`）
        - 使用标准输入/输出进行通信。
        - 适用于本地进程。
    - 带有服务器发送事件（`SSE`）的`HTTP`传输
        - 使用服务器发送事件进行服务器到客户端的消息传递。
        - 使用`HTTP POST`进行客户端到服务器的消息传递。


:::info{title="相关信息"}
所有传输机制均使用[`JSON-RPC 2.0`](https://www.jsonrpc.org/specification)来交换消息。有关模型上下文协议消息格式的详细信息，可查看[官网](https://www.jsonrpc.org/specification)说明或[JSON-RPC 2.0协议详解](https://blog.jianggujin.com/post/19)。
:::

- **消息类型**：`MCP`主要有以下几种消息类型：
    - **请求（Requests）**：期望从另一端获得响应。
    - **结果（Results）**：对请求的成功响应。
    - **错误（Errors）**：表示请求失败。
    - **通知（Notifications）**：单向消息，不期望响应。



### 2.1.2 连接生命周期
#### 2.1.2.1 初始化

![03.png](/static/img/57c6e01b25a5331c54d24967c4364d71.03.webp)

1. 客户端发送`initialize`请求，包含协议版本和功能。
2. 服务器响应其协议版本和功能。
3. 客户端发送`initialized`通知作为确认。
4. 开始正常的消息交换。

#### 2.1.2.2 消息交换
初始化完成后，支持以下模式：
- **请求-响应**：客户端或服务器发送请求，另一端响应。
- **通知**：任一方发送单向消息。

#### 2.1.2.3 终止

任一方都可以终止连接：
- 通过`close()`进行干净的关闭。
- 传输断开连接。
- 出现错误条件。

### 2.1.3 错误处理

`MCP`定义了以下标准错误代码：

```ts
enum ErrorCode {
  // Standard JSON-RPC error codes
  ParseError = -32700,
  InvalidRequest = -32600,
  MethodNotFound = -32601,
  InvalidParams = -32602,
  InternalError = -32603
}
```

`SDK`和应用程序可以在`-32000`以上定义自己的错误代码。

## 2.2 Resources（资源）

资源是`MCP`的核心原语，允许服务器向客户端暴露数据和内容，这些数据和内容可以被客户端读取，并用作与大型语言模型（`LLM`）交互的上下文。

资源代表了`MCP`服务器希望向客户端提供的任何类型的数据。这可以包括：

- 文件内容
- 数据库记录
- API响应
- 实时系统数据
- 截图和图片
- 日志文件
- 以及其他更多内容

每个资源都通过一个唯一的`URI`进行标识，并且可以包含文本或二进制数据。

### 2.2.1 资源URI

资源通过URI进行标识，其格式如下：

```
[protocol]://[host]/[path]
```

例如：

- `file:///home/user/documents/report.pdf`
- `postgres://database/customers/schema`
- `screen://localhost/display1`

协议和路径结构由`MCP`服务器实现定义。服务器可以定义自己的自定义`URI`方案。

### 2.2.2 资源类型

资源可以包含两种类型的内容：

- **文本资源**：文本资源包含`UTF-8`编码的文本数据。这些适用于：
    - 源代码
    - 配置文件
    - 日志文件
    - `JSON`/`XML`数据
    - 纯文本
- **二进制资源**：二进制资源包含以`base64`编码的原始二进制数据。这些适用于：
    - 图像
    - PDF文件
    - 音频文件
    - 视频文件
    - 其他非文本格式

### 2.2.3 资源发现

客户端可以通过两种主要方法发现可用资源：
- **直接资源**：服务器通过`resources/list`端点暴露一组具体的资源。每个资源包括：
```json
{
  uri: string;           // Unique identifier for the resource
  name: string;          // Human-readable name
  description?: string;  // Optional description
  mimeType?: string;     // Optional MIME type
}
```

- **资源模板**：对于动态资源，服务器可以暴露`URI`模板，客户端可以使用这些模板构建有效的资源`URI`。

```json
{
  uriTemplate: string;   // URI template following RFC 6570
  name: string;          // Human-readable name for this type
  description?: string;  // Optional description
  mimeType?: string;     // Optional MIME type for all matching resources
}
```

### 2.2.4 读取资源

要读取资源，客户端需要使用资源`URI`发起`resources/read`请求。

服务器会返回资源内容的列表：

```json
{
  contents: [
    {
      uri: string;        // The URI of the resource
      mimeType?: string;  // Optional MIME type

      // One of:
      text?: string;      // For text resources
      blob?: string;      // For binary resources (base64 encoded)
    }
  ]
}
```

:::tip{title="提示"}
服务器可能会对一个`resources/read`请求返回多个资源。例如，当读取一个目录时，这可以用来返回目录内的文件列表。
:::

### 2.2.5 资源更新

`MCP`通过两种机制支持资源的实时更新：

- **列表变更**：服务器可以通过`notifications/resources/list_changed`通知客户端其可用资源列表的变化。
- **内容变更**：客户端可以订阅特定资源的更新：
    1. 客户端发送`resources/subscribe`请求，包含资源`URI`。
    2. 资源变更时，服务器发送`notifications/resources/updated`通知。
    3. 客户端可以通过`resources/read`获取最新内容。
    4. 客户端可以通过`resources/unsubscribe`取消订阅。

## 2.3 Prompts（提示）

提示使服务器能够定义可重用的提示模板和工作流，客户端可以轻松地将其展示给用户和大型语言模型（`LLM`）。它们为标准化和共享常见的`LLM`交互提供了一种强大的方式。

`MCP`中的提示是预定义的模板，可以：
- 接受动态参数
- 包含来自资源的上下文
- 链接多个交互
- 指导特定的工作流
- 作为`UI`元素展示（例如斜杠命令）

### 2.3.1 提示结构

每个提示的定义包括：

```json
{
  name: string;              // Unique identifier for the prompt
  description?: string;      // Human-readable description
  arguments?: [              // Optional list of arguments
    {
      name: string;          // Argument identifier
      description?: string;  // Argument description
      required?: boolean;    // Whether argument is required
    }
  ]
}
```

### 2.3.2 发现提示

客户端可以通过`prompts/list`端点发现可用的提示：

```json
// Request
{
  method: "prompts/list"
}

// Response
{
  prompts: [
    {
      name: "analyze-code",
      description: "Analyze code for potential improvements",
      arguments: [
        {
          name: "language",
          description: "Programming language",
          required: true
        }
      ]
    }
  ]
}
```

### 2.3.3 使用提示

要使用提示，客户端需要发起`prompts/get`请求：

```json
// Request
{
  method: "prompts/get",
  params: {
    name: "analyze-code",
    arguments: {
      language: "python"
    }
  }
}

// Response
{
  description: "Analyze Python code for potential improvements",
  messages: [
    {
      role: "user",
      content: {
        type: "text",
        text: "Please analyze the following Python code for potential improvements:\n\n```python\ndef calculate_sum(numbers):\n    total = 0\n    for num in numbers:\n        total = total + num\n    return total\n\nresult = calculate_sum([1, 2, 3, 4, 5])\nprint(result)\n```"
      }
    }
  ]
}
```

### 2.3.4 动态提示

提示可以是动态的，并包含以下内容：

- **嵌入资源上下文**

在处理`prompts/get`请求时：
```json
{
  "name": "analyze-project",
  "description": "Analyze project logs and code",
  "arguments": [
    {
      "name": "timeframe",
      "description": "Time period to analyze logs",
      "required": true
    },
    {
      "name": "fileUri",
      "description": "URI of code file to review",
      "required": true
    }
  ]
}
```

在处理`prompts/get`请求时：

```json
{
  "messages": [
    {
      "role": "user",
      "content": {
        "type": "text",
        "text": "Analyze these system logs and the code file for any issues:"
      }
    },
    {
      "role": "user",
      "content": {
        "type": "resource",
        "resource": {
          "uri": "logs://recent?timeframe=1h",
          "text": "[2024-03-14 15:32:11] ERROR: Connection timeout in network.py:127\n[2024-03-14 15:32:15] WARN: Retrying connection (attempt 2/3)\n[2024-03-14 15:32:20] ERROR: Max retries exceeded",
          "mimeType": "text/plain"
        }
      }
    },
    {
      "role": "user",
      "content": {
        "type": "resource",
        "resource": {
          "uri": "file:///path/to/code.py",
          "text": "def connect_to_service(timeout=30):\n    retries = 3\n    for attempt in range(retries):\n        try:\n            return establish_connection(timeout)\n        except TimeoutError:\n            if attempt == retries - 1:\n                raise\n            time.sleep(5)\n\ndef establish_connection(timeout):\n    # Connection implementation\n    pass",
          "mimeType": "text/x-python"
        }
      }
    }
  ]
}
```

- **多步骤工作流**

```ts
const debugWorkflow = {
  name: "debug-error",
  async getMessages(error: string) {
    return [
      {
        role: "user",
        content: {
          type: "text",
          text: `Here's an error I'm seeing: ${error}`
        }
      },
      {
        role: "assistant",
        content: {
          type: "text",
          text: "I'll help analyze this error. What have you tried so far?"
        }
      },
      {
        role: "user",
        content: {
          type: "text",
          text: "I've tried restarting the service, but the error persists."
        }
      }
    ];
  }
};
```

## 2.4 Tools（工具）

工具是`MCP`中一个强大的原语，它允许服务器向客户端暴露可执行的功能。通过工具，`LLM`可以与外部系统交互、执行计算以及在现实世界中采取行动。

`MCP`中的工具允许服务器暴露可被客户端调用并由`LLM`用于执行操作的可执行函数。工具的关键特性包括：

- **发现**：客户端可以通过`tools/list`端点列出可用的工具。
- **调用**：工具通过`tools/call`端点被调用，服务器执行请求的操作并返回结果。
- **灵活性**：工具可以是从简单计算到复杂API交互的任何内容。

与资源类似，工具通过唯一名称进行标识，并且可以包含描述以指导其使用。然而，与资源不同的是，工具代表动态操作，可以修改状态或与外部系统交互。

**每个工具的定义结构如下**：

```json
{
  name: string;          // Unique identifier for the tool
  description?: string;  // Human-readable description
  inputSchema: {         // JSON Schema for the tool's parameters
    type: "object",
    properties: { ... }  // Tool-specific parameters
  }
}
```

**`MCP`支持动态工具发现**：

1. 客户端可以随时列出可用的工具。
2. 服务器可以通过`notifications/tools/list_changed`通知客户端工具的变化。
3. 工具可以在运行时添加或移除。
4. 工具定义可以更新（尽管这应该谨慎进行）。

## 2.5 Roots（根目录）

根目录是`MCP`中的一个概念，用于定义服务器可以操作的边界。它们为客户端提供了一种方式，用于告知服务器相关资源及其位置。

### 2.5.1 什么是根目录？

根目录是一个客户端建议服务器关注的`URI`。当客户端连接到服务器时，它会声明服务器应该使用哪些根目录。根目录主要用于文件系统路径，但也可以是任何有效的`URI`，包括`HTTP URL`。

例如，根目录可以是：

- `file:///home/user/projects/myapp`
- `https://api.example.com/v1`

### 2.5.2 为什么使用根目录？

根目录有以下几个重要的作用：

1. **引导**：它们告知服务器相关资源和位置。
2. **明确性**：根目录明确了哪些资源属于你的工作空间。
3. **组织性**：多个根目录允许你同时处理不同的资源。

### 2.5.3 根目录的工作原理

当客户端支持根目录时，它会：

1. 在连接时声明`roots`能力。
2. 向服务器提供一组建议的根目录。
3. 在支持的情况下，当根目录发生变化时通知服务器。

虽然根目录是信息性的，并不强制执行，但服务器应该：

1. 尊重提供的根目录。
2. 使用根目录URI定位和访问资源。
3. 优先在根目录边界内执行操作。

## 2.6 Transports（传输）

在`MCP`中，传输为客户端和服务器之间的通信提供了基础。传输层负责消息发送和接收的底层机制。

### 2.6.1 消息格式

`MCP`使用`[JSON-RPC 2.0](https://blog.jianggujin.com/post/19)`作为其传输格式。传输层负责将`MCP`协议消息转换为`JSON-RPC`格式以进行传输，并将接收到的`JSON-RPC`消息转换回`MCP`协议消息。

使用的JSON-RPC消息有三种类型：

- 请求（Requests）

```json
{
  jsonrpc: "2.0",
  id: number | string,
  method: string,
  params?: object
}
```

- 响应（Responses）

```json
{
  jsonrpc: "2.0",
  id: number | string,
  result?: object,
  error?: {
    code: number,
    message: string,
    data?: unknown
  }
}
```

- 通知（Notifications）

```json
{
  jsonrpc: "2.0",
  method: string,
  params?: object
}
```

### 2.6.2 内置传输类型

MCP提供了两种标准的传输实现：

- **标准输入/输出（stdio）**：通过标准输入和输出流实现通信。这种传输方式特别适用于本地集成和命令行工具。使用stdio的情况：
    - 构建命令行工具时
    - 实现本地集成时
    - 需要简单的进程间通信时
    - 使用shell脚本时

- **服务器发送事件（`SSE`）**：通过`HTTP POST`请求实现客户端到服务器的通信，同时支持服务器到客户端的流式传输。使用`SSE`的情况：
    - 只需要服务器到客户端的流式传输时
    - 在受限网络环境中工作时
    - 实现简单的更新时

### 2.6.3 自定义传输

`MCP`支持为特定需求实现自定义传输。任何传输实现只需符合`Transport`接口即可：

可以为以下场景实现自定义传输：

- 自定义网络协议
- 专用通信通道
- 与现有系统的集成
- 性能优化

# 第三部分 MCP常用地址
- [官网 (modelcontextprotocol.io)](https://modelcontextprotocol.io/introduction)
- [MCP servers](https://github.com/modelcontextprotocol/servers)
- [MCP Server精选 (glama.ai)](https://glama.ai/mcp/servers)
- [MCP Server精选 (awesome-mcp-servers)](https://github.com/punkpeye/awesome-mcp-servers)
- [社区驱动的平台 (mcp.so)](https://mcp.so/)
- [portkey.ai](https://portkey.ai/mcp-servers)
- [把stdio-based转化为SSE远程Server](https://github.com/supercorp-ai/supergateway)
- [LangChain的mcp适配器](https://github.com/langchain-ai/langchain-mcp-adapters)
- [FastMCP (Python)](https://github.com/jlowin/fastmcp)
- [FastMCP (TypeScript)](https://github.com/punkpeye/fastmcp)
- [SDKs (Python)](https://github.com/modelcontextprotocol/python-sdk)
- [SDKs (TypeScript)](https://github.com/modelcontextprotocol/typescript-sdk)
- [Inspector：用于测试和调试MCP服务器的开发工具](https://github.com/modelcontextprotocol/inspector)
- [MCP YouTube：用于yt-dlp从 YouTube 下载字幕](https://github.com/anaisbetts/mcp-youtube)
- [mcp-security-scanner：使用 MCP 插件构建的安全漏洞扫描器，用于分析 JavaScript 代码](https://github.com/DMontgomery40/mcp-security-scanner)
- [Cloudflare MCP Server：这是一个用于与 Cloudflare 服务交互的模型上下文协议 (MCP) 服务器。它提供了用于管理 Cloudflare KV Store、R2 Storage、D1 Database、Workers 和 Analytics 的统一界面](https://github.com/cloudflare/mcp-server-cloudflare)
- [mcp-get：用于安装和管理模型上下文协议 (MCP) 服务器的命令行工具](https://github.com/michaellatman/mcp-get)

Model Context Protocol (MCP)

# 第一部分 概述

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

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分 概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述

第一部分概述