R语言R6类中变量原地修改（in place）失效的技术咨询

Hey there! I’ve run into this exact issue with R6 and in-place modifications before—let’s walk through why it’s happening and how to fix it.

First, let’s replicate your minimal example so everyone can see the problem clearly:

library(R6)
library(pryr) # For checking memory addresses

# Working in-place modification outside R6
x <- matrix(1:4, 2, 2)
cat("Outside class - initial address:", address(x), "\n")
x[1,1] <- 99
cat("Outside class - modified address:", address(x), "\n") # Address stays the same

# Broken in-place modification inside R6
MyClass <- R6Class("MyClass",
  public = list(
    x = NULL,
    initialize = function(x) {
      self$x <- x
    },
    modify_x = function() {
      cat("Inside method - initial address:", address(self$x), "\n")
      self$x[1,1] <- 99
      cat("Inside method - modified address:", address(self$x), "\n")
    }
  )
)

obj <- MyClass$new(matrix(1:4, 2, 2))
cat("Outside class - initial address:", address(obj$x), "\n")
obj$modify_x()
cat("Outside class - modified address:", address(obj$x), "\n") # Address changes!

Why This Happens #

The root cause is how R6 handles property access. When you call self$x inside an R6 method, R6 doesn’t return a direct reference to the original object stored in the class. Instead, it creates a copy of the value. Any changes you make to this copy are then written back to self$x as a brand new object—which explains the shifted memory address.

Outside the class, accessing obj$x lets you interact directly with the object stored in the R6 instance’s environment, so modifications happen in-place (for reference types like matrices, lists, etc.).

Fixes for In-Place Modifications in R6 #

1. Directly Access the R6 Encapsulated Environment

Skip R6’s property getter by reaching directly into the class’s internal environment. For public variables, use self$.__enclos_env__$public$[var_name]:

MyClassFixed <- R6Class("MyClassFixed",
  public = list(
    x = NULL,
    initialize = function(x) {
      self$x <- x
    },
    modify_x = function() {
      # Grab the original reference straight from the public environment
      x_ref <- self$.__enclos_env__$public$x
      cat("Inside method - initial address:", address(x_ref), "\n")
      x_ref[1,1] <- 99
      cat("Inside method - modified address:", address(x_ref), "\n")
    }
  )
)

obj_fixed <- MyClassFixed$new(matrix(1:4, 2, 2))
cat("Outside class - initial address:", address(obj_fixed$x), "\n")
obj_fixed$modify_x()
cat("Outside class - modified address:", address(obj_fixed$x), "\n") # Address stays the same!

2. Use Private Variables

If your variable doesn’t need public access, store it in the private block. R6 doesn’t create copies when accessing private variables via private$[var_name], so modifications happen directly in-place:

MyClassPrivate <- R6Class("MyClassPrivate",
  private = list(
    .x = NULL # Dot prefix is a common R6 convention for private variables
  ),
  public = list(
    initialize = function(x) {
      private$.x <- x
    },
    modify_x = function() {
      cat("Inside method - initial address:", address(private$.x), "\n")
      private$.x[1,1] <- 99
      cat("Inside method - modified address:", address(private$.x), "\n")
    },
    # Optional getter method if you need to access the variable externally
    get_x = function() {
      private$.x
    }
  )
)

obj_private <- MyClassPrivate$new(matrix(1:4, 2, 2))
cat("Outside class - initial address:", address(obj_private$get_x()), "\n")
obj_private$modify_x()
cat("Outside class - modified address:", address(obj_private$get_x()), "\n") # Address stays the same

Quick Note on R’s In-Place Limits #

Keep in mind that not all R types support true in-place modification:

• Atomic vectors (numeric, integer, character, etc.) use value semantics—any change will create a new object, even outside R6.
• Reference types (matrices, arrays, lists, environments) allow in-place edits of their elements, which is where these fixes will shine for your numerical computation use case.

内容的提问来源于stack exchange，提问作者Peter Clark