Go 中读取命令参数的几种方法总结？

2024-04-18 06:16•css•阅读 2739

前言

对于一名初学者来说，想要尽快熟悉 Go 语言特性，所以以操作式的学习方法为主，比如编写一个简单的数学计算器，读取命令行参数，进行数学运算。

本文讲述使用三种方式讲述 Go 语言如何接受命令行参数，并完成一个简单的数学计算，为演示方便，最后的命令行结果大概是这样的：

# input

./calc add 1 2

# output

3

# input

./calc sub 1 2

# out

-1

# input

./calc mul 10 20

# out

200

使用的三种方式是：

内置 os 包读取命令参数
内置 flag 包读取命令参数
cli 框架读取命令参数

0. 已有历史经验

如果你熟悉 Python 、Shell 脚本，你可以比较下：

Python

importsys

args=sys.argv

# args 是一个列表

# 第一个值表示的是文件名

# 除第一个之外，其他的值是接受的参数

Shell

if[ $# -ne 2 ]; then

echo"Usage: $0 param1 pram2"

exit1

fi

name=$1

age=$2

echo$name

echo$age

# `$0` 表示文件名

# `$1` 表示第一个参数

# `$2` 表示第二个参数

能看出一些共性，接收参数，一般解析出来都是一个数组（列表、切片），第一个元素表示的是文件名，剩余的参数表示接收的参数。

好，那么为了实现 “简单数学计算” 这个功能，读取命令行参数：比如 ./calc add 1 2

除文件名之外的第一个元素：解析为进行数学运算的操作，比如： add、sub、mul、sqrt

其余参数表示：进行操作的数值

注意：命令行读取的参数一般为字符串，进行数值计算需要进行数据类型转换

大概思路就是这样。

1. OS 获取命令行参数

os.Args

# 为接受的参数，是一个切片

strconv.Atoi

# 将字符串数值转换为整型

strconv.Itoa

# 将整型转换为字符串

strconv.ParseFloat

# 将字符串数值转换为浮点型

var help = func () {

fmt.Println("Usage for calc tool.")

fmt.Println("====================================================")

fmt.Println("add 1 2, return 3")

fmt.Println("sub 1 2, return -1")

fmt.Println("mul 1 2, return 2")

fmt.Println("sqrt 2, return 1.4142135623730951")

}

func CalcByOs() error {

args := os.Args

if len(args) < 3 || args == nil {

help()

return nil

}

operate := args[1]

switch operate {

case "add":{

rt := 0

number_one, err1 := strconv.Atoi(args[2])

number_two, err2 := strconv.Atoi(args[3])

if err1 == nil && err2 == nil {

rt = number_one + number_two

fmt.Println("Result ", rt)

}

case "sub":

{

rt := 0

number_one, err1 := strconv.Atoi(args[2])

number_two, err2 := strconv.Atoi(args[3])

if err1 == nil && err2 == nil {

rt += number_one - number_two

fmt.Println("Result ", rt)

}

case "mul":

{

rt := 1

number_one, err1 := strconv.Atoi(args[2])

number_two, err2 := strconv.Atoi(args[3])

if err1 == nil && err2 == nil {

rt = number_one * number_two

fmt.Println("Result ", rt)

}

case "sqrt":

{

rt := float64(0)

if len(args) != 3 {

fmt.Println("Usage: sqrt 2, return 1.4142135623730951")

return nil

}

number_one, err := strconv.ParseFloat(args[2], 64)

if err == nil {

rt = math.Sqrt(number_one)

fmt.Println("Result ", rt)

}

default:

help()

}

return nil

}

最后的效果大概是：

./calc add 1 2

Result 3

====================

./calc sub 1 2

Result -1

====================

./calc mul 10 20

Result 200

===================

./calc sqrt 2

Result 1.4142135623730951

2. flag 获取命令行参数

flag 包比 os 读取参数更方便。可以自定义传入的参数的类型：比如字符串，整型，浮点型，默认参数设置等

基本的使用方法如下：

var operate string

flag.StringVar(&operate,"o", "add", "operation for calc")

# 解释

绑定 operate 变量， name="o", value="add" , usage="operation for calc"

也可以这样定义为指针变量

1	`var operate := flag.String("o", "add", "operation for calc")`

同时还可以自定义 flag 类型

所有变量注册之后，调用 flag.Parse() 来解析命令行参数，如果是绑定变量的方式，直接使用变量进行操作，

如果使用指针变量型，需要 *operate 这样使用。

flag.Args() 表示接收的所有命令行参数集，也是一个切片

for index, value := range flag.Args {

fmt.Println(index, value)

}

func CalcByFlag() error {

var operation string

var numberone float64

var numbertwo float64

flag.StringVar(&operation, "o", "add", "operation for this tool")

flag.Float64Var(&numberone, "n1", 0, "The first number")

flag.Float64Var(&numbertwo, "n2", 0, "The second number")

flag.Parse()

fmt.Println(numberone, numbertwo)

if operation == "add" {

rt := numberone + numbertwo

fmt.Println("Result ", rt)

} else if operation == "sub" {

rt := numberone - numbertwo

fmt.Println("Result ", rt)

} else if operation == "mul" {

rt := numberone * numbertwo

fmt.Println("Result ", rt)

} else if operation == "sqrt" {

rt := math.Sqrt(numberone)

fmt.Println("Result ", rt)

} else {

help()

}

return nil

}

最后的结果效果如下：

./calc -o add -n1 1 -n2 2

Result 3

=============================

./calc -o sub -n1 2 -n2 3

Result -1

============================

./calc -o mul -n1 10 -n2 20

Result 200

===========================

./calc -o sqrt -n1 2

Result 1.4142135623730951

3. CLI 框架

cli 是一款业界比较流行的命令行框架。

所以你首先需要安装：

1	`go get github.com/urfave/cli`

# 一个简单的示例如下：

package main

import (

"fmt"

"os"

"github.com/urfave/cli"

)

func main() {

app := cli.NewApp()

app.Name = "boom"

app.Usage = "make an explosive entrance"

app.Action = func(c *cli.Context) error {

fmt.Println("boom! I say!")

return nil

}

app.Run(os.Args)

}

好，为实现 “简单数学计算” 的功能，我们应该怎么实现呢？

主要是使用框架中的 Flag 功能，对参数进行设置

app.Flags = []cli.Flag {

cli.StringFlag{

Name: "operation, o",

Value: "add",

Usage: "calc operation",

},

cli.Float64Flag{

Name: "numberone, n1",

Value: 0,

Usage: "number one for operation",

},

cli.Float64Flag{

Name: "numbertwo, n2",

Value: 0,

Usage: "number two for operation",

},

}

能看出，我们使用了三个参数：operation、numberone、numbertwo

同时定义了参数的类型，默认值，以及别名（缩写）

那么在这个框架中如何实现参数的操作呢：主要是重写app.Action 方法

app.Action = func(c *cli.Context) error {

operation := c.String("operation")

numberone := c.Float64("numberone")

numbertwo := c.Float64("numbertwo")

//fmt.Println(operation, numberone, numbertwo)

if operation == "add" {

rt := numberone + numbertwo

fmt.Println("Result ", rt)

} else if operation == "sub" {

rt := numberone - numbertwo

fmt.Println("Result ", rt)

} else if operation == "mul" {

rt := numberone * numbertwo

fmt.Println("Result ", rt)

} else if operation == "sqrt" {

rt := math.Sqrt(numberone)

fmt.Println("Result ", rt)

} else {

help()

}

return nil

}

# 对 operation 参数进行判断，执行的是那种运算，然后编写相应的运算操作

func CalcByCli(){

app := cli.NewApp()

app.Name = "calc with go"

app.Usage = "calc tool operate by go"

app.Version = "0.1.0"

app.Flags = [] cli.Flag {

cli.StringFlag{

Name: "operation, o",

Value: "add",

Usage: "calc operation",

},

cli.Float64Flag{

Name: "numberone, n1",

Value: 0,

Usage: "number one for operation",

},

cli.Float64Flag{

Name: "numbertwo, n2",

Value: 0,

Usage: "number two for operation",

},

}

app.Action = func(c *cli.Context) error {

operation := c.String("operation")

numberone := c.Float64("numberone")

numbertwo := c.Float64("numbertwo")

//fmt.Println(operation, numberone, numbertwo)

if operation == "add" {

rt := numberone + numbertwo

fmt.Println("Result ", rt)

} else if operation == "sub" {

rt := numberone - numbertwo

fmt.Println("Result ", rt)

} else if operation == "mul" {

rt := numberone * numbertwo

fmt.Println("Result ", rt)

} else if operation == "sqrt" {

rt := math.Sqrt(numberone)

fmt.Println("Result ", rt)

} else {

help()

}

return nil

}

app.Run(os.Args)

}

调用这个函数的最终效果如下：

./calc -o add --n1 12 --n2 12

Result 24

===================================

./calc -o sub --n1 100 --n2 200

Result -100

===================================

./calc -o mul --n1 10 --n2 20

Result 200

===================================

./calc -o sqrt --n1 2

Result 1.4142135623730951

4 其他

知道如何读取命令行参数，就可以实现一些更有意思的事。

比如网上有许多免费的 API 接口，比如查询天气，查询农历的API 接口。

还有一些查询接口，比如有道云翻译接口，你可以实现翻译的功能。

或者扇贝的接口，实现查询单词的功能。

再比如一些音乐接口，实现音乐信息查询。

不一一列了。

下面实现一个调用免费的查询天气的接口实现命令行查询天气。

GO 如何进行 HTTP 访问？内置的 net/http 可以实现

一个简易的GET 操作如下：

func Requests(url string) (string, error) {

response, err := http.Get(url)

if err != nil {

return "", err

}

defer response.Body.Close()

body, _ := ioutil.ReadAll(response.Body)

return string(body), nil

}

免费的 API URL 如下：

1	`http://www.sojson.com/open/api/weather/json.shtml?city=北京`

返回的结果是一个Json 格式的数据

{

"status": 200,

"data": {

"wendu": "29",

"ganmao": "各项气象条件适宜，发生感冒机率较低。但请避免长期处于空调房间中，以防感冒。",

"forecast": [

{

"fengxiang": "南风",

"fengli": "3-4级",

"high": "高温 32℃",

"type": "多云",

"low": "低温 17℃",

"date": "16日星期二"

},

{

"fengxiang": "南风",

"fengli": "微风级",

"high": "高温 34℃",

"type": "晴",

"low": "低温 19℃",

"date": "17日星期三"

},

{

"fengxiang": "南风",

"fengli": "微风级",

"high": "高温 35℃",

"type": "晴",

"low": "低温 22℃",

"date": "18日星期四"

},

{

"fengxiang": "南风",

"fengli": "微风级",

"high": "高温 35℃",

"type": "多云",

"low": "低温 22℃",

"date": "19日星期五"

},

{

"fengxiang": "南风",

"fengli": "3-4级",

"high": "高温 34℃",

"type": "晴",

"low": "低温 21℃",

"date": "20日星期六"

}

],

"yesterday": {

"fl": "微风",

"fx": "南风",

"high": "高温 28℃",

"type": "晴",

"low": "低温 15℃",

"date": "15日星期一"

},

"aqi": "72",

"city": "北京"

},

"message": "OK"

}

所以我们的任务就是传入 “城市” 的名称，再对返回的 Json 数据解析。

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

package main

import (

"fmt"

"os"

"encoding/json"

"github.com/urfave/cli"

"net/http"

"io/ioutil"

//"github.com/modood/table"

)

type Response struct {

Status int `json:"status"`

CityName string `json:"city"`

Data Data `json:"data"`

Date string `json:"date"`

Message string `json:"message"`

Count int `json:"count"`

}

type Data struct {

ShiDu string `json:"shidu"`

Quality string `json:"quality"`

Ganmao string `json:"ganmao"`

Yesterday Day `json:"yesterday"`

Forecast []Day `json:"forecast"`

}

type Day struct {

Date string `json:"date"`

Sunrise string `json:"sunrise"`

High string `json:"high"`

Low string `json:"low"`

Sunset string `json:"sunset"`

Aqi float32 `json:"aqi"`

Fx string `json:"fx"`

Fl string `json:"fl"`

Type string `json:"type"`

Notice string `json:"notice"`

}

func main() {

const apiURL = "http://www.sojson.com/open/api/weather/json.shtml?city="

app := cli.NewApp()

app.Name = "weather-cli"

app.Usage = "天气预报小程序"

app.Flags = []cli.Flag{

cli.StringFlag{

Name: "city, c",

Value: "上海",

Usage: "城市中文名",

},

cli.StringFlag{

Name: "day, d",

Value: "今天",

Usage: "可选: 今天, 昨天, 预测",

},

cli.StringFlag{

Name: "Author, r",

Value: "xiewei",

Usage: "Author name",

},

}

app.Action = func(c *cli.Context) error {

city := c.String("city")

day := c.String("day")

var body, err = Requests(apiURL + city)

if err != nil {

fmt.Printf("err was %v", err)

return nil

}

var r Response

err = json.Unmarshal([]byte(body), &r)

if err != nil {

fmt.Printf("\nError message: %v", err)

return nil

}

if r.Status != 200 {

fmt.Printf("获取天气API出现错误, %s", r.Message)

return nil

}

Print(day, r)

return nil

}

app.Run(os.Args)

}

func Print(day string, r Response) {

fmt.Println("城市:", r.CityName)

if day == "今天" {

fmt.Println("湿度:", r.Data.ShiDu)

fmt.Println("空气质量:", r.Data.Quality)

fmt.Println("温馨提示:", r.Data.Ganmao)

} else if day == "昨天" {

fmt.Println("日期:", r.Data.Yesterday.Date)

fmt.Println("温度:", r.Data.Yesterday.Low, r.Data.Yesterday.High)

fmt.Println("风量:", r.Data.Yesterday.Fx, r.Data.Yesterday.Fl)

fmt.Println("天气:", r.Data.Yesterday.Type)

fmt.Println("温馨提示:", r.Data.Yesterday.Notice)

} else if day == "预测" {

fmt.Println("====================================")

for _, item := range r.Data.Forecast {

fmt.Println("日期:", item.Date)

fmt.Println("温度:", item.Low, item.High)

fmt.Println("风量:", item.Fx, item.Fl)

fmt.Println("天气:", item.Type)

fmt.Println("温馨提示:", item.Notice)

fmt.Println("====================================")

}

} else {

fmt.Println("...")

}

func Requests(url string) (string, error) {

response, err := http.Get(url)

if err != nil {

return "", err

}

defer response.Body.Close()

body, _ := ioutil.ReadAll(response.Body)

return string(body), nil

}

最终的效果大概如下：

./weather -c 上海

城市: 上海

湿度: 80%

空气质量: 轻度污染

温馨提示: 儿童、老年人及心脏、呼吸系统疾病患者人群应减少长时间或高强度户外锻炼

================================

./weaather -c 上海 -d 昨天

城市: 上海

日期: 28日星期二

温度: 低温 12.0℃ 高温 19.0℃

风量: 西南风 <3级

天气: 小雨

温馨提示: 雾蒙蒙的雨天，最喜欢一个人听音乐

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对脚本之家的支持。

上一篇 »javascript:中定义类，class的几种方法总结？
下一篇 »PHP检测数据类型的几种方法？总结【转】

Go 中读取命令参数的几种方法总结？

相关推荐

java读取clob字段的几种方法？

mysql命令行中执行sql的几种方式总结？

C#遍历DataSet中数据的几种方法总结？

go语言中type的几种使用？

[转]matlab读取cvs文件的几种方法？

asp.net页面之间传递参数的几种方法？

angular中的用到的几种方法总结？

C#和asp.net中链接数据库中 参数的几种传递方法？

C#和asp.net中链接数据库中参数的几种传递方法？