Go 读取命令参数的几种方式-原创手记-慕课网

微信截图_20171129195400.png

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

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

# input  ./calc add 1 2# output3# input./calc sub 1 2# out-1# input./calc mul 10 20# out200

使用的三种方式是：

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

0. 已有历史经验

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

Python

import sys

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

Shell

if [ $# -ne 2 ]; then
  echo "Usage: $0 param1 pram2"
  exit 1finame=$1age=$2echo $nameecho $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 2Result 3====================

./calc sub 1 2Result -1====================

./calc mul 10 20Result 200===================

./calc sqrt 2Result 1.4142135623730951

2. flag 获取命令行参数

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

基本的使用方法如下：

var operate stringflag.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 2Result 3=============================

./calc -o sub -n1 2 -n2 3Result -1============================

./calc -o mul -n1 10 -n2 20Result 200===========================

./calc -o sqrt -n1 2Result 1.4142135623730951

3. CLI 框架

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

所以你首先需要安装：

go get github.com/urfave/cli

# 一个简单的示例如下：package mainimport (  "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 12Result 24===================================

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

./calc -o mul --n1 10 --n2 20Result 200===================================

./calc -o sqrt --n1 2Result 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 mainimport (        "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级
天气: 小雨
温馨提示: 雾蒙蒙的雨天，最喜欢一个人听音乐

(全文完)

作者：谢小路
链接：https://www.jianshu.com/p/548adff0d10d