Golang中基础的命令行模块urfave/cli的用法说明

Golang是一种开发高效、安全和可维护软件应用程序的编程语言，广泛应用于网络编程和系统编程中。Golang中基础的命令行模块 urfave/cli 提供了一种简单的方法来处理命令行参数和选项，它的主要功能包括处理命令行选项、参数、帮助信息、全局选项等功能。下面将详细讲解 urfave/cli 的用法。

安装 urfave/cli

可以使用 go get 命令来安装 urfave/cli

go get -u github.com/urfave/cli

urfave/cli 命令行参数解析

使用 urfave/cli，我们可以轻松解析命令行参数和选项，例如：

package main

import (
    "fmt"
    "os"

    "github.com/urfave/cli"
)

func main() {
    app := cli.NewApp()

    app.Flags = []cli.Flag{
        cli.BoolFlag{
            Name:  "debug, d",
            Usage: "启用 debug 模式",
        },
        cli.StringFlag{
            Name:  "config, c",
            Value: "config.yml",
            Usage: "指定配置文件路径",
        },
    }

    app.Action = func(c *cli.Context) error {
        debug := c.Bool("debug")
        config := c.String("config")

        fmt.Printf("debug 模式：%v\n", debug)
        fmt.Printf("配置文件路径：%s\n", config)

        return nil
    }

    err := app.Run(os.Args)
    if err != nil {
        fmt.Println(err)
    }
}

在这个示例中，我们定义了两个选项：--debug 和 --config。启用 --debug，可以在终端输出调试信息。指定 --config，可以指定配置文件的路径。通过 cli.Context，我们可以轻松获取命令行的参数和选项的值。

urfave/cli 命令行示例

接下来，我们来看一个更完整的命令行示例。示例程序通过命令行输入路径，读取指定目录下的所有文件（包括子目录中的文件），并对文件进行操作。示例中实现了以下命令行选项：

• -p, --path：指定目录路径，默认为当前目录。
• -t：指定操作类型，包括 count 和 size，默认为 count。
• -e：指定要操作的文件扩展名，多个扩展名用逗号隔开。

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "path/filepath"
    "strings"

    "github.com/urfave/cli"
)

func main() {
    app := cli.NewApp()
    app.Name = "filecount"
    app.Usage = "统计指定目录下的文件数或文件总大小"
    app.Version = "0.1.0"

    app.Flags = []cli.Flag{
        cli.StringFlag{
            Name:  "path, p",
            Value: ".",
            Usage: "指定目录路径",
        },
        cli.StringFlag{
            Name:  "type, t",
            Value: "count",
            Usage: "指定操作类型，包括 count 和 size",
        },
        cli.StringFlag{
            Name:  "ext, e",
            Value: "",
            Usage: "指定要操作的文件扩展名，多个扩展名用逗号隔开",
        },
    }

    app.Action = func(c *cli.Context) error {
        path := c.String("path")
        fileType := c.String("type")
        ext := c.String("ext")

        return handleFileCount(path, fileType, ext)
    }

    err := app.Run(os.Args)
    if err != nil {
        fmt.Printf("命令行错误：%v\n", err)
    }
}

func handleFileCount(path string, fileType string, ext string) error {
    if ext != "" {
        ext = strings.TrimSpace(ext)
        extArr := strings.Split(ext, ",")
        for i, v := range extArr {
            extArr[i] = strings.TrimSpace(v)
        }
    }

    total := 0
    size := int64(0)

    err := filepath.Walk(path, func(p string, info os.FileInfo, err error) error {
        if err != nil {
            fmt.Printf("? 无法访问：%s：%v\n", p, err)
            return nil
        }

        if info.IsDir() {
            return nil
        }

        if ext != "" {
            fileExt := strings.ToLower(filepath.Ext(info.Name()))
            has := false
            for _, v := range extArr {
                if v == fileExt {
                    has = true
                    break
                }
            }
            if !has {
                return nil
            }
        }

        if fileType == "count" {
            total++
        } else if fileType == "size" {
            size += info.Size()
        }

        return nil
    })

    if err != nil {
        fmt.Printf("? 目录遍历错误：%v\n", err)
        return err
    }

    if fileType == "count" {
        fmt.Printf("文件个数：%d\n", total)
    } else if fileType == "size" {
        fmt.Printf("文件总大小：%v\n", ByteSize(size))
    }

    return nil
}

func ByteSize(size int64) string {
    const (
        KB = 1 << 10
        MB = 1 << 20
        GB = 1 << 30
        TB = 1 << 40
        PB = 1 << 50
        EB = 1 << 60
    )

    switch {
    case size >= EB:
        return fmt.Sprintf("%.2f EB", float64(size)/EB)
    case size >= PB:
        return fmt.Sprintf("%.2f PB", float64(size)/PB)
    case size >= TB:
        return fmt.Sprintf("%.2f TB", float64(size)/TB)
    case size >= GB:
        return fmt.Sprintf("%.2f GB", float64(size)/GB)
    case size >= MB:
        return fmt.Sprintf("%.2f MB", float64(size)/MB)
    case size >= KB:
        return fmt.Sprintf("%.2f KB", float64(size)/KB)
    }
    return fmt.Sprintf("%d B", size)
}

在上述代码中，我们定义了三个命令行选项 -p, --path、-t 和 -e。通过 cli.Context，我们可以轻松地获取命令行选项的值，然后解析指定目录下的所有文件。根据 -t 选项，可以输出指定目录下的文件数量或文件总大小。 -e 选项可以指定操作的文件扩展名。

总结

在这个攻略中，我们详细讲解了 urfave/cli 的用法，包括命令行参数解析和命令行示例。通过 urfave/cli，我们可以轻松地处理命令行参数和选项，快速实现命令行程序的开发。