《Go语言编程之旅》学习02--单词格式转换工具

日之朝矣
  2023-02-22 20:32:28 2023-02-22 20:32:28 创建   2024-08-18 09:25:27 2024-08-18 09:25:27 更新    1.3k 字  

这篇文章是跟着《Go编程之旅》第1.2节 ，使用第三方库cobra库制作的一个单词格式转换demo，加入了一些个人的理解与弃用代码的更换。

Cobra 是一个提供了一个简单的界面来创建类似于 git & go 工具的强大的现代 CLI 界面的库

基本结构与初始化

我们的项目目录是这样的

1
2
3
4
5
6
7
8
9
10
tour
├── main.go				# 程序入口
├── go.mod				
├── go.sum
├── cmd					# 命令与初始化
│   ├── root.go	 
│   └── word.go
└── internal			# 逻辑处理 
   	└── word
   		└── word.go

首先我们创建好项目结构

安装一下cobra库，这是cobra的官方文档：https://cobra.dev/ 

1
go get -u github.com/spf13/[email protected]

在cmd目录下创建root.go，内容如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package cmd

import (
	"github.com/spf13/cobra"
)

var rootCmd = &cobra.Command{} // 创建一个cobra.Command对象

func Execute() error {
	return rootCmd.Execute()	// 执行
}

func init() {
	rootCmd.AddCommand(wordCmd)	// 将自己定义的命令行参数添加进rootCmd中，此时wrodCmd我们还未创建，稍后就做
}

这个root.go文件主要作用是cobra的初始化

接着在cmd目录下创建word.go文件，内容如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package cmd 

import(
	"github.com/spf13/cobra"
)

var wordCmd = &cobra.Command{
    Use:	"word",
    Short:	"单词格式转换",
    Long:	"对单词进行一些格式上的转换",
    Run: func(cmd *cobra.Command, args []string){
        // 暂时留空,
    }
}

func init() {
    // 暂时留空，用来定义命令行flag
}

cobra.Command中我们所使用到的字段说明：

  • Use: 子命令的命令标识
  • Short: 简短说明
  • Long: 完整说明
  • Run：该子命令要执行的内容

最后在main.go内写入

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import (
	"log"
	"wordConvertTool/cmd"
)

func main() {
	err := cmd.Execute()
	if err != nil {
		log.Fatalf("cmd.Execute err: %v", err)
	}
}

到这里基本的结构就完成了，我们可以来写内容了

单词转换

单词转换的内容我们要写到internal包中，在internal包的word文件夹中，创建一个word.go文件,首先展示下我的代码开头部分，避免引用包错误问题

1
2
3
4
5
6
7
8
package word

import (
	"golang.org/x/text/cases"
	"golang.org/x/text/language"
	"strings"
	"unicode"
)

全部大写

全部大写和全部小写用strings库的ToUpper和ToLower就行

1
2
3
func ToUpper(s string) string {
	return strings.ToUpper(s)
}

全部小写

1
2
3
func ToLower(s string) string {
   return strings.ToLower(s)
}

下划线转大驼峰

下划线转大驼峰，先把下划线全部替换为空格，然后将单词转换为首字母大写

我的go版本为1.18.3，strings.Titile()方法已经弃用，官方推荐了另一个库，也就是"golang.org/x/text/cases"

1
2
3
4
5
func UnderscoreToUpperCamelCase(s string) string {
   s = strings.Replace(s, "_", " ", -1)
   s = cases.Title(language.Tag{}, cases.Compact).String(s)
   return strings.Replace(s, " ", "", -1)
}

下划线转小驼峰

先转为大驼峰，然后将单词第一个字母改为小写即可

1
2
3
4
func UnderscoreToLowerCamelCase(s string) string {
   s = UnderscoreToUpperCamelCase(s)
   return string(unicode.ToLower(rune(s[0]))) + s[1:]
}

驼峰转下划线

将第一个字母转为小写，之后每遇到一个大写字母，就在后面加一个下划线

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func CamelCaseToUnderscore(s string) string {
   var output []rune
   for i, r := range s {
      if i == 0 {
         output = append(output, unicode.ToLower(r))
         continue
      }
      if unicode.IsUpper(r) {
         output = append(output, '_')
      }
      output = append(output, unicode.ToLower(r))
   }
   return string(output)
}

word子命令

写完处理的部分后，开始写命令部分

回到cmd/word.go文件中

创建一些常量用来表示不同的命令

1
2
3
4
5
6
7
const (
	ModeUpper                      = iota + 1 // 全部转大写
	ModeLower                                 // 全部转小写
	ModeUnderscoreToUpperCamelCase            // 下划线转大驼峰
	ModeUnderscoreToLowerCamelCase            // 下划线转小驼峰
	ModeCamelCaseToUnderscore                 // 驼峰转下划线
)

完善一下wordCmd的完整说明（Long），以及执行方法（Run）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
var desc = strings.Join([]string{
	"该子命令支持各种单词格式转换，模式如下:",
	"1: 全部转大写",
	"2: 全部转小写",
	"3: 下划线转大驼峰",
	"4: 下划线转小驼峰",
	"5: 驼峰转下划线",
}, "\n")
var str string
var mode int8

var wordCmd = &cobra.Command{
	Use:   "word",
	Short: "单词格式转换",
	Long:  desc,
	Run: func(cmd *cobra.Command, args []string) {
		var content string
		switch mode {
		case ModeUpper:
			content = word.ToUpper(str)
		case ModeLower:
			content = word.ToLower(str)
		case ModeUnderscoreToUpperCamelCase:
			content = word.UnderscoreToUpperCamelCase(str)
		case ModeUnderscoreToLowerCamelCase:
			content = word.UnderscoreToLowerCamelCase(str)
		case ModeCamelCaseToUnderscore:
			content = word.CamelCaseToUnderscore(str)
		default:
			log.Fatalf("暂不支持该转换模式，请执行 help word 查看帮助文档")
		}

		log.Printf("输出结果: %s", content)
	},
}

最后定义一下flag,放在这个文件的init函数中

1
2
3
4
func init() {
	wordCmd.Flags().StringVarP(&str, "str", "s", "", "请输入单词内容")
	wordCmd.Flags().Int8VarP(&mode, "mode", "m", 0, "请输入单词转换的模式")
}

验证

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 全部转大写
go run main.go word -s=rzzy -m=1 
输出结果: RZZY

# 全部转小写
go run main.go word -s=RZZY -m=2
2023/02/22 20:20:48 输出结果: rzzy

# 下划线转大驼峰
go run main.go word -s=rz_zy -m=3
输出结果: RzZy

# 下划线转小驼峰
go run main.go word -s=rz_zy -m=4
输出结果: rzZy

# 驼峰转下划线
go run main.go word -s=RzZy -m=5 
输出结果: rz_zy

go run main.go word -s=rzZy -m=5
输出结果: rz_zy
  • 标题: 《Go语言编程之旅》学习02--单词格式转换工具
  • 作者: 日之朝矣
  • 创建于 : 2023-02-22 20:32:28
  • 更新于 : 2024-08-18 09:25:27
  • 链接: https://blog.rzzy.fun/2023/02/22/go-wordConvert/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
评论
此页目录
《Go语言编程之旅》学习02--单词格式转换工具
  1. 基本结构与初始化
  2. 单词转换
    1. 全部大写
    2. 全部小写
    3. 下划线转大驼峰
    4. 下划线转小驼峰
    5. 驼峰转下划线
  3. word子命令
  4. 验证