CLI 应用程序框架 —— Go Cobra 入门

最新推荐文章于 2024-04-12 09:59:15 发布
最新推荐文章于 2024-04-12 09:59:15 发布
阅读量435 收藏 1
点赞数
分类专栏： GoWeb 学习笔记 文章标签： golang 开发语言 后端 云原生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54605471/article/details/132261643
版权

本文通过丰富的代码示例演示了 Cobra 的基本功能，读者可以跟随这些示例，学习如何使用 Cobra。

Cobra

Cobra 由以下两部分组成：

  • 用于创建 CLI 应用程序的库（cobra 库）
  • 用于生成 Cobra 应用程序的工具（cobra-cli）

概念

Cobra 建立在命令（command）、参数（arguments）和标志（flags）的结构之上，这三个组件共同定义了命令行应用程序的行为。

  • 命令（Commands）代表着命令行应用程序可以执行的特定操作
  • 参数（Args）是这些操作所针对的实体或项
  • 标志（Flags）是可以修改命令或参数行为的修饰符。

设计良好的命令行应用程序在使用时读起来像句子，其遵循的模式如下：

  • APPNAME VERB NOUN --ADJECTIVE，如：git clone URL --bare
  • APPNAME COMMAND ARG --FLAG，如：hugo server --port=1313

cobra-cli

cobra-cli 是一个命令行工具，用于生成 Cobra 应用程序。我们可以使用命令 go install github.com/spf13/cobra-cli@latest 来安装它。

初始化应用程序

安装完 cobra-cli 后，我们可以在项目根目录下执行命令 cobra-cli init 以初始化我们的 Cobra 应用程序。初始化完成后，我们的项目目录结构如下：

│  go.mod
│  go.sum
│  LICENSE	# cobra-cli 生成的许可证文件
│  main.go	# cobra-cli 生成的程序入口文件
│
└─cmd
        root.go	# cobra-cli 生成的根命令文件

cobra-cli 生成的代码文件具有详细的注释，这里我们就不作讲解。

使用 cobro-cli init 时，我们还可以附加 flag ：

cobra-cli init --author="Sue211213@163.com" --license=mit --viper
 
#D:\workspace\golang\src\cobra-demo
  • --author 指定作者，作者信息会显示在文件的版权头信息和 LICENSE 文件中
  • --license 指定许可证，许可证信息会显示在 LICENSE 文件中
  • --viper 使用 viper

添加命令

初始化 Cobra 应用程序后，我们还可以使用 cobra-cli add 命令为我们的应用程序添加其他命令，如：

cobra-cli add serve
cobra-cli add config
cobra-cli add create -p 'configCmd'
  • -p 指定该命令的父级，默认情况下父级命令为 rootCmd

指定 command ，运行程序：

go run main.go serve
#serve called

go run main.go config
#config called

go run main.go config create
#create called

配置文件

我们可以将 flag 写入到配置文件中，然后以读取配置文件的形式使用 flag。

创建配置文件 .cobra.yaml ：

author: Sue211213 <sue211213@163.com>	# 作者信息
license: MIT							# 许可证信息，可以为 none，也可以自定义
useViper: true							# 启用 viper

使用配置文件进行初始化：

cobra-cli init --config=.cobra.yaml
#Using config file: .cobra.yaml
#Your Cobra application is ready at
#D:\workspace\golang\src\cobra-demo

cobra

使用标志

持久标志

我们可以为某个命令分配持久标志，持久标志能够被该命令及其所有子命令使用。

在下面这个示例中，我们为根命令分配了一个名为 verbose 的持久标志，由于是根命令上的持久标志，所以该标志是一个全局标志，可用于所有命令：

var rootCmd = &cobra.Command{
	Use:   "app",
}

var cmdFoo = &cobra.Command{
	Use:   "foo",

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("foo executed")
		if verbose {
			fmt.Println("verbose output enabled")
		}
	},
}

var verbose bool

func init() {
	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "enable verbose output")
}

func main() {
	rootCmd.AddCommand(cmdFoo)
	
	_ = rootCmd.Execute()
}

go run main.go foo
#foo executed

go run main.go foo -v
#foo executed
#verbose output enabled
本地标志

我们可以为某个命令分配本地标志，本地标志只有该命令能够使用。

在下面这个示例中，我们为子命令 foo 分配了一个本地标志 name，该标志只能由子命令 foo 使用：

var rootCmd = &cobra.Command{
	Use:   "app",
}

var cmdFoo = &cobra.Command{
	Use:   "foo",

	Run: func(cmd *cobra.Command, args []string) {
		name, _ := cmd.Flags().GetString("name")
		fmt.Printf("Hello %s\n", name)
	},
}

func init() {
	cmdFoo.Flags().StringP("name", "n", "world", "The name to greet")
}

func main() {
	rootCmd.AddCommand(cmdFoo)
    
	_ = rootCmd.Execute()
}

go run main.go -n=sue211213@163.com
#Error: unknown shorthand flag: 'n' in -n=sue211213@163.com
#...

go run main.go foo -n=sue211213@163.com
#Hello sue211213@163.com
将标志与配置绑定

我们可以使用 viper 将我们的标志和配置信息进行绑定。

在下面的这个示例中，我们将 name 标志与环境变量 APP_NAME 进行绑定：

var rootCmd = &cobra.Command{
	Use:   "app",

	Run: func(cmd *cobra.Command, args []string) {
		name := viper.GetString("name")
		fmt.Printf("Hello, %s\n", name)
	},
}

func init() {
	rootCmd.Flags().StringP("name", "n", "world", "the name to greet")
	_ = viper.BindPFlag("name", rootCmd.Flags().Lookup("name"))
	viper.SetEnvPrefix("app")
	viper.AutomaticEnv()
}

func main() {
	_ = rootCmd.Execute()
}

APP_NAME=Bob go run main.go
#Hello, Bob
必填标志

我们可以为某个命令设置必填标志。

在下面这个示例中，我们为 app 命令设置了必填标志 name：

var rootCmd = &cobra.Command{
	Use:   "app",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func init() {
	rootCmd.Flags().StringP("name", "n", "World", "The name to greet")
	_ = rootCmd.MarkFlagRequired("name")
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go
#Error: required flag(s) "name" not set
#...
标志组

我们可以使用 MarkFlagsRequiredTogether 函数限制某些标志必须一起执行，如：

var rootCmd = &cobra.Command{
	Use:   "myapp",
	Short: "A simple command line application",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func init() {
	rootCmd.Flags().StringP("username", "u", "", "Username (required)")
	rootCmd.Flags().StringP("password", "p", "", "Password (required)")
	rootCmd.MarkFlagsRequiredTogether("username", "password")
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go --username=alice
#Error: if any flags in the group [username password] are set they must all be set; missing [password]
#...

我们可以使用 MarkFlagsRequiredTogether 函数限制某些标志不能同时出现，如：

var rootCmd = &cobra.Command{
	Use:   "myapp",
	Short: "A simple command line application",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func init() {
	rootCmd.Flags().Bool("json", false, "Output in JSON format")
	rootCmd.Flags().Bool("yaml", false, "Output in YAML format")
	rootCmd.MarkFlagsMutuallyExclusive("json", "yaml")
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go --json --yaml
#Error: if any flags in the group [json yaml] are set none of the others can be; [json yaml] were all set
#...

参数验证

我们可以对传入的参数进行验证。

内置验证

在下面这个示例中，我们为 hello 命令设置了有且只有一个参数验证；为 bye 命令设置了最少有一个参数验证；为 color 命令设置了选项参数验证：

var rootCmd = &cobra.Command{
	Use: "app",
}

var cmdHello = &cobra.Command{
	Use:  "hello [name]",
	Args: cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
	},
}

var cmdBye = &cobra.Command{
	Use:  "bye [name]...",
	Args: cobra.MinimumNArgs(1),
	
	Run: func(cmd *cobra.Command, args []string) {
	},
}

var cmdColor = &cobra.Command{
	Use:       "color [color]",
	Args:      cobra.OnlyValidArgs,
	ValidArgs: []string{"red", "green", "blue"},
	
	Run: func(cmd *cobra.Command, args []string) {
	},
}

func init() {
	rootCmd.AddCommand(cmdHello)
	rootCmd.AddCommand(cmdBye)
	rootCmd.AddCommand(cmdColor)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go hello Alice Bob
#Error: accepts 1 arg(s), received 2
#...

go run main.go bye
#Error: requires at least 1 arg(s), only received 0
#...

go run main.go color yellow
#Error: invalid argument "yellow" for "app color"
#...
自定义验证

在下面这个示例中，我们为主目录自定义了参数验证函数，要求传入参数必须为整数，且为2个：

var rootCmd = &cobra.Command{
	Use:  "app",
	Args: validateNumbers,

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func validateNumbers(cmd *cobra.Command, args []string) error {
	if len(args) != 2 {
		return fmt.Errorf("requires two arguments")
	}

	for _, arg := range args {
		if _, err := strconv.Atoi(arg); err != nil {
			return fmt.Errorf("invalid number: %s", arg)
		}
	}

	return nil
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go 1 2 3
#Error: requires two arguments

go run main.go 1 a
#Error: invalid number: a

帮助命令

当我们有子命令时，Cobra 会自动向我们的应用程序添加帮助命令和帮助标志。如：

var rootCmd = &cobra.Command{
	Use: "app",
}

var cmdHello = &cobra.Command{
	Use: "hello",
}

func init() {
	rootCmd.AddCommand(cmdHello)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go help
#Usage:
#  app [command]
#
#Available Commands:
#  completion  Generate the autocompletion script for the specified shell
#  help        Help about any command
#
#Flags:
#  -h, --help   help for app
#
#Additional help topics:
#  app hello
#
#Use "app [command] --help" for more information about a command.

go run main.go --help
#Usage:
#  app [command]
#
#Available Commands:
#  completion  Generate the autocompletion script for the specified shell
#  help        Help about any command
#
#Flags:
#  -h, --help   help for app
#
#Additional help topics:
#  app hello
#
#Use "app [command] --help" for more information about a command.
自定义帮助信息

我们可以用 setHelpCommand 函数自定义帮助信息，如：

var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with SetHelpCommand",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

var cmdFoo = &cobra.Command{
	Use:   "foo",
	Short: "A subcommand that prints foo",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

var helpCmd = &cobra.Command{
	Use:   "help [command]",
	Short: "Help about any command",

	Run: func(cmd *cobra.Command, args []string) {
		if len(args) == 0 {
			fmt.Println("This is an example app with SetHelpFunc.")
			fmt.Println("Usage:")
			fmt.Println("  app [command]")
			fmt.Println()
			fmt.Println("Available Commands:")
			fmt.Println("  foo    A subcommand that prints foo")
			fmt.Println()
		} else {
			sub, _, err := cmd.Root().Find(args)
			if err != nil {
				fmt.Printf("Unknown help topic %q\n", args[0])
				return
			}
			_ = sub.Help()
		}
	},
}

func init() {
	rootCmd.AddCommand(cmdFoo)
	rootCmd.SetHelpCommand(helpCmd)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go help
#This is an example app with SetHelpFunc.
#Usage:
#  app [command]
#
#Available Commands:
#  foo    A subcommand that prints foo

go run main.go help foo
#A subcommand that prints foo
#
#Usage:
#  app foo

我们还可以使用 SetHelpFunc 函数自定义帮助信息，如：

var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with SetHelpFunc",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

var cmdFoo = &cobra.Command{
	Use:   "foo",
	Short: "A subcommand that prints foo",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func customHelp(cmd *cobra.Command, args []string) {
	if len(args) == 0 {
		fmt.Println("This is an example app with SetHelpFunc.")
		fmt.Println("Usage:")
		fmt.Println("  app [command]")
		fmt.Println()
		fmt.Println("Available Commands:")
		fmt.Println("  foo    A subcommand that prints foo")
		fmt.Println()
	} else {
		sub, _, err := cmd.Root().Find(args)
		if err != nil {
			fmt.Printf("Unknown help topic %q\n", args[0])
			return
		}
		_ = sub.Help()
	}
}

func init() {
	rootCmd.SetHelpFunc(customHelp)
	rootCmd.AddCommand(cmdFoo)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go help
#This is an example app with SetHelpFunc.
#Usage:
#  app [command]
#
#Available Commands:
#  foo    A subcommand that prints foo

go run main.go help foo
#This is an example app with SetHelpFunc.
#Usage:
#  app [command]

我们还可以使用 SetHelpTemplate 自定义帮助信息，如：

var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with SetHelpTemplate",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

var cmdFoo = &cobra.Command{
	Use:   "foo",
	Short: "A subcommand that prints foo",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

const customTemplate = `{{with (or .Long .Short)}}{{. | trimTrailingWhitespaces}}{{end}}
Usage:
  {{.UseLine}}
{{if .HasAvailableSubCommands}}
Available Commands:{{range .Commands}}{{if (or .IsAvailableCommand (eq .Name "help"))}}
  {{.Name}}    {{.Short}}{{end}}{{end}}{{end}}
`

func init() {
	rootCmd.SetHelpTemplate(customTemplate)
	rootCmd.AddCommand(cmdFoo)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go help 
#An example app with SetHelpTemplate
#Usage:
#  app [flags]
#
#Available Commands:
#  completion    Generate the autocompletion script for the specified shell
#  foo    A subcommand that prints foo
#  help    Help about any command

go run main.go help foo
#A subcommand that prints foo
#Usage:
#  app foo [flags]

用法信息

当我们提供无效标志时，Cobra 会向我们显示用法信息，如：

var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with SetUsageFunc",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go --name
#Error: unknown flag: --name
#Usage:
#  app [flags]
#
#Flags:
#  -h, --help   help for app
自定义用法信息

我们可以使用 SetUsageFunc 函数自定义用法信息，如：

var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with SetUsageFunc",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func customUsage(cmd *cobra.Command) error {
	_, _ = fmt.Fprintf(os.Stderr, "Usage: %s [OPTIONS]\n", cmd.Name())
	_, _ = fmt.Fprintln(os.Stderr, "My app does something useful.")
	_, _ = fmt.Fprintln(os.Stderr, "")
	_, _ = fmt.Fprintln(os.Stderr, "Options:")
	cmd.Flags().VisitAll(func(flag *pflag.Flag) {
		_, _ = fmt.Fprintf(os.Stderr, "  --%s=%s\n", flag.Name, flag.Usage)
	})
	return nil
}

func init() {
	rootCmd.SetUsageFunc(customUsage)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go --name
#Error: unknown flag: --name
#Usage: app [OPTIONS]
#My app does something useful.
#
#Options:
#  --help=help for app

我们还可以使用 SetUsageTemplate 函数自定义用法信息，如：

var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with SetUsageTemplate",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

const customTemplate = `Usage: {{.UseLine}}
My app does something useful.

Options:
  {{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}
`

func init() {
	rootCmd.SetUsageTemplate(customTemplate)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go --name
#Error: unknown flag: --name
#Usage: app [flags]
#My app does something useful.
#
#Options:
#    -h, --help   help for app

版本标志

我们可以在根命令上设置版本字段，Cobra 会自动添加 version 标志，此标志的作用是输出应用的版本信息，如：

var rootCmd = &cobra.Command{
	Use:     "app",
	Short:   "An example app with Version and SetVersionTemplate",
	Version: "1.0.0",
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go --version
#app version 1.0.0
自定义版本信息

我们可以使用 cmd.SetVersionTemplate(s string) 函数自定义版本信息模板，如：

var rootCmd = &cobra.Command{
	Use:     "app",
	Short:   "An example app with Version and SetVersionTemplate",
	Version: "1.0.0",
}

const customTemplate = `This is {{.Name}}, an example app with Version and SetVersionTemplate.
The current version is {{.Version}}.
`

func init() {
	rootCmd.SetVersionTemplate(customTemplate)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go --version
#This is app, an example app with Version and SetVersionTemplate.
#The current version is 1.0.0.

钩子函数

cobra 为我们提供了钩子函数，它们的执行顺序如下：

  • PersistentPreRun
  • PreRun
  • Run
  • PostRun
  • PersistentPostRun

注意，若子命令没有自己的钩子函数，将会继承父命令的钩子函数

var rootCmd = &cobra.Command{
	Use:   "root [sub]",
	Short: "My root command",
	PersistentPreRun: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Inside rootCmd PersistentPreRun with args: %v\n", args)
	},
	PreRun: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Inside rootCmd PreRun with args: %v\n", args)
	},
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Inside rootCmd Run with args: %v\n", args)
	},
	PostRun: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Inside rootCmd PostRun with args: %v\n", args)
	},
	PersistentPostRun: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Inside rootCmd PersistentPostRun with args: %v\n", args)
	},
}

var subCmd = &cobra.Command{
	Use:   "sub [no options!]",
	Short: "My subcommand",
	PreRun: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Inside subCmd PreRun with args: %v\n", args)
	},
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Inside subCmd Run with args: %v\n", args)
	},
	PostRun: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Inside subCmd PostRun with args: %v\n", args)
	},
	PersistentPostRun: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Inside subCmd PersistentPostRun with args: %v\n", args)
	},
}

func init() {
	rootCmd.AddCommand(subCmd)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go
#Inside rootCmd PersistentPreRun with args: []
#Inside rootCmd PreRun with args: []
#Inside rootCmd Run with args: []
#Inside rootCmd PostRun with args: []
#Inside rootCmd PersistentPostRun with args: []

go run main.go sub
#Inside rootCmd PersistentPreRun with args: []
#Inside subCmd PreRun with args: []
#Inside subCmd Run with args: []
#Inside subCmd PostRun with args: []
#Inside subCmd PersistentPostRun with args: []

出现 “unknown command” 时的建议

当发生 “unknown command” 错误时，Cobra 将打印建议，建议是根据注册的子命令自动生成的，如：

var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with DisableSuggestions",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

var cmdFoo = &cobra.Command{
	Use:   "foo",
	Short: "A subcommand that prints foo",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func init() {
	rootCmd.AddCommand(cmdFoo)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go f
#Error: unknown command "f" for "app"
#
#Did you mean this?
#        foo
#
#Run 'app --help' for usage.
禁用建议

我们可以使用 command.DisableSuggestions = true 以禁用子命令建议，如：

var rootCmd = &cobra.Command{
	Use:                "app",
	Short:              "An example app with DisableSuggestions",
	DisableSuggestions: true,

	Run: func(cmd *cobra.Command, args []string) {
	},
}

var cmdFoo = &cobra.Command{
	Use:   "foo",
	Short: "A subcommand that prints foo",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func init() {
	rootCmd.AddCommand(cmdFoo)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go f
#Error: unknown command "f" for "app"
#Run 'app --help' for usage.

我们还可以使用 SuggestFor 属性显式设置建议给定命令的名称，如：

var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with SuggestFor",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

var cmdBar = &cobra.Command{
	Use:        "bar",
	Short:      "A subcommand that prints bar",
	SuggestFor: []string{"qux"},

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func init() {
	rootCmd.AddCommand(cmdBar)
}

func main() {
	_ = rootCmd.Execute()
}

go run main.go qux
#Error: unknown command "qux" for "app"
#
#Did you mean this?
#        bar
#
#Run 'app --help' for usage.

为命令生成文档

我们可以根据子命令、标志等生成以下格式的文档：

  • Markdown，如：

    var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with documentation",

	Run: func(cmd *cobra.Command, args []string) {
	},
}

func main() {
	err := doc.GenMarkdownTree(rootCmd, "./docs")
	if err != nil {
		log.Fatal(err)
	}
}

  • ReStructured Text，如：

    var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with documentation",
}

func main() {
	err := doc.GenReSTTree(rootCmd, "./docs")
	if err != nil {
		log.Fatal(err)
	}
}

  • Man Page，如：

    var rootCmd = &cobra.Command{
	Use:   "app",
	Short: "An example app with documentation",
}

func main() {
	header := &doc.GenManHeader{
		Title:   "APP",
		Section: "1",
		Date:    &time.Time{},
		Source:  "Cobra Example App",
		Manual:  "Cobra Example Manual",
	}

	err := doc.GenManTree(rootCmd, header, "./docs")
	if err != nil {
		log.Fatal(err)
	}
}

本文由 Sue211213 原创，发表于 2023 年 8 月 13 日，转载请注明出处和作者，谢谢！

蓝色的天白色的云
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
w2j-cli：JavaWeb CLI框架，简单易用。简单易用的Javaweb命令行框架
03-01
W2J-CLI JavaWeb命令行框架，可帮助您轻松构建命令行JavaWeb系统。 它可以轻松地与任何Java框架结合，而无需其他依赖项。即使您不需要创建HTML页面。 为什么需要它 一些功能是提供给专业人士的，不希望投资于开发前端。 快速开发简单的管理系统 通过网页提供了一些工具 快速，简单，有趣，极客等 得到它 玛文 <!-- https://mvnrepository.com/artifact/top.thinkin/w2j-cli-core --> < dependency> < groupId>top.thinkin</ groupId> < artifactId>w2j-cli-core</ artifactId> < version>0.1.3</ version> </ dependency> Gradle // https:/
使用vue-cli(vue脚手架)快速搭建项目框架
weixin_42113716的博客
09-04 101
使用vue-cli(vue脚手架)快速搭建项目框架
Golang 命令行框架对比：Cobra VS urfave/cli
最新发布
源自开发者
04-12 604
当开发者使用 Go 语言开发命令行应用时，通常会选用一些成熟的框架来简化开发过程。在众多选项中，Cobra 和 urfave/cli 是两个相当受欢迎的库。下面，我们将详细对比这两个库的特点、使用情况、文档支持与活跃度，来帮助开发者做出选择。
【vue框架】 vue-cli从0开始搭建移动端vue项目框架（vscode版本）
我有满天星辰的博客
04-13 6638
github因为 rem 这个单位是要根据 html 的字号的变化而变化，那么html字号要如何才能变换呢？要么我们自己写媒体查询，根据不同的屏幕宽度给html设置不同的字号，但是这样就比较麻烦，因为移动端的屏幕特别多，要自己写媒体查询，就累到吐血，所以可以用别人写好的插件，自动根据屏幕大小来设置html的字号flexible 就是一种能根据屏幕自动设置html字号的插件。
Golang : cobra 包简介
weixin_30378623的博客
05-14 632
Cobra 是一个 Golang 包，它提供了简单的接口来创建命令行程序。同时，Cobra 也是一个应用程序，用来生成应用框架，从而开发以 Cobra 为基础的应用。本文的演示环境为 ubuntu 18.04(下图来自互联网)。 主要功能 cobra 的主要功能如下，可以说每一项都很实用： 简易的子命令行模式，如 app server， app fetch 等等 完全兼容 posi...
VUE框架CLI组件化开发配置信息和组成------VUE框架
吾不识青天高黄地厚。唯见月寒日暖，来煎人寿。
12-05 1128
VUE框架CLI组件化开发配置信息和组成------VUE框架
go Cobra命令行工具入门
xmcy001122的专栏
05-06 2155
本文介绍一个go命令行工具库，我们可以基于cobra快速的开发我们自己的命令行程序，特别适合Admin CLI、写各种测试脚本（如果使用main入口，要建很多个package）等等场合。
Golang框架：cobra
luyoung0001@gmail.com的博客
06-06 1625
cobra库是 golang 的一个开源第三方库，能够快速便捷的建立命令行应用程序。
cli脚手架（框架）
qq_38271992的博客
11-20 136
一、创建vue项目 1 npm install vue-cli -g #-g全局 2 (sudo)npm install vue-cli -g #mac笔记本 3 4 vue-init webpack myvue #项目的名字 5 cd muvue 6 npm install 7 npm run dev二、目录结构的说明出现下面这样的图就说明成功了三...
Go语言CLI程序
Lgw1102的博客
10-12 223
Selpg.go 此文档用于说明Go语言的CLI程序的完成过程以及相关测试, 接下来我将按照写程序的顺序来依次介绍每个部分的过程。 对包的引用 写这个CLI程序的过程中，需要用到的包有下面这些，在代码注释中，我对这些包进行了详细的解释： import ( "bufio" // 标准输入流和数据之间的交互 // "fmt" // 引用io.EOF 来判断错误是否是文件尾...
golang工程组件之命令行框架cobra
SMILY12138的博客
04-13 1121
而cobra则是一个非常受欢迎的Golang工程组件之一，它提供了简单易用的命令行框架，并且支持子命令、Flag解析、嵌套等高级特性。通过使用cobra，我们可以轻松地创建各种复杂的命令行工具，并实现Flag解析、子命令、嵌套等高级功能。同时，cobra还提供了丰富的自定义选项，使我们能够轻松地扩展和定制我们的命令行工具。在上面的例子中，我们创建了一个名为nestedCmd的嵌套命令，并将其添加到subCmd对象中。在上面的例子中，我们添加了一个名为subCmd的子命令，并将其添加到rootCmd对象中。
go-cli-template：使用cobra编写CLI的模板
02-17
开始使用Go语言轻松编写CLI的模板。 请将“ go-cli-template”更改为您的项目名称并使用它。 通过在secrets.SLACK_WEBHOOK中设置Slack webhook网址， 您还可以通知测试结果松弛。 如何使用 通过此存储库上的“使用...
Go-cobra-一个库来创建强大的现代CLI应用程序以及程序生成应用程序和命令文件
08-14
cobra - 一个库来创建强大的现代CLI应用程序以及程序生成应用程序和命令文件。
balbalancli:BalbalanCLI是一个简单的CLI应用程序，可以显示最新的足球得分和状态
03-14
巴尔巴兰
fops-cli:文件操作（Fops）CLI，一种用Golang编写的弹性命令行应用程序，用于对行和校验和文件进行计数
03-27
命令行CLI 文件操作（Fops）CLI，这是一种用Golang编写的弹性命令行应用程序，用于对行和校验和文件进行计数。安装git clone https://github.com/cdvel/fops-clicd fops-climake./fops help用法安装后，将通过以下...
phone-cli:电话簿应用程序CLI
04-14
电话cli 电话簿应用程序CLI $ cd〜/ go / src / github.com / mactsouk $ git clone ：mactsouk / phone-cli.git $ cd phone-cli $〜/ go / bin / cobra init --pkg-name github.com/mactsouk/phone-cli $ go mod ...
Vue-cli（vue脚手架）超详细教程
Java修炼记
03-15 8995
前言 “脚手架”，可以方便我们快速的创建项目。自动化地为我们搭建一个项目框架。之前的一篇文章：“Vue.js 快速入门”中提到了 Vue-cli脚手架，那么这篇文章就来介绍一下~ 1. 什么是Vue-cli Vue cli是基于Vue的应用开发提供的一个标准的脚手架工具.为应用搭建基础的框架结构,提供插件、开发服务、Preset、构建打包功能 Vue cli 背后集成了现代化开发的诸多功能，通过简单的命令就可以完成 "零配置"的项目环境搭建 2. 安装Vue-cli步骤 在安装vue-cli前，要确认自
golang cobra命令行工具介绍
学亮编程手记
08-22 567
cron，是一个Linux定时执行工具，可以在无需人工干预的情况下运行作业。 在Ubuntu server 下，cron是被默认安装并启动的；如果没有启动，自行设置并启动(chkconfigsysv-rc-conf)。通过其配置文件 /etc/crontab 可以看到以下内容：ununtu 通过调用 run-parts 命令，定时运行四个目录下的所有脚本。 1）/etc/cron.hourly，目录下的脚本会每个小时让执行一次，在每小时的17分钟时运行； 2）/etc/cron.daily，目录下的脚本会每
Go-cli框架Cobra
weixin_43081090的博客
09-14 770
Cobra是前go语言负责人spf13开发的一款go-cli框架，可以轻松规范的处理cli应用场景。作者博客：图片网站。
golang cobra
09-14
Cobra是一个用于创建强大的现代命令行应用的Go库。它不仅可以作为库来开发命令行应用，还可以作为脚手架来生成应用和命令文件。许多流行的Go项目都使用了Cobra，例如Kubernetes、Hugo、rkt、etcd等。 要使用Cobra，你可以通过运行以下命令来下载Cobra库：go get github.com/spf13/cobra。 对于Golang中命令行库Cobra的使用方法，你可以参考一些详细的示例代码和教程。这些教程会介绍Cobra的各种功能和用法，对于学习或者工作中使用Cobra都会有一定的参考价值。 总结起来，Cobra是一个用于创建现代命令行应用的Go库，许多流行的Go项目都在使用Cobra。你可以通过go get命令来下载Cobra库，并参考详细的示例代码和教程来学习和使用Cobra。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值