@colin4k1024/tsp 2.4.0

package/skills/goframe-v2/references//346/240/270/345/277/203/347/273/204/344/273/266/I18N/345/233/275/351/231/205/345/214/226/I18N/345/233/275/351/231/205/345/214/226-/344/275/277/347/224/250/344/273/213/347/273/215.md

@@ -0,0 +1,338 @@
+## 对象创建
+
+### 单例对象
+
+大多数场景下，我们推荐使用 `g.I18n` 单例对象，并可自定义配置不同的单例对象，但是需要注意的是，单例对象的配置修改是全局有效的。例如：
+
+```go
+g.I18n().T(context.TODO(), "{#hello} {#world}")
+```
+:::tip
+在所有的转译方法中，第一个参数都要求输入 `Context` 上下文变量参数，用于上下文变量的传递、翻译语言的指定、后续的可扩展能力。该参数虽然直接传递 `nil` 也是可以的，但是为保证程序的严谨性，我们建议您当不知道传递什么或者没有特殊要求的时候传递 `context.TODO()` 或者 `context.Background()` 来替代。
+:::
+### 独立对象
+
+其次，我们也可以模块化独立使用 `gi18n` 模块，通过 `gi18n.New()` 方法创建独立的 `i18n` 对象，然后开发者自行进行管理。例如：
+
+```go
+i18n := gi18n.New()
+i18n.T(context.TODO(), "{#hello} {#world}")
+```
+
+## 语言设置
+
+设置转译语言有两种方式，一种是通过 `SetLanguage` 方法设置当前 `I18N` 对象统一的转译语言，另一种是通过上下文设置当前执行转译的语言。
+
+### `SetLanguage`
+
+例如，我们通过 `g.I18n().SetLanguage("zh-CN")` 即可设置当前转译对象的转译语言，随后使用该对象都将使用 `zh-CN` 进行转译。需要注意的是，组件的配置方法往往都不是并发安全的，该方法也同样如此，需要在程序初始化时进行设置，随后不能在运行时进行更改。
+
+### `WithLanguage`
+
+`WithLanguage` 方法可以创建一个新的上下文变量，并临时设置您当前转译的语言，由于该方法作用于 `Context` 上下文，因此是并发安全的，常用于运行时转译语言设置。我们来看一个例子：
+
+```go
+ctx := gi18n.WithLanguage(context.TODO(), "zh-CN")
+i18n.Translate(ctx, `hello`)
+```
+
+其中 `WithLanguage` 方法定义如下：
+
+```go
+// WithLanguage append language setting to the context and returns a new context.
+func WithLanguage(ctx context.Context, language string) context.Context
+```
+
+用于将转译语言设置到上下文变量中，并返回一个新的上下文变量，该变量可用于后续的转译方法。
+
+## 常用方法
+
+### `T` 方法
+
+`T` 方法为 `Translate` 方法的别名，也是大多数时候我们推荐使用的方法名称。 `T` 方法可以给定关键字名称，也可以直接给定模板内容，将会被自动转译并返回转译后的字符串内容。
+
+此外， `T` 方法可以通过第二个语言参数指定需要转译的目标语言名称，该名称需要和配置文件/路径中的名称一致，往往是标准化的国际化语言缩写名称例如： `en/ja/ru/zh-CN/zh-TW` 等等。否则，将会自动使用 `Manager` 转译对象中设置的语言进行转译。
+
+方法定义：
+
+```go
+// T translates <content> with configured language and returns the translated content.
+func T(ctx context.Context, content string)
+```
+
+**关键字转译**
+
+关键字的转译直接给 `T` 方法传递关键字即可，例如： `T(context.TODO(), "hello")`、 `T(context.TODO(), "world")`。 `I18N` 组件将会优先将给定的关键字进行转译，转译成后返回转译后的内容，否则直接展示原内容。
+
+**模板内容转译**
+
+`T` 方法支持模板内容转换，模板中的关键字默认使用 `{#` 和 `}` 标签进行包含，模板解析时将会自动替换该标签中的关键字内容。使用示例：
+
+#### 1）目录结构
+
+```bash
+├── main.go
+└── i18n
+    ├── en.toml
+    ├── ja.toml
+    ├── ru.toml
+    └── zh-CN.toml
+```
+
+#### 2）转译文件
+
+`ja.toml`
+
+```bash
+hello = "こんにちは"
+world = "世界"
+```
+
+`ru.toml`
+
+```bash
+hello = "Привет"
+world = "мир"
+```
+
+`zh-CN.toml`
+
+```bash
+hello = "你好"
+world = "世界"
+```
+
+#### 3）示例代码
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/os/gctx"
+
+    "github.com/gogf/gf/v2/i18n/gi18n"
+)
+
+func main() {
+    var (
+        ctx  = gctx.New()
+        i18n = gi18n.New()
+    )
+
+    i18n.SetLanguage("en")
+    fmt.Println(i18n.Translate(ctx, `hello`))
+    fmt.Println(i18n.Translate(ctx, `GF says: {#hello}{#world}!`))
+
+    i18n.SetLanguage("ja")
+    fmt.Println(i18n.Translate(ctx, `hello`))
+    fmt.Println(i18n.Translate(ctx, `GF says: {#hello}{#world}!`))
+
+    i18n.SetLanguage("ru")
+    fmt.Println(i18n.Translate(ctx, `hello`))
+    fmt.Println(i18n.Translate(ctx, `GF says: {#hello}{#world}!`))
+
+    ctx = gi18n.WithLanguage(ctx, "zh-CN")
+    fmt.Println(i18n.Translate(ctx, `hello`))
+    fmt.Println(i18n.Translate(ctx, `GF says: {#hello}{#world}!`))
+}
+```
+
+执行后，终端输出为：
+
+```bash
+Hello
+GF says: HelloWorld!
+こんにちは
+GF says: こんにちは世界!
+Привет
+GF says: Приветмир!
+你好
+GF says: 你好世界!
+```
+
+### `Tf` 方法
+
+我们都知道，模板内容中也会存在一些变量，这些变量可以通过 `Tf` 方法进行转译。
+
+`Tf` 为 `TranslateFormat` 的别名，该方法支持格式化转译内容，字符串格式化语法参考标准库 `fmt` 包的 `Sprintf` 方法。
+
+**方法定义：**
+
+```go
+// Tf translates, formats and returns the <format> with configured language
+// and given <values>.
+func Tf(ctx context.Context, format string, values ...interface{}) string
+```
+
+我们来看一个简单的示例。
+
+#### 1）目录结构
+
+```bash
+├── main.go
+└── i18n
+    ├── en.toml
+    └── zh-CN.toml
+```
+
+#### 2） **转译文件**
+
+`en.toml`
+
+```bash
+OrderPaid = "You have successfully complete order #%d payment, paid amount: ￥%0.2f."
+```
+
+`zh-CN.toml `
+
+```bash
+OrderPaid = "您已成功完成订单号 #%d 支付，支付金额￥%.2f。"
+```
+
+#### 3） **示例代码**
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/i18n/gi18n"
+    "github.com/gogf/gf/v2/os/gctx"
+)
+
+func main() {
+    var (
+        ctx         = gctx.New()
+        orderId     = 865271654
+        orderAmount = 99.8
+    )
+
+    i18n := gi18n.New()
+    i18n.SetLanguage("en")
+    fmt.Println(i18n.Tf(ctx, `{#OrderPaid}`, orderId, orderAmount))
+
+    i18n.SetLanguage("zh-CN")
+    fmt.Println(i18n.Tf(ctx, `{#OrderPaid}`, orderId, orderAmount))
+}
+```
+
+执行后，终端输出为：
+
+```bash
+You have successfully complete order #865271654 payment, paid amount: ￥99.80.
+您已成功完成订单号 #865271654 支付，支付金额￥99.80。
+```
+:::note
+为方便演示，该示例中对支付金额的处理比较简单，在实际项目中往往需要在业务代码中对支付金额的单位按照区域做自动转换，再渲染 `i18n` 显示内容。
+:::
+### 上下文设置转译语言
+
+我们将上面的示例做些改动来演示。
+
+#### 1）目录结构
+
+```bash
+├── main.go
+└── i18n
+    ├── en.toml
+    └── zh-CN.toml
+```
+
+#### 2）转译文件
+
+`en.toml`
+
+```bash
+OrderPaid = "You have successfully complete order #%d payment, paid amount: ￥%0.2f."
+```
+
+`zh-CN.toml`
+
+```bash
+OrderPaid = "您已成功完成订单号 #%d 支付，支付金额￥%.2f。"
+```
+
+#### 3）示例代码
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/i18n/gi18n"
+)
+
+func main() {
+    var (
+        orderId     = 865271654
+        orderAmount = 99.8
+    )
+    fmt.Println(g.I18n().Tf(
+        gi18n.WithLanguage(context.TODO(), `en`),
+        `{#OrderPaid}`, orderId, orderAmount,
+    ))
+    fmt.Println(g.I18n().Tf(
+        gi18n.WithLanguage(context.TODO(), `zh-CN`),
+        `{#OrderPaid}`, orderId, orderAmount,
+    ))
+}
+```
+
+执行后，终端输出为：
+
+```bash
+You have successfully complete order #865271654 payment, paid amount: ￥99.80.
+您已成功完成订单号 #865271654 支付，支付金额￥99.80。
+```
+:::note
+为方便演示，该示例中对支付金额的处理比较简单，在实际项目中往往需要在业务代码中对支付金额的单位按照区域做自动转换，再渲染 `i18n` 显示内容。
+:::
+## `I18N` 与视图引擎
+
+`gi18n` 默认已经集成到了 `GoFrame` 框架的视图引擎中，直接在模板文件/内容中使用 `gi18n` 的关键字标签即可。我们同样可以通过上下文变量的形式来设置当前请求的转译语言。
+:::tip
+此外，我们也可以通过设置模板变量 `I18nLanguage` 设置当前模板的解析语言，该变量可以控制不同的模板内容按照不同的国际化语言进行解析。
+:::
+使用示例：
+
+```go
+package main
+
+import (
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/i18n/gi18n"
+    "github.com/gogf/gf/v2/net/ghttp"
+)
+
+func main() {
+    s := g.Server()
+    s.Group("/", func(group *ghttp.RouterGroup) {
+        group.Middleware(func(r *ghttp.Request) {
+            r.SetCtx(gi18n.WithLanguage(r.Context(), r.Get("lang", "zh-CN").String()))
+            r.Middleware.Next()
+        })
+        group.ALL("/", func(r *ghttp.Request) {
+            r.Response.WriteTplContent(`{#hello}{#world}!`)
+        })
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+
+执行后，访问以下页面，将会输出：
+
+1. [http://127.0.0.1:8199](http://127.0.0.1:8199/)
+
+```bash
+你好世界!
+```
+
+2. [http://127.0.0.1:8199/?lang=ja](http://127.0.0.1:8199/?lang=ja)
+
+```bash
+こんにちは世界!
+```

package/skills/goframe-v2/references//346/240/270/345/277/203/347/273/204/344/273/266/I18N/345/233/275/351/231/205/345/214/226/I18N/345/233/275/351/231/205/345/214/226-/351/205/215/347/275/256/347/256/241/347/220/206.md

@@ -0,0 +1,69 @@
+作为框架的核心组件之一，传承 `goframe` 一贯的便捷化设计思想， `I18N` 国际化组件的配置管理非常简便。
+
+## 文件格式
+
+`gi18n` 国际化组件支持框架通用的五种配置文件格式： `xml/ini/yaml/toml/json/properties`（更详细的文件支持列表具体以配置管理章节为主： [配置管理](../配置管理/配置管理.md)）。同样的，和配置管理模块一样，框架推荐使用 `toml` 文件格式。
+
+## 读取路径
+
+默认情况下 `gi18n` 会自动查找并读取当前项目源码根目录（或者当前 `PWD` 运行目录下）下的以下目录：
+
+- `manifest/i18n`
+- `i18n`
+
+默认将查找到的目录作为国际化转译文件存储目录。开发者也可以通过 `SetPath` 方法自定义 `i18n` 文件的存储目录路径。
+
+## 文件存储
+
+在 `i18n` 目录下可以直接按照国际化名称命名的文件如： `en.toml`/ `ja.toml`/ `zh-CN.toml`；也可以给定国际化名称目录，目录下随意自定义配置文件，如： `en/editor.toml`/ `en/user.toml`、 `zh-CN/editor.toml`/ `zh-CN/user.toml`。您使用纯文件管理或者增加一级目录管理都是可以的， `gi18n` 可以智能识别加载。
+:::tip
+国际化的文件/目录名称都是开发者可自行定义和维护的，该名称主要用于程序中设置和使用。建议按照标准化的国际化地区语言码进行命名，具体请参考WIKI： [https://zh.wikipedia.org/wiki/ISO\_639-1](https://zh.wikipedia.org/wiki/ISO_639-1)
+:::
+例如，以下的 `i18n` 目录结构以及文件格式都是支持的。
+
+**通过单独的 `i18n` 文件区分不同的语言**
+
+```
+└── i18n
+    ├── en.toml
+    ├── ja.toml
+    ├── ru.toml
+    ├── zh-CN.toml
+    └── zh-TW.toml
+```
+
+**通过不同的目录名称区分不同的语言**
+
+```
+└── i18n
+    ├── en
+    │   ├── hello.toml
+    │   └── world.toml
+    ├── ja
+    │   ├── hello.yaml
+    │   └── world.yaml
+    ├── ru
+    │   ├── hello.ini
+    │   └── world.ini
+    ├── zh-CN
+    │   ├── hello.json
+    │   └── world.json
+    └── zh-TW
+        ├── hello.xml
+        └── world.xml
+```
+
+**不同语言可以存在不同文件格式**
+
+```
+└── i18n
+    ├── en.toml
+    ├── ja.yaml
+    ├── ru.ini
+    ├── zh-CN.json
+    └── zh-TW.xml
+```
+
+## 资源管理器
+
+`gi18n` 默认支持资源管理器（详情请参考章节： [资源管理](../资源管理/资源管理.md)），默认情况下会从 `gres` 配置管理器中检索 `manifest/i18n` 及 `i18n` 目录，或者开发者设置的 `i18n` 目录路径。

package/skills/goframe-v2/references//346/240/270/345/277/203/347/273/204/344/273/266/I18N/345/233/275/351/231/205/345/214/226/I18N/345/233/275/351/231/205/345/214/226.md

@@ -0,0 +1,15 @@
+## 基本介绍
+
+`GoFrame` 框架提供了常用的 `I18N` 国际化组件，由 `gi18n` 模块实现。
+
+**使用方式：**
+
+```go
+import "github.com/gogf/gf/v2/i18n/gi18n"
+```
+
+**接口文档**：
+
+[https://pkg.go.dev/github.com/gogf/gf/v2/i18n/gi18n](https://pkg.go.dev/github.com/gogf/gf/v2/i18n/gi18n)
+
+## 相关文档

package/skills/goframe-v2/references//346/240/270/345/277/203/347/273/204/344/273/266//345/221/275/344/273/244/347/256/241/347/220/206//345/221/275/344/273/244/347/256/241/347/220/206-Parser/350/247/243/346/236/220.md

@@ -0,0 +1,72 @@
+## 基本介绍
+
+命令行解析最主要的是针对于选项的解析， `gcmd` 组件提供了 `Parse` 方法，用于自定义解析选项，包括有哪些选项名称，每个选项是否带有数值。根据这一配置便可将所有的参数和选项进行解析归类。
+:::tip
+大部分场景下，我们并不需要显式创建 `Parser` 对象，因为我们有层级管理以及对象管理方式来管理多命令。但底层仍然是采用 `Parser` 方式实现，因此本章节大家了解原理即可。
+:::
+相关方法：
+
+更多 `Parser` 方法请参考接口文档： [https://pkg.go.dev/github.com/gogf/gf/v2/os/gcmd#Parser](https://pkg.go.dev/github.com/gogf/gf/v2/os/gcmd#Parser)
+
+```go
+func Parse(supportedOptions map[string]bool, option ...ParserOption) (*Parser, error)
+func ParseWithArgs(args []string, supportedOptions map[string]bool, option ...ParserOption) (*Parser, error)
+func ParserFromCtx(ctx context.Context) *Parser
+func (p *Parser) GetArg(index int, def ...string) *gvar.Var
+func (p *Parser) GetArgAll() []string
+func (p *Parser) GetOpt(name string, def ...interface{}) *gvar.Var
+func (p *Parser) GetOptAll() map[string]string
+```
+
+其中， `ParserOption` 如下：
+
+```go
+// ParserOption manages the parsing options.
+type ParserOption struct {
+    CaseSensitive bool // Marks options parsing in case-sensitive way.
+    Strict        bool // Whether stops parsing and returns error if invalid option passed.
+}
+```
+
+解析示例：
+
+```go
+parser, err := gcmd.Parse(g.MapStrBool{
+    "n,name":    true,
+    "v,version": true,
+    "a,arch":    true,
+    "o,os":      true,
+    "p,path":    true,
+})
+```
+
+可以看到，选项输入参数其实是一个 `map` 类型。其中键值为选项名称，同一个选项的不同名称可以通过 `,` 符号进行分隔。比如，该示例中 `n` 和 `name` 选项是同一个选项，当用户输入 `-n john` 的时候， `n` 和 `name` 选项都会获得到数据 `john`。
+
+而键值是一个布尔类型，标识该选项是否需要解析参数。这一选项配置是非常重要的，因为有的选项是不需要获得数据的，仅仅作为一个标识。例如， `-f force` 这个输入，在需要解析数据的情况下，选项 `f` 的值为 `force`；而在不需要解析选项数据的情况下，其中的 `force` 便是命令行的一个参数，而不是选项。
+
+## 使用示例
+
+```go
+func ExampleParse() {
+    os.Args = []string{"gf", "build", "main.go", "-o=gf.exe", "-y"}
+    p, err := gcmd.Parse(g.MapStrBool{
+        "o,output": true,
+        "y,yes":    false,
+    })
+    if err != nil {
+        panic(err)
+    }
+    fmt.Println(p.GetOpt("o"))
+    fmt.Println(p.GetOpt("output"))
+    fmt.Println(p.GetOpt("y") != nil)
+    fmt.Println(p.GetOpt("yes") != nil)
+    fmt.Println(p.GetOpt("none") != nil)
+
+    // Output:
+    // gf.exe
+    // gf.exe
+    // true
+    // true
+    // false
+}
+```

package/skills/goframe-v2/references//346/240/270/345/277/203/347/273/204/344/273/266//345/221/275/344/273/244/347/256/241/347/220/206//345/221/275/344/273/244/347/256/241/347/220/206-/345/221/275/344/273/244/350/241/214/345/257/271/350/261/241.md

@@ -0,0 +1,193 @@
+## 基本介绍
+
+大部分场景下，我们通过`Command`命令行对象来管理单个或多个命令，并且使用默认的命令行解析规则（不用显式使用`Parser`解析器）即可。`Command`对象定义如下：
+
+详细请参考接口文档： [https://pkg.go.dev/github.com/gogf/gf/v2/os/gcmd@master#Command](https://pkg.go.dev/github.com/gogf/gf/v2/os/gcmd@master#Command)
+
+```go
+// Command holds the info about an argument that can handle custom logic.
+type Command struct {
+    Name          string        // Command name(case-sensitive).
+    Usage         string        // A brief line description about its usage, eg: gf build main.go [OPTION]
+    Brief         string        // A brief info that describes what this command will do.
+    Description   string        // A detailed description.
+    Arguments     []Argument    // Argument array, configuring how this command act.
+    Func          Function      // Custom function.
+    FuncWithValue FuncWithValue // Custom function with output parameters that can interact with command caller.
+    HelpFunc      Function      // Custom help function
+    Examples      string        // Usage examples.
+    Additional    string        // Additional info about this command, which will be appended to the end of help info.
+    Strict        bool          // Strict parsing options, which means it returns error if invalid option given.
+    Config        string        // Config node name, which also retrieves the values from config component along with command line.
+    parent        *Command      // Parent command for internal usage.
+    commands      []*Command    // Sub commands of this command.
+}
+```
+
+由于对象均有详细的注释，这里不再赘述。
+
+## 回调方法
+
+`Command`对象支持3个回调方法：
+
+- `Func` 我们一般需要自定义这个回调方法，用于实现当前命令执行的操作。
+- `FuncWithValue` 方法同`Func`，只不过支持返回值，往往用于命令行相互调用的场景，一般项目用不到。
+- `HelpFunc` 自定义帮助信息，一般来说没有太大必要，因为`Command`对象能够自动生成帮助信息。
+
+我们主要关注`Func`回调方法即可，其他方法大家感兴趣可以自行研究。
+
+## Func 回调
+
+方法定义：
+
+```go
+// Function is a custom command callback function that is bound to a certain argument.
+type Function func(ctx context.Context, parser *Parser) (err error)
+```
+
+可以看到，在回调方法内部，我们通过 `parser` 对象获取解析参数和选项，并通过返回 `error` 来告诉上层调用方法是否执行成功。
+
+使用示例：
+
+```go
+package main
+
+import (
+    "context"
+
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/net/ghttp"
+    "github.com/gogf/gf/v2/os/gcmd"
+    "github.com/gogf/gf/v2/os/gctx"
+)
+
+var (
+    Main = &gcmd.Command{
+        Name:        "main",
+        Brief:       "start http server",
+        Description: "this is the command entry for starting your http server",
+        Func: func(ctx context.Context, parser *gcmd.Parser) (err error) {
+            s := g.Server()
+            s.BindHandler("/", func(r *ghttp.Request) {
+                r.Response.Write("Hello world")
+            })
+            s.SetPort(8199)
+            s.Run()
+            return
+        },
+    }
+)
+
+func main() {
+    Main.Run(gctx.New())
+}
+```
+
+这也是大部分项目的启动命令行对象的样子，大部分项目只有一个启动入口，并且只会有一个回调方法实现。
+
+## 帮助信息生成
+
+`Command`对象虽然可以自定义`HelpFunc`帮助回调方法，但`Command`对象可以自动生成`Help`使用帮助信息，大部分场景下无需自定义。并且`gcmd`组件默认内置了支持了`h`/`help`选项，因此使用`gcmd`组件的程序可以通过这两个选项自动生成`Help`帮助信息。
+
+我们来看一个例子，我们先通过 `go build main.go` 把上面的例子编译为二进制 `main` 文件，然后来简单看一下只有一个命令场景下自动生成的帮助信息：
+
+```bash
+$ ./main -h
+USAGE
+    main [OPTION]
+
+DESCRIPTION
+    this is the command entry for starting your http server
+```
+
+## 层级命令管理
+
+### 父命令与子命令
+
+一个`Command`命令可以添加子级命令，当`Command`存在子级命令时，自己便成为了父级命令。子级命令也可以添加自己的子级命令，以此类推，形成层级命令关系。父级命令和子级命令都可以有自己的回调方法，不过大部分场景下，一旦`Command`成为了父级命令，回调方法往往都没有太大存在的必要。我们通常通过`AddCommand`方法为`Command`添加子级命令：
+
+```go
+// AddCommand adds one or more sub-commands to current command.
+func (c *Command) AddCommand(commands ...*Command) error
+```
+
+### 层级命令使用示例
+
+我们来演示一个多命令管理的示例。我们将上面的例子改进一下，增加两个子级命令。
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+
+    "github.com/gogf/gf/v2/os/gcmd"
+    "github.com/gogf/gf/v2/os/gctx"
+)
+
+var (
+    Main = &gcmd.Command{
+        Name:        "main",
+        Brief:       "start http server",
+        Description: "this is the command entry for starting your process",
+    }
+    Http = &gcmd.Command{
+        Name:        "http",
+        Brief:       "start http server",
+        Description: "this is the command entry for starting your http server",
+        Func: func(ctx context.Context, parser *gcmd.Parser) (err error) {
+            fmt.Println("start http server")
+            return
+        },
+    }
+    Grpc = &gcmd.Command{
+        Name:        "grpc",
+        Brief:       "start grpc server",
+        Description: "this is the command entry for starting your grpc server",
+        Func: func(ctx context.Context, parser *gcmd.Parser) (err error) {
+            fmt.Println("start grpc server")
+            return
+        },
+    }
+)
+
+func main() {
+    err := Main.AddCommand(Http, Grpc)
+    if err != nil {
+        panic(err)
+    }
+    Main.Run(gctx.New())
+}
+```
+
+可以看到，我们通过 `AddCommand` 命令为主命令增加了两个子级命令 `http`/`grpc`，分别用于开启 `HTTP`/`gRPC` 服务。当存在子级命令式，父命令往往便没有 `Func` 回调定义的必要了，因此我们这里去掉了 `main` 命令的 `Func` 定义。
+
+我们编译后来执行一下看看效果：
+
+```bash
+$ main
+USAGE
+    main COMMAND [OPTION]
+
+COMMAND
+    http    start http server
+    grpc    start grpc server
+
+DESCRIPTION
+    this is the command entry for starting your process
+```
+
+使用 `http` 命令：
+
+```bash
+$ main http
+start http server
+```
+
+使用 `grpc` 命令：
+
+```bash
+$ main grpc
+start grpc server
+```