Cambiar valores mientras itera

Supongamos que tengo estos tipos:

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

y que quiero iterar sobre los atributos de mi nodo para cambiarlos.

Me hubiera encantado poder hacer:

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

pero como attrno es un puntero, esto no funcionaría y tengo que hacer:

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

¿Hay una manera más simple o más rápida? ¿Es posible obtener directamente punteros range?

Obviamente no quiero cambiar las estructuras solo por la iteración y las soluciones más detalladas no son soluciones.

No, la abreviatura que desea no es posible.

La razón de esto es que rangecopia los valores del segmento sobre el que está iterando. La especificación sobre el rango dice:

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

Por lo tanto, el rango utiliza a[i]como su segundo valor para matrices / sectores, lo que significa que el valor se copia, haciendo que el valor original sea intocable.

Este comportamiento se demuestra mediante el siguiente 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)
}

El código le imprime ubicaciones de memoria completamente diferentes para el valor del rango y el valor real en el segmento:

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

Entonces, lo único que puede hacer es usar punteros o el índice, como ya lo propusieron jnml y peterSO.

Parece que estás pidiendo algo equivalente a esto:

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)
}

Salida:

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

Esto evita crear una copia, posiblemente grande, de los Attributevalores de tipo , a expensas de las comprobaciones de los límites de corte. En su ejemplo, el tipo Attributees relativamente pequeño, dos stringreferencias de segmento: 2 * 3 * 8 = 48 bytes en una máquina de arquitectura de 64 bits.

También podrías simplemente escribir:

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

Pero, la forma de obtener un resultado equivalente con una rangecláusula, que crea una copia pero minimiza las comprobaciones de los límites de corte, es:

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

Adaptaría su última sugerencia y usaría la versión de rango de solo índice.

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

Me parece más simple referirme n.Attr[i]explícitamente tanto en la línea que prueba Keycomo en la línea que establece Val, en lugar de usar attrpara una y n.Attr[i]para la otra.

Por ejemplo:

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)
        }
}

Patio de recreo

Salida

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

Enfoque alternativo:

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)
        }
}

Patio de recreo

Salida:

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