Go，一流的功能和最佳实践

Question

在过去的几天里，我一直在解决一流函数问题的最佳方法（将可调用对象分配给某个变量）以及效率方面的最佳实践方面遇到障碍。假设我正在编写一个 Yugioh 纸牌游戏，我希望每张卡片类型的卡片至少具有以下属性：type card struct {    name string    text string}我一直在努力思考在哪里（以及如何）对每张卡的单独功能进行编程的想法。我目前确信一流函数的最佳位置是type card struct创建新属性作为“可调用”，就像我在 Python 中那样（Go playground 链接）。package mainimport "fmt"type card struct {    name string    text string    f interface{}}type monsterCard struct {    card    attack int    defense int}type buff func(target *monsterCard) // Could be defined in a second filetype swap func(target *monsterCard, value int) // dittovar increaseAttack buff = func(target *monsterCard)  { // ditto    target.attack += 100}var swichStats swap = func(target *monsterCard, value int) { // ditto    attack := target.attack    target.attack = value    target.defense = attack}func main()  {    m1 := monsterCard{        card:    card{            name: "Celtic Guardian",            f:    increaseAttack,        },        attack:  1400,        defense: 1200,    }    m2 := monsterCard{        card:    card{            name:     "Dark Magician",            f:         swichStats,        },        attack:  2500,        defense: 2100,    }    var monsters = [2]monsterCard{m1, m2}    for _, m := range monsters {        fmt.Println(m)        switch m.f.(type) {        case buff:            m.f.(buff)(&m)        case swap:            m.f.(swap)(&m, m.defense)        default:            fmt.Printf("%T", m.f)        }        fmt.Println(m)    }}我在高效代码方面不是很好，我完全理解我可能会在这里提前优化；但是，我需要编写数百个这样的卡，如果这些可调用对象存在于全局范围内并且严重依赖类型断言会使程序变慢，那么我将在重新组织代码时遇到麻烦。我的方法有什么明显的问题吗？我是否正确地使用了一流的功能，还是有一些我看不到的明显性能问题？任何和所有的帮助将不胜感激！

Answer 1

您可以在需要时使用普通函数和闭包：

type card struct {

    name string

    text string

    fn   func(*monsterCard)

}

type monsterCard struct {

    card

    attack  int

    defense int

}

func (mc *monsterCard) call() {

    mc.fn(mc)

}

func increaseAttack(mc *monsterCard) {

    mc.attack += 100

}

func switchStats(mc *monsterCard) {

    mc.attack, mc.defense = mc.defense, mc.attack

}

func updateTextAndAttack(text string, attack int) func(mc *monsterCard) {

    return func(mc *monsterCard) {

        mc.text, mc.attack = text, attack

    }

}

https://play.golang.com/p/v_RbObnu7sN

您还可以在需要时使用普通方法和闭包：

type card struct {

    name string

    text string

}

type monsterCard struct {

    card

    attack  int

    defense int

}

func (mc *monsterCard) increaseAttack() {

    mc.attack += 100

}

func (mc *monsterCard) switchStats() {

    mc.attack, mc.defense = mc.defense, mc.attack

}

func (mc *monsterCard) updateTextAndAttack(text string, attack int) func() {

    return func() {

        mc.text, mc.attack = text, attack

    }

}

https://play.golang.com/p/Eo1mm-seldA

Answer 2

看来我仍在使用我的脚本语言思维方式来尝试用编译语言解决问题。与其尝试创建最终导致代码更难阅读的接口，我需要更严格地自定义类型定义，并为每种类型的卡片效果实现不同的函数类型。如此严格的执行也将允许具有多种效果的卡牌存在于游戏中。

package main

type card struct {

    name string

    text string

}

type monsterCard struct {

    card

    attack int

    defense int

}

type buffEffect struct {

    monsterCard

    fn buff

}

type setValueEffect struct {

    monsterCard

    fn swap

}

type buff func(target *monsterCard)

type swap func(target *monsterCard, value int)

var increaseAttack buff = func(target *monsterCard)  {

    target.attack += 100

}

var setAttackValue swap = func(target *monsterCard, value int) {

    target.attack = value

}

func main()  {

    m1 := buffEffect{

        monsterCard: monsterCard{

            card:    card{

                name: "Celtic Guardian",

            },

            attack:  1400,

            defense: 1200,

        },

        fn:          increaseAttack,

    }

    m2 := setValueEffect{

        monsterCard: monsterCard{

            card:    card{

                name: "Dark Magician",

            },

            attack:  2500,

            defense: 2100,

        },

        fn:          setAttackValue,

    }

    m1.fn(&m1.monsterCard)

    m2.fn(&m2.monsterCard, 100)

}