修改接收器的数值属性？

**接收器数值属性的修改** 在 Go 语言中，根据值定义的方法无法修改接收器的内容。然而，如果接收器是引用类型，如切片，则可以修改其内容。这是因为切片本质上是引用类型，指向底层数组。因此，即使接收器是值的副本，它仍然可以访问和修改底层数组。 修改接收器内容的经典示例是 set 方法，它允许修改切片中的元素。尽管 set 方法接收接收器的副本，但它可以修改底层数组，因为副本仍然指向相同的底层数组。这使得 set 方法能够修改接收器的内容，即使它是由值定义的。

package matrix

import (
    "errors"
    "strconv"
    "strings"
)

// Matrix matrix inteface
type Matrix interface {
    Rows() [][]int
    Cols() [][]int
    Set(r, c, val int) bool
}

// matrix implements the interface Matrix
type matrix struct {
    data [][]int
    rows int
    cols int
}

// New returns a valid matrix created from the input
func New(input string) (Matrix, error) {
    var m matrix
    rows := strings.Split(input, "\n")
    for r, row := range rows {
        rowElements := strings.Fields(row)

        switch {
        case r == 0:
            m.rows, m.cols = len(rows), len(rowElements)
            matrix, err := allocateMemory(m.rows, m.cols)
            if err != nil {
                return invalidMatrix()
            }
            m.data = matrix
        case len(rowElements) != m.cols:
            return invalidMatrix()
        }

        for c, element := range rowElements {
            element, err := strconv.Atoi(element)
            if err != nil {
                return invalidMatrix()
            }
            m.data[r][c] = element
        }
    }
    return m, nil
}

// invalidMatrix returns the error indicating the
// provided matrix is invalid
func invalidMatrix() (Matrix, error) {
    return nil, errors.New("invalid matrix")
}

// allocateMemory allocates a 2D slice of int having size RxC
func allocateMemory(R, C int) ([][]int, error) {
    if R < 1 || C < 1 {
        return nil, errors.New("invalid matrix")
    }
    matrix := make([][]int, R)
    for r := range matrix {
        matrix[r] = make([]int, C)
    }
    return matrix, nil
}

// Set sets the given value at (r,c) in the matrix,
// if (r,c) belongs to the matrix.
func (m matrix) Set(r, c, val int) bool {
    switch {
    case r < 0 || c < 0:
        return false
    case r >= m.rows || c >= m.cols:
        return false
    default:
        m.data[r][c] = val
        return true
    }
}

// order defines the order the matrix to export
// two useful values are columnMajor and rowMajor
type order int

const (
    columnMajor order = iota
    rowMajor
)

// Cols returns columns of the matrix.
func (m matrix) Cols() [][]int {
    return m.export(columnMajor)
}

// Rows returns rows of the matrix.
func (m matrix) Rows() [][]int {
    return m.export(rowMajor)
}

// export return the matrix in the required order;
// either columnMajor or rowMajor.
func (m matrix) export(o order) [][]int {
    var matrix [][]int
    var err error
    switch o {
    case columnMajor:
        matrix, err = allocateMemory(m.cols, m.rows)
        if err != nil {
            return nil
        }
        for r, row := range m.data {
            for c, element := range row {
                matrix[c][r] = element
            }
        }
    case rowMajor:
        matrix, err = allocateMemory(m.rows, m.cols)
        if err != nil {
            return nil
        }
        for r, row := range m.data {
            copy(matrix[r], row)
        }
    }
    return matrix
}

我很难理解为什么方法 set() 能够修改结构的数据。我知道根据值定义的方法不能做到这一点。我试图将它与另一个问题进行比较，在另一个问题中我无法修改接收器的内容，但在这种情况下它就可以工作。此代码的测试文件可在测试文件中找到。知道我缺少什么吗？

正确答案

set之所以可以修改切片的内容是因为切片是一个参考值。您的另一个示例（在评论中）尝试分配保存切片的字段，但这不起作用 - 因为它正在处理副本。请参阅此代码示例：

package main

import (
    "fmt"
)

type holder struct {
    s []int
    v []int
}

func (h holder) set() {
    // this will successfully modify the `s` slice's contents
    h.s[0] = 99

    // this will assign a new slice to a copy of the v field,
    // so it won't affect the actual value on which this
    // method is invoked. 
    h.v = []int{1, 2, 3}
}

func main() {
    var h holder
    h.s = []int{10, 20, 30}
    h.v = []int{40, 50, 60}

    fmt.println("before set:", h)
    
    h.set()
    fmt.println("after set:", h)
}

You can run it on the playground，它打印：

before Set: {[10 20 30] [40 50 60]}
after Set: {[99 20 30] [40 50 60]}

这里发生的情况是，尽管 set 获取了 h 的副本，因此 h.s 也是一个副本，但两个副本都指向相同的底层切片，因此可以修改内容。请阅读 this post 了解所有详细信息。

理论要掌握，实操不能落！以上关于《修改接收器的数值属性？》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！