Eine gewöhnliche Golang-Bibliothekskobra

Die folgende Tutorial-Kolumne von golang stellt Ihnen Cobra vor, eine gemeinsame Golang-Bibliothek. Ich hoffe, dass sie Freunden in Not hilfreich sein wird!

cobra ist eine Bibliothek in der Go-Sprache, die zum Schreiben von Befehlszeilentools verwendet werden kann. Normalerweise können wir Befehle wie git pull, docker container start , apt install usw. sehen, die mit corba In einfach implementiert werden können Darüber hinaus lässt sich die Go-Sprache leicht in eine Binärdatei kompilieren. In diesem Artikel wird ein einfaches Befehlszeilentool implementiert. git pull  、docker container start  、apt install 等等这样命令，都可以很容易用corba来实现，另外，go 语言是很容易编译成一个二进制文件，本文将实现一个简单的命令行工具。

具体写一个例子, 设计一个命令叫blog， 有四个子命令

 blog new [post-name] ：创建一篇新的blog
 blog list   ：列出当前有哪些文章
 blog delete [post-name]: 删除某一篇文章
 blog edit [post-name]：编辑某一篇文章

计划有以下几个步骤

• 创建模块
• 用cobra的命令行，创建命令行入口
• 用cobra的命令行，创建子命令
• 编写功能逻辑

创建模块

$ go mod init github.com/shalk/blog
go: creating new go.mod: module github.com/shalk/blog

创建命令行入口

说到命令行，可能会想到bash的getopt 或者 java 的jcommand，可以解析各种风格的命令行，但是通常这些命令行都有固定的写法，这个写法一般还记不住要找一个模板参考以下。cobra除了可以解析命令行之外，还提供了命令行，可以生成模板。先安装这个命令行, 并且把库的依赖加到go.mod里

$ go get -u github.com/spf13/cobra/cobra

cobra会安装到$GOPATHbin

Schreiben Sie ein konkretes Beispiel und entwerfen Sie einen Befehl namens blog, der vier Unterbefehle hat

$ cobra init --pkg-name github.com/shalk/blog -a shalk -l mit
Your Cobra applicaton is ready at
D:\code\github.com\shalk\blog

Der Plan besteht aus den folgenden Schritten:

Erstellen Sie ein Modul.

Verwenden Sie die Befehlszeile von cobra, um eine Befehlszeile zu erstellen Eintrag

Verwenden Sie die Befehlszeile von Cobra, um Unterbefehle zu erstellen.

Funktionslogik schreiben Befehlszeile: Sie denken vielleicht an getopt von bash oder jcommand von Java, die verschiedene Befehlszeilenstile analysieren können, aber normalerweise haben diese Befehlszeilen eine feste Schreibweise. Im Allgemeinen können Sie sich diese Schreibweise nicht merken, also müssen Sie sie tun Suchen Sie eine Vorlage und sehen Sie sich Folgendes an. Zusätzlich zum Parsen der Befehlszeile bietet Cobra auch eine Befehlszeile, mit der Vorlagen generiert werden können. Installieren Sie zuerst diese Befehlszeile und fügen Sie die Bibliotheksabhängigkeiten zu go.mod hinzu Struktur Wie folgt:

./cmd
./cmd/root.go
./go.mod
./go.sum
./LICENSE
./main.go

Kompilieren

go build  -o blog .

Die Befehlszeile wird erstellt. Wenn das Verständnis zunimmt, müssen Sie den generierten Code später anpassen Sie müssen also noch die Cobra-Code-Routine verstehen.

Cobra-Code-Routinen
• Es gibt drei Konzepte: Befehl, Flag und Argumente, zum Beispiel:

• $blog -h
  A longer description that spans multiple lines and likely contains
  examples and usage of using your application. For example:
  
  Cobra is a CLI library for Go that empowers applications.
  This application is a tool to generate the needed files
  to quickly create a Cobra application.

Hier ist get üblich (das ist spezieller), -u ist Flag, test.com/a/b ist args
Die Befehlszeile besteht also aus drei Teilen. Daher müssen einige grundlegende Informationen des

-Befehls selbst definiert werden, die durch den Befehl dargestellt werden. Das spezifische Objekt sind einige Symbole oder Optionen des Befehls cobra.Command

. dargestellt durch Flag, und der letzte Parameter von FlagSet

wird normalerweise durch []string

dargestellt Strukturbeziehung.

Ich kann den Befehl go oder den Befehl go get verwenden

Zum Beispiel: root.go definiert den Root-Befehl und definiert auch das Flag in init. Wenn er speziell ausgeführt wird, wird das Feld Ausführen ausgefüllt.

go get -u test.com/a/b

Wenn Sie einen Unterbefehl benötigen, müssen Sie rootCmd.AddCommand() in init andere Befehle geben. Andere Unterbefehle werden normalerweise in eine separate Datei geschrieben und verfügen über eine globale Variable, damit rootCmd sie hinzufügen kann.

Unterbefehl erstellen

// rootCmd represents the base command when called without any subcommands
var rootCmd = &cobra.Command{
	Use:   "blog",
	Short: "A brief description of your application",
	Long: `A longer description that spans multiple lines and likely contains
examples and usage of using your application. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
	// Uncomment the following line if your bare application
	// has an action associated with it:
	//	Run: func(cmd *cobra.Command, args []string) { },
}

// Execute adds all child commands to the root command and sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the rootCmd.
func Execute() {
	if err := rootCmd.Execute(); err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
}

func init() {
	cobra.OnInitialize(initConfig)

	// Here you will define your flags and configuration settings.
	// Cobra supports persistent flags, which, if defined here,
	// will be global for your application.

	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.blog.yaml)")

	// Cobra also supports local flags, which will only run
	// when this action is called directly.
	rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")

}

New.go, delete.go, list.go, edit.go im cmd-Verzeichnis hinzugefügt

Funktionscode hinzugefügt

new.go

D:\code\github.com\shalk\blog>cobra add  new
new created at D:\code\github.com\shalk\blog

D:\code\github.com\shalk\blog>cobra add  delete
delete created at D:\code\github.com\shalk\blog

D:\code\github.com\shalk\blog>cobra add  list
list created at D:\code\github.com\shalk\blog

D:\code\github.com\shalk\blog>cobra add  edit
edit created at D:\code\github.com\shalk\blog

list.go

var newCmd = &cobra.Command{
	Use:   "new",
	Short: "create new post",
	Long:  `create new post `,
	Args: func(cmd *cobra.Command, args []string) error {
		if len(args) != 1 {
			return errors.New("requires a color argument")
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {
		fileName := "posts/" + args[0]
		err := os.Mkdir("posts", 644)
		if err != nil {
			log.Fatal(err)
		}
		_, err = os.Stat( fileName)
		if os.IsNotExist(err) {
			file, err := os.Create(fileName)
			if err != nil {
				log.Fatal(err)
			}
			log.Printf("create file %s", fileName)
			defer file.Close()
		} else {
		}
	},
}

delete.go

var listCmd = &cobra.Command{
	Use:   "list",
	Short: "list all blog in posts",
	Long: `list all blog in posts `,
	Run: func(cmd *cobra.Command, args []string) {
		_, err := os.Stat("posts")
		if os.IsNotExist(err) {
			log.Fatal("posts dir is not exits")
		}
		dirs, err := ioutil.ReadDir("posts")
		if err != nil {
			log.Fatal("read posts dir fail")
		}
		fmt.Println("------------------")
		for _, dir := range dirs {
			fmt.Printf(" %s\n", dir.Name() )
		}
		fmt.Println("------------------")
		fmt.Printf("total: %d blog\n", len(dirs))

	},
}

edit.go This ist etwas mühsam, denn wenn Sie ein Programm wie vim aufrufen, um die Datei zu öffnen, und das Golang-Programm selbst beendet werden möchte, muss es getrennt werden. Lassen Sie es uns vorerst beiseite legen (TODO)

🎜Kompilieren und testen🎜🎜Ich teste unter Windows, Linux ist etwas einfacher🎜

var deleteCmd = &cobra.Command{
	Use:   "delete",
	Short: "delete a post",
	Long: `delete a post`,
	Args: func(cmd *cobra.Command, args []string) error {
		if len(args) != 1 {
			return errors.New("requires a color argument")
		}
		if strings.Contains(args[0],"/") || strings.Contains(args[0],"..") {
			return errors.New("posts name should not contain / or .. ")
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {
		fileName := "./posts/" +  args[0]
		stat, err := os.Stat(fileName)
		if os.IsNotExist(err) {
			log.Fatalf("post %s is not exist", fileName)
		}
		if stat.IsDir() {
			log.Fatalf("%s is dir ,can not be deleted", fileName)
		}
		err = os.Remove(fileName)
		if err != nil {
			log.Fatalf("delete %s fail, err %v", fileName, err)
		} else {
			log.Printf("delete post %s success", fileName)
		}
	},
}

🎜Zusammenfassung🎜🎜cobra ist eine effiziente Befehlszeilen-Parsing-Bibliothek. Mit dem Gerüst von cobra können Sie schnell implementieren ein Befehlszeilentool. Wenn Sie eine detailliertere Kontrolle benötigen, können Sie sich auf die offizielle Dokumentation von Cobra beziehen. 🎜

Das obige ist der detaillierte Inhalt vonEine gewöhnliche Golang-Bibliothekskobra. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!