大家好，今天本人给大家带来文章《有效地处理结构状态错误的方法》，文中内容主要涉及到，如果你对Golang方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

所以我刚刚接触 go，并且正在尝试干净地处理 go-way 中的错误。一个结果是拥有一个 type movie struct 以及更新记录并同步到数据存储的方法。一个示例方法：

func (movie movie) settitle(title string) : error {
    prevtitle := movie.title
    movie.title = title
    json, err := json.marshal(movie)
    if (err != nil) {
        movie.title = prevtitle
        return err
    }

    err = db.setvalue(movie.id, json)
    if (err != nil) {
        movie.title = prevtitle
        return err
    }

    return nil
}

上面的问题是失败操作的“清理”是保存以前的状态，并根据需要进行恢复。但这感觉非常难以维护——将来很容易进行新的错误检查，但没有经过适当的清理就返回。如果进行多次这样的“清理”，情况会变得更糟。

因此，相比之下，在其他语言中，我会将整个位包装在 try/catch 中，并在单个 catch 块内处理清理。在这里，我可以：

1. 创建 movie 的副本，在副本上执行所有操作，然后仅在一切成功后复制回原始对象
2. 将逻辑更改为：

if json, err := json.Marshal(movie); err == nil {
  if err = db.SetValue(...); err == nil {
    return nil
  }
}

movie.Title = prevTitle;
return err

这可行，但我不喜欢每个检查都有一定程度的嵌套。

1. 更改错误返回以指示它已在本地更新，但未保存
2. 按照上述说明进行操作
3. 将保存逻辑分解为 func update() ：err 函数，以最大限度地减少所需检查的数量（只是想到这一点 - 我想我喜欢这个）

我觉得这些都不是完美的；我错过了一些明显的东西吗？

解决方案

更新

你坚持的方式可能会导致许多问题：

• 你可以不断地改变原始对象
• 在一种方法中混合不同的层，这会使代码非常脆弱
• 方法，做得太多

我建议，将更新和持久性分开。 Playground

type movie struct {
    id    int
    title string
}

func (m *movie) persist() error {
    json, err := json.marshal(m)
    if err != nil {
        return err
    }

    log.printf("storing in db: %s", json)

    return nil
}

func main() {
    m := &movie{1, "matrix"}
    m.title = "iron man"

    if err := m.persist(); err != nil {
        log.fatalln(err)
    }

}

旧答案

在您的示例中，您使用按值接收器。在这种情况下，您在方法中获得了结构体的副本，您可以自由修改该副本，但所有更改都不会在外部可见。

func (movie movie) settitlevaluesemantic(title string) error {
    movie.title = title
    json, err := json.marshal(movie)
    if err != nil {
        return err
    }

    log.printf("serialized: %s", json)

    return nil
}

游戏轮：https://play.golang.org/p/mVnQ66TCaG9

我强烈建议避免这种编码风格。 如果您确实需要此类内容，请参阅以下示例以获取灵感：

演示：https://play.golang.org/p/rHacnsRLkEE

func (movie *movie) settitle(title string) (result *movie, e error) {
    moviecopy := new(movie)
    *moviecopy = *movie
    result = movie

    defer func() {
        if e != nil {
            result = moviecopy
        }
    }()

    movie.title = title
    serialized, e := json.marshal(movie)
    if e != nil {
        return
    }

    log.printf("serialized: %s", serialized)

    return
}

alexey 是正确的，但如果 movie 结构体具有指针或切片字段，则不会复制它们。

这是一个在每次更新之前手动复制切片字段（tags）的示例，并且还具有一个很好的事务方法（update）我认为您可以使用：

type Movie struct {
    id int
    Title string
    Year int
    Tags []string
}

func (m *Movie) update(fn func(m *Movie) error) error {
    // Make a copy of Movie.
    movieCopy := *m

    // Manually copy slice and pointer fields.
    movieCopy.Tags = make([]string, 0, len(m.Tags))
    copy(movieCopy.Tags, m.Tags)

    // Run the update transaction on the copy.
    if err := fn(&movieCopy); err != nil {
        return err
    }

    // Save to db.
    data, err := json.Marshal(movieCopy)
    if err != nil {
        return err
    }
    return db.SetValue(m.id, data)
}

func (m *Movie) SetTitle(title string) error {
    m.update(func(mm *Movie) error {
        mm.Title = title
        return nil
    })
}

func (m *Movie) SetYear(year int) error {
    m.update(func(mm *Movie) error {
        mm.Year = year
        return nil
    })
}

好了，本文到此结束，带大家了解了《有效地处理结构状态错误的方法》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！