Thay đổi giá trị trong khi lặp

Giả sử tôi có những loại này:

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

và rằng tôi muốn lặp lại các thuộc tính của nút để thay đổi chúng.

Tôi rất thích có thể làm:

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

nhưng attrkhông phải là một con trỏ, điều này sẽ không hoạt động và tôi phải làm:

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

Có cách nào đơn giản hơn hay nhanh hơn? Có thể trực tiếp nhận được con trỏ từ range?

Rõ ràng tôi không muốn thay đổi các cấu trúc chỉ cho lần lặp và các giải pháp dài dòng hơn không phải là giải pháp.

Không, viết tắt bạn muốn là không thể.

Lý do cho điều này là rangesao chép các giá trị từ lát bạn đang lặp đi lặp lại. Các đặc điểm kỹ thuật về phạm vi nói:

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

Vì vậy, phạm vi sử dụng a[i]làm giá trị thứ hai của nó cho các mảng / lát, có nghĩa là giá trị đó được sao chép một cách hiệu quả, làm cho giá trị ban đầu không thể chạm tới được.

Hành vi này được thể hiện bằng mã sau đây :

x := make([]int, 3)

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

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

Mã in cho bạn các vị trí bộ nhớ hoàn toàn khác nhau cho giá trị từ phạm vi và giá trị thực trong lát:

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

Vì vậy, điều duy nhất bạn có thể làm là sử dụng con trỏ hoặc chỉ mục, như đã được đề xuất bởi jnml và peterSO.

Bạn dường như đang yêu cầu một cái gì đó tương đương với điều này:

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

Đầu ra:

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

Điều này tránh tạo ra một bản sao - có thể lớn - của các Attributegiá trị loại , với chi phí kiểm tra giới hạn lát. Trong ví dụ của bạn, loại Attributetương đối nhỏ, hai stringtham chiếu lát: 2 * 3 * 8 = 48 byte trên máy kiến ​​trúc 64 bit.

Bạn cũng có thể chỉ cần viết:

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

Nhưng, cách để có được kết quả tương đương với một rangemệnh đề, tạo ra một bản sao nhưng giảm thiểu kiểm tra giới hạn lát, là:

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

Tôi sẽ điều chỉnh đề xuất cuối cùng của bạn và sử dụng phiên bản phạm vi chỉ mục.

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

Nó có vẻ đơn giản hơn đối với tôi khi đề cập n.Attr[i]rõ ràng trong cả dòng kiểm tra Keyvà dòng đặt Val, thay vì sử dụng attrcho cái này và n.Attr[i]cái kia.

Ví dụ:

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

Sân chơi

Đầu ra

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

Cách tiếp cận khác:

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

Sân chơi

Đầu ra:

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