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

Question

在过去的几天里，我一直在寻找解决一流函数问题的最佳方法(将可调用函数分配给某个变量(，以及效率方面的最佳实践。

假设我正在编程一个Yugioh纸牌游戏，我希望每一张类型的牌都至少具有以下属性：

type card struct {
name string
text string
}

我一直在为在哪里(以及如何(对每张卡的各个功能进行编程而苦苦挣扎。我目前确信，一流函数的最佳位置是在type card struct中，并像在Python中那样将新属性创建为"可调用"(Go游乐场链接(。

package main
import "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 file
type swap func(target *monsterCard, value int) // ditto
var 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)
}