http://openmymind.net/Things-I-Wish-Someone-Had-Told-Me-About-Go/

试图让我了解 Go，它仍然很新。我知道 C 中的引用和指针，但我似乎无法在 Go 中使用它。我已经阅读了很多关于这个问题的文章，但仍然没有真正设法理解和实现解决方案。

角色有生命值和攻击点。

Chars 可以 Attack()。

战斗回合调用 Attack() ，角色可以在此回合进行攻击。

意图，当在角色上调用 Attack() 时，另一个角色的生命值会发生变化。

目前角色的生命值永远不会改变。

谁能给我一个简洁的例子，说明如何以正确的方式更改对象的值？

package main

import (
    "fmt"
    "math/rand"
    "time"
)

//Character health + atk of
type Character struct {
    Health, Atk int
}

//Attack ... Character can Attack
func (c *Character) Attack(health, atk int) {
    health -= atk
}

//CharacterInterface ... methods for characters
type CharacterInterface interface {
    Attack(health, atk int)
}

func combatRound(p, e Character) {
    whoAtks := rand.Intn(100)
    if whoAtks > 30 {
        p.Attack(e.Health, p.Atk)
        fmt.Println(p.Health)
    } else {
        e.Attack(p.Health, e.Atk)

        fmt.Println(p.Health)
    }
}

func main() {
    //seed rand generator for the current run
    rand.Seed(time.Now().UTC().UnixNano())
    p := Character{20, 5}
    e := Character{20, 5}
    combatRound(p, e)
    fmt.Println("Player Health: %d \n Enemy Health: %d", p.Health, e.Health)

}

最佳答案

在 Go 中，调用函数或方法的参数和接收者总是按值传递(通过赋值)。

例如，

package main

import (
    "fmt"
    "math/rand"
    "time"
)

type Attacker interface {
    Attacks(a *Character)
}

type Character struct {
    Health, Attack int
}

func (c *Character) Attacks(a *Character) {
    a.Health -= c.Attack
}

func combatRound(player, enemy *Character) {
    if rand.Intn(100) <= 30 {
        player, enemy = enemy, player
    }
    player.Attacks(enemy)
}

func main() {
    rand.Seed(time.Now().UnixNano())
    p := &Character{20, 5}
    e := &Character{20, 5}
    combatRound(p, e)
    fmt.Printf("Player Health: %d\nEnemy Health: %d\n", p.Health, e.Health)
}

输出:

$ go run attack.go
Player Health: 20 
Enemy Health: 15
$ go run attack.go
Player Health: 20 
Enemy Health: 15
$ go run attack.go
Player Health: 15 
Enemy Health: 20

The Go Programming Language Specification

Assignments

Assignment = ExpressionList assign_op ExpressionList .

assign_op = [ add_op | mul_op ] "=" .

Each left-hand side operand must be addressable, a map index expression, or (for = assignments only) the blank identifier. Operands may be parenthesized.

A tuple assignment assigns the individual elements of a multi-valued operation to a list of variables. There are two forms. In the first, the right hand operand is a single multi-valued expression such as a function call, a channel or map operation, or a type assertion. The number of operands on the left hand side must match the number of values. For instance, if f is a function returning two values,

x, y = f()

assigns the first value to x and the second to y. In the second form, the number of operands on the left must equal the number of expressions on the right, each of which must be single-valued, and the nth expression on the right is assigned to the nth operand on the left:

one, two, three = '一', '二', '三'

The assignment proceeds in two phases. First, the operands of index expressions and pointer indirections (including implicit pointer indirections in selectors) on the left and the expressions on the right are all evaluated in the usual order. Second, the assignments are carried out in left-to-right order.

a, b = b, a  // exchange a and b

Go 语句

player, enemy = enemy, player

是元组赋值的第二种形式。这是交换两个值的惯用方式。左边的操作数和右边的表达式在赋值发生之前被求值。编译器会为您处理任何临时变量。

在 combatRound 函数中，对于 100 次调用中的 31 次([0, 100 的间隔 [0, 30])次调用，平均而言，角色被颠倒或交换，敌人(防御者)击退玩家(攻击者)。交换指向 Characters 的指针反射(reflect)了角色互换。并且玩家的生命值下降，而不是敌人的。

关于去改变结构属性值，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35386151/