Alterar valores enquanto itera

Vamos supor que eu tenho esses tipos:

type Attribute struct {
    Key, Val string
}
type Node struct {
    Attr []Attribute
}

e que eu quero iterar nos atributos do meu nó para alterá-los.

Eu adoraria poder fazer:

for _, attr := range n.Attr {
    if attr.Key == "href" {
        attr.Val = "something"
    }
}

mas como attrnão é um ponteiro, isso não funcionaria e eu tenho que fazer:

for i, attr := range n.Attr {
    if attr.Key == "href" {
        n.Attr[i].Val = "something"
    }
}

Existe uma maneira mais simples ou mais rápida? É possível obter diretamente ponteiros range?

Obviamente, não quero alterar as estruturas apenas para a iteração, e soluções mais detalhadas não são soluções.

Não, a abreviação que você deseja não é possível.

A razão para isso é que rangecopia os valores da fatia na qual você está repetindo. A especificação sobre a faixa diz:

Range expression                          1st value             2nd value (if 2nd variable is present)
array or slice  a   [n]E, *[n]E, or []E   index    i  int       a[i]       E

Portanto, o intervalo usa a[i]como seu segundo valor para matrizes / fatias, o que significa efetivamente que o valor é copiado, tornando o valor original intocável.

Esse comportamento é demonstrado pelo seguinte código :

x := make([]int, 3)

x[0], x[1], x[2] = 1, 2, 3

for i, val := range x {
    println(&x[i], "vs.", &val)
}

O código imprime locais de memória completamente diferentes para o valor do intervalo e o valor real na fatia:

0xf84000f010 vs. 0x7f095ed0bf68
0xf84000f014 vs. 0x7f095ed0bf68
0xf84000f018 vs. 0x7f095ed0bf68

Portanto, a única coisa que você pode fazer é usar ponteiros ou o índice, como já proposto por jnml e peterSO.

Você parece estar pedindo algo equivalente a isso:

package main

import "fmt"

type Attribute struct {
    Key, Val string
}
type Node struct {
    Attr []Attribute
}

func main() {

    n := Node{
        []Attribute{
            {"key", "value"},
            {"href", "http://www.google.com"},
        },
    }
    fmt.Println(n)

    for i := 0; i < len(n.Attr); i++ {
        attr := &n.Attr[i]
        if attr.Key == "href" {
            attr.Val = "something"
        }
    }

    fmt.Println(n)
}

Resultado:

{[{key value} {href http://www.google.com}]}
{[{key value} {href something}]}

Isso evita a criação de uma cópia - possivelmente grande - dos Attributevalores de tipo , às custas das verificações de limites de fatia. No seu exemplo, o tipo Attributeé relativamente pequeno, com duas stringreferências de fatia: 2 * 3 * 8 = 48 bytes em uma máquina de arquitetura de 64 bits.

Você também pode simplesmente escrever:

for i := 0; i < len(n.Attr); i++ {
    if n.Attr[i].Key == "href" {
        n.Attr[i].Val = "something"
    }
}

Porém, a maneira de obter um resultado equivalente com uma rangecláusula, que cria uma cópia, mas minimiza as verificações de limites de fatia, é:

for i, attr := range n.Attr {
    if attr.Key == "href" {
        n.Attr[i].Val = "something"
    }
}

Eu adaptaria sua última sugestão e usaria a versão apenas do índice do intervalo.

for i := range n.Attr {
    if n.Attr[i].Key == "href" {
        n.Attr[i].Val = "something"
    }
}

Parece-me mais simples me referir n.Attr[i]explicitamente na linha que testa Keye na linha que define Val, em vez de usar attrpara um e n.Attr[i]para o outro.

Por exemplo:

package main

import "fmt"

type Attribute struct {
        Key, Val string
}

type Node struct {
        Attr []*Attribute
}

func main() {
        n := Node{[]*Attribute{
                &Attribute{"foo", ""},
                &Attribute{"href", ""},
                &Attribute{"bar", ""},
        }}

        for _, attr := range n.Attr {
                if attr.Key == "href" {
                        attr.Val = "something"
                }
        }

        for _, v := range n.Attr {
                fmt.Printf("%#v\n", *v)
        }
}

Parque infantil

Resultado

main.Attribute{Key:"foo", Val:""}
main.Attribute{Key:"href", Val:"something"}
main.Attribute{Key:"bar", Val:""}

Abordagem alternativa:

package main

import "fmt"

type Attribute struct {
        Key, Val string
}

type Node struct {
        Attr []Attribute
}

func main() {
        n := Node{[]Attribute{
            {"foo", ""},
            {"href", ""},
            {"bar", ""},
        }}

        for i := range n.Attr {
                attr := &n.Attr[i]
                if attr.Key == "href" {
                        attr.Val = "something"
                }
        }

        for _, v := range n.Attr {
                fmt.Printf("%#v\n", v)
        }
}

Parque infantil

Resultado:

main.Attribute{Key:"foo", Val:""}
main.Attribute{Key:"href", Val:"something"}
main.Attribute{Key:"bar", Val:""}