如何在嵌套R6对象中避免重复计算？

嘿，你提到Hadley Wickham在《Mastering Shiny》里说的那段话太对了——普通函数每次调用都重新计算（像太烫的粥），而响应式表达式只在依赖变化时才计算。你的多层嵌套R6对象现在就遇到了这个“粥太烫”的问题，下面几个实用方案能帮你解决重复计算的痛点：

方案1：手动实现缓存与依赖追踪（最灵活） #

我们可以给需要缓存结果的R6对象添加私有成员，用来存储缓存的结果、记录依赖数据的状态（比如哈希值或者版本号）。每次调用方法时，先检查依赖数据有没有变化，没变就直接返回缓存，变了再重新计算并更新缓存。

修改你的示例代码如下：

library(R6)
library(digest) # 需要先安装：install.packages("digest")

# 1. 定义数据帧对象（实际场景中get_df会动态变化）
df_object <- R6Class(
  classname = "df_object",
  public = list(
    get_df = function() {
      return(iris) # 实际中这里可能是动态生成的数据集
    },
    # 新增：获取数据的哈希值，用来判断数据是否变化
    get_df_hash = function() {
      digest::digest(self$get_df())
    }
  )
)

# 2. 定义带缓存的摘要对象
summary_object <- R6Class(
  classname = "summary_object",
  private = list(
    df = NULL,
    cached_summary = NULL, # 存储缓存的摘要结果
    last_df_hash = NULL    # 记录上次数据的哈希值
  ),
  public = list(
    initialize = function() {
      private$df <- df_object$new()
    },
    get_summary = function() {
      # 获取当前数据的哈希值
      current_hash <- private$df$get_df_hash()
      # 如果缓存不存在，或者数据哈希值变化了，重新计算
      if (is.null(private$cached_summary) || current_hash != private$last_df_hash) {
        message("重新计算摘要...") # 测试用：打印是否触发计算
        private$cached_summary <- summary(private$df$get_df())
        private$last_df_hash <- current_hash
      }
      return(private$cached_summary)
    }
  )
)

# 测试效果
test <- summary_object$new()
test$get_summary() # 第一次调用：打印"重新计算摘要..."并返回结果
test$get_summary() # 第二次调用：直接返回缓存，不会打印信息

如果你的数据对象本身有可以标记变化的属性（比如手动维护的版本号），可以用它代替哈希值，效率会更高。

方案2：用memoise包快速添加缓存 #

memoise包可以帮我们给函数自动添加缓存功能，不用手动维护状态，代码更简洁。需要注意的是，R6对象的方法绑定在实例上，我们要把计算逻辑封装成一个可缓存的私有函数：

library(R6)
library(memoise) # 需要先安装：install.packages("memoise")

df_object <- R6Class(
  classname = "df_object",
  public = list(
    get_df = function() {
      return(iris)
    }
  )
)

summary_object <- R6Class(
  classname = "summary_object",
  private = list(
    df = NULL,
    # 把摘要计算逻辑封装成可缓存的函数
    compute_summary = memoise(function(df_data) {
      message("重新计算摘要...")
      summary(df_data)
    })
  ),
  public = list(
    initialize = function() {
      private$df <- df_object$new()
    },
    get_summary = function() {
      # 传入数据作为缓存的判断依据
      private$compute_summary(private$df$get_df())
    },
    # 新增：手动清除缓存（比如已知数据变化但缓存没自动更新时）
    clear_cache = function() {
      forget(private$compute_summary)
    }
  )
)

# 测试效果
test <- summary_object$new()
test$get_summary() # 第一次计算
test$get_summary() # 直接用缓存

这个方案的缺点是：如果你的数据集很大，生成缓存键的成本会偏高，这时候方案1的哈希/版本号方式会更高效。

方案3：主动式依赖通知（贴近Shiny响应式逻辑） #

如果你的数据是通过特定方法修改的（不是直接修改底层变量），可以给数据对象添加“观察者”机制：当数据变化时，主动通知依赖它的对象清除缓存。这种方式能实现精准的缓存失效，避免每次检查哈希的开销：

library(R6)

df_object <- R6Class(
  classname = "df_object",
  private = list(
    df = iris,
    observers = list() # 存储依赖这个数据的观察者对象
  ),
  public = list(
    get_df = function() {
      return(private$df)
    },
    # 实际场景中修改数据的方法，修改后通知所有观察者
    update_df = function(new_df) {
      private$df <- new_df
      lapply(private$observers, function(obs) obs$on_data_change())
    },
    # 添加观察者（依赖此数据的对象）
    add_observer = function(obs) {
      private$observers <- c(private$observers, obs)
    }
  )
)

summary_object <- R6Class(
  classname = "summary_object",
  private = list(
    df = NULL,
    cached_summary = NULL
  ),
  public = list(
    initialize = function(df_obj) {
      private$df <- df_obj
      private$df$add_observer(self) # 注册为观察者
    },
    get_summary = function() {
      if (is.null(private$cached_summary)) {
        message("重新计算摘要...")
        private$cached_summary <- summary(private$df$get_df())
      }
      return(private$cached_summary)
    },
    # 响应数据变化：清除缓存
    on_data_change = function() {
      private$cached_summary <- NULL
    }
  )
)

# 测试效果
df_inst <- df_object$new()
test <- summary_object$new(df_inst)

test$get_summary() # 第一次计算
test$get_summary() # 用缓存

# 修改数据，触发缓存清除
df_inst$update_df(iris[1:10, ])
test$get_summary() # 重新计算

总结 #

• 如果数据变化难以追踪，优先选方案1或方案2；
• 如果数据是通过受控方法修改的，方案3的主动通知机制效率更高；
• 你可以把这个缓存逻辑逐层应用到嵌套的R6对象上，就能大幅减少不必要的重复计算，节省时间和算力。

内容来源于stack exchange