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

前言

对于一名初学者来说，想要尽快熟悉 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

import sys

args = sys.argv

# args 是一个列表
# 第一个值表示的是 文件名
# 除第一个之外，其他的值是接受的参数

shell

if [ $# -ne 2 ]; then
 echo "usage: $0 param1 pram2"
 exit 1
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"

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

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 框架

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

所以你首先需要安装：

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 如下：

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 数据解析。

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级
天气: 小雨
温馨提示: 雾蒙蒙的雨天，最喜欢一个人听音乐

总结

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