Ubah nilai saat iterasi

Misalkan saya memiliki tipe-tipe ini:

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

dan bahwa saya ingin beralih pada atribut simpul saya untuk mengubahnya.

Saya ingin sekali dapat melakukan:

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

tetapi karena attrbukan sebuah pointer, ini tidak akan berhasil dan harus saya lakukan:

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

Apakah ada cara yang lebih sederhana atau lebih cepat? Apakah mungkin untuk mendapatkan pointer secara langsung range?

Jelas saya tidak ingin mengubah struktur hanya untuk iterasi dan solusi yang lebih verbal bukanlah solusi.

Tidak, singkatan yang Anda inginkan tidak mungkin.

Alasannya adalah karena rangemenyalin nilai dari slice yang Anda iterasi. The spesifikasi tentang berbagai mengatakan:

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

Jadi, rentang menggunakan a[i]sebagai nilai kedua untuk array / irisan, yang secara efektif berarti bahwa nilai tersebut disalin, membuat nilai asli tidak tersentuh.

Perilaku ini ditunjukkan oleh kode berikut :

x := make([]int, 3)

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

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

Kode ini mencetak lokasi memori yang sama sekali berbeda untuk nilai dari rentang dan nilai aktual di slice:

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

Jadi satu-satunya hal yang dapat Anda lakukan adalah menggunakan pointer atau indeks, seperti yang telah diusulkan oleh jnml dan peterSO.

Anda tampaknya meminta sesuatu yang setara dengan ini:

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

Keluaran:

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

Ini menghindari pembuatan - kemungkinan besar - salinan Attributenilai tipe , dengan mengorbankan pengecekan slice bounds. Dalam contoh Anda, tipe Attributerelatif kecil, dua stringreferensi slice: 2 * 3 * 8 = 48 byte pada mesin arsitektur 64-bit.

Anda juga bisa menulis:

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

Tapi, cara untuk mendapatkan hasil yang setara dengan rangeklausa, yang membuat salinan tetapi meminimalkan cek batas slice, adalah:

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

Saya akan menyesuaikan saran terakhir Anda dan menggunakan versi rentang indeks saja.

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

Tampaknya lebih mudah bagi saya untuk merujuk n.Attr[i]secara eksplisit di kedua baris yang menguji Keydan baris yang mengatur Val, daripada menggunakan attruntuk satu dan n.Attr[i]untuk yang lain.

Sebagai contoh:

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

Tempat bermain

Keluaran

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

Pendekatan alternatif:

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

Tempat bermain

Keluaran:

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