Go 中处理混合类型的哈希替代方案

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《Go 中处理混合类型的哈希替代方案》，文章讲解的知识点主要包括，如果你对Golang方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

我正在做一个编程练习来熟悉 go。我目前正在编写一个解析器，它将字符串解析为带有参数的命令，例如：

c w h           should create a new canvas of width w and height h.
b x y c         should fill the entire area connected to (x,y) with "colour" c.
q               should quit the program.

首先，我开始使用哈希来保存参数，例如w h。但这是不灵活的，正如您所看到的 c 是一种颜色，它将是一个字符串，而其他参数是整数。

我是这样开始的：

package main

import (
    "errors"
    "strconv"
    "strings"
)

type command struct {
    id   string
    args map[string]int // won't work because args can be of mixed types
}

func parsecommand(input string) (command, error) {
    if input == "" {
        return command{}, errors.new("no input")
    }

    commandparts := strings.split(input, " ")

    switch commandparts[0] {
    case "c":
        if (len(commandparts)) != 3 {
            return command{}, errors.new("c (create) requires 2 arguments")
        }

        w, err := strconv.atoi(commandparts[1])

        if err != nil {
            return command{}, errors.new("width must be an integer")
        }

        h, err := strconv.atoi(commandparts[2])

        if err != nil {
            return command{}, errors.new("height must be an integer")
        }

        return command{
            id: "create",
            args: map[string]int{
                "w": w,
                "h": h,
            },
        }, nil
    case "b":
        if (len(commandparts)) != 4 {
            return command{}, errors.new("b (bucket fill) requires 3 arguments")
        }

        x, err := strconv.atoi(commandparts[1])

        if err != nil {
            return command{}, errors.new("x must be an integer")
        }

        y, err := strconv.atoi(commandparts[2])

        if err != nil {
            return command{}, errors.new("y must be an integer")
        }

        return command{
            id: "bucketfill",
            args: map[string]int{
                "x": x,
                "y": y,
                "c": commandparts[3], // this should be a string!
            },
        }, nil
    case "q":
        return command{
            id: "quit",
        }, nil
    default:
        return command{}, errors.new("command not supported")
    }
}

我的问题是，如果我想返回的参数是变量并且具有混合类型，我应该如何将输入字符串解析为命令？谢谢。

p.s 命令可以自由输入并修改终端中的假画布，例如：

enter command: C 20 4
----------------------
|                    |
|                    |
|                    |
|                    |
----------------------

// Didn't mention this one but it's a Line if you didn't guess
enter command: L 1 2 6 2
----------------------
|                    |
|xxxxxx              |
|                    |
|                    |
----------------------

解决方案

您对 command 的方法不正确。 command 是可以应用于画布的东西。所以我们这样说：

type canvas struct{ ... }

type command interface {
    apply(canvas *canvas)
}

现在有多种命令，每种命令都有自己的参数。但是，当用作命令时，调用者不必关心这些参数是什么。

type createcommand struct {
    width  int
    height int
}

func (c createcommand) apply(canvas *canvas) { ... }

type bucketfillcommand struct {
    x     int
    y     int
    color string
}

func (c bucketfillcommand) apply(canvas *canvas) { ... }

type quitcommand struct{}

func (c quitcommand) apply(canvas *canvas) { ... }

然后你可以解析它们（我可能会将所有解析放入函数中，但这很好）。

func parseCommand(input string) (command, error) {
    if input == "" {
        return nil, errors.New("No input")
    }

    commandParts := strings.Split(input, " ")

    switch commandParts[0] {
    case "C":
        if (len(commandParts)) != 3 {
            return nil, errors.New("C (create) requires 2 arguments")
        }

        w, err := strconv.Atoi(commandParts[1])

        if err != nil {
            return nil, errors.New("width must be an integer")
        }

        h, err := strconv.Atoi(commandParts[2])

        if err != nil {
            return nil, errors.New("height must be an integer")
        }

        return createCommand{width: w, height: h}, nil
    case "B":
        if (len(commandParts)) != 4 {
            return nil, errors.New("B (Bucket Fill) requires 3 arguments")
        }

        x, err := strconv.Atoi(commandParts[1])

        if err != nil {
            return nil, errors.New("x must be an integer")
        }

        y, err := strconv.Atoi(commandParts[2])

        if err != nil {
            return nil, errors.New("y must be an integer")
        }

        return bucketFillCommand{x: x, y: y, color: commandParts[3]}, nil
    case "Q":
        return quitCommand{}, nil
    default:
        return nil, errors.New("Command not supported")
    }
}

请注意，当出现故障时，此命令会返回 nil 作为命令，而不是 command{}。

Playground

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Go 中处理混合类型的哈希替代方案》文章吧，也可关注golang学习网公众号了解相关技术文章。