isolate

isolate(expr)

Arguments

expr	An expression that can access reactive values or expressions.

Description

Executes the given expression in a scope where reactive values or expression can be read, but they cannot cause the reactive scope of the caller to be re-evaluated when they change.

Details

Ordinarily, the simple act of reading a reactive value causes a relationship to be established between the caller and the reactive value, where a change to the reactive value will cause the caller to re-execute. (The same applies for the act of getting a reactive expression's value.) The isolate function lets you read a reactive value or expression without establishing this relationship.

The expression given to isolate() is evaluated in the calling environment. This means that if you assign a variable inside the isolate(), its value will be visible outside of the isolate(). If you want to avoid this, you can use local() inside the isolate().

This function can also be useful for calling reactive expression at the console, which can be useful for debugging. To do so, simply wrap the calls to the reactive expression with isolate().

Examples

## Not run: ------------------------------------
# observe({
#   input$saveButton  # Do take a dependency on input$saveButton
# 
#   # isolate a simple expression
#   data <- get(isolate(input$dataset))  # No dependency on input$dataset
#   writeToDatabase(data)
# })
# 
# observe({
#   input$saveButton  # Do take a dependency on input$saveButton
# 
#   # isolate a whole block
#   data <- isolate({
#     a <- input$valueA   # No dependency on input$valueA or input$valueB
#     b <- input$valueB
#     c(a=a, b=b)
#   })
#   writeToDatabase(data)
# })
# 
# observe({
#   x <- 1
#   # x outside of isolate() is affected
#   isolate(x <- 2)
#   print(x) # 2
# 
#   y <- 1
#   # Use local() to avoid affecting calling environment
#   isolate(local(y <- 2))
#   print(y) # 1
# })
## ---------------------------------------------

# Can also use isolate to call reactive expressions from the R console
values <- reactiveValues(A=1)
fun <- reactive({ as.character(values$A) })
isolate(fun())
[1] "1"

# "1"

# isolate also works if the reactive expression accesses values from the
# input object, like input$x