reactive() to avoid repeated codeobserve() for side effectsreq() and validate()From Shiny I, our app had two inputs (name, var) feeding one output (plot):
Inputs Outputs
------ -------
name --------> plot
var ------/This note extends the app with a second output, shared data preparation logic, and dynamic UI updates.
reactive() — DRY reactive expressionsAs apps grow, it is common to compute the same filtered dataset in multiple render*() calls:
server <- function(input, output, session) {
output$plot <- renderPlot({
d |>
filter(name %in% input$name) |>
ggplot(...)
})
output$minmax <- renderTable({
d |>
filter(name %in% input$name) |>
summarize(...)
})
}input$name changes, Shiny re-runs both expressions — the same filtering happens twice.
reactive()reactive() creates a reactive conductor — an intermediate computation that can be shared across multiple downstream consumers:
library(tidyverse)
library(shiny)
library(bslib)
d <- read_csv("data/weather.csv")
d_vars <- c(
"Average temp" = "temp_avg",
"Min temp" = "temp_min",
"Max temp" = "temp_max",
"Total precip" = "precip",
"Wind speed" = "wind_speed"
)
ui <- page_sidebar(
title = "Weather Forecasts",
sidebar = sidebar(
radioButtons(
"name",
"Select an airport",
choices = c("Raleigh-Durham", "Denver", "Los Angeles", "JFK")
),
selectInput(
"var",
"Select a variable",
choices = d_vars,
selected = "temp_avg"
)
),
plotOutput("plot"),
tableOutput("minmax")
)
server <- function(input, output, session) {
d_city <- reactive({
d |> filter(name %in% input$name)
})
output$plot <- renderPlot({
d_city() |>
ggplot(mapping = aes(x = date, y = .data[[input$var]])) +
geom_line()
})
output$minmax <- renderTable({
d_city() |>
mutate(year = year(date) |> as.integer()) |>
summarize(
`min avg temp` = min(temp_min),
`max avg temp` = max(temp_max),
.by = year
)
})
}
shinyApp(ui = ui, server = server)reactive({...}) wraps a computation and caches its result. The expression re-executes only when input$name changes.
d_city() — note the parentheses, as if calling a function. Using d_city without parentheses returns the reactive object itself, not its value, which causes the error: Error: object of type 'closure' is not subsettable.
The reactive graph now has an intermediate node:
Inputs Conductors Outputs
------ ---------- -------
name --------> d_city -------> plot
var --------------------/
d_city -------> minmaxd_city is evaluated once when input$name changes; both plot and minmax use the cached result.
reactive() rulesserver() function, not at the top levelreactive(), render*(), or observe() calls)() — not with the bare nameobserve() — reactive side effectsA reactive conductor returns a value. An observer does not — it is used purely for its side effects. The most common side effect is updating a UI element.
Demo: add a “region” filter that dynamically updates the list of airports in the name input:
ui <- page_sidebar(
title = "Weather Forecasts",
sidebar = sidebar(
selectInput(
"region",
"Select a region",
choices = c("West", "Midwest", "Northeast", "South")
),
selectInput(
"name",
"Select an airport",
choices = c()
),
selectInput(
"var",
"Select a variable",
choices = d_vars,
selected = "temp_avg"
)
),
plotOutput("plot"),
tableOutput("minmax")
)
server <- function(input, output, session) {
observe({
updateSelectInput(
session = session,
inputId = "name",
choices = d |>
distinct(region, name) |>
filter(region == input$region) |>
pull(name)
)
})
d_city <- reactive({
d |> filter(name %in% input$name)
})
# ... render functions unchanged ...
}observe({...}) runs whenever any reactive value inside it changes. Here it reads input$region and calls updateSelectInput() to repopulate the "name" dropdown with airports in the selected region.
The updated reactive graph:
Inputs Conductors Outputs / Observers
------ ---------- -------------------
region ---------------------------------> obs (updateSelectInput)
name --------> d_city -------> plot
var --------------------/
d_city -------> minmaxobserve() rulesreactive(), must be inside server() and may only read reactive values from reactive contextsrender*() functions are observers — they update a UI output as a side effectreq()Shiny apps execute reactive expressions on initialization, often before the reader has made a selection. This can produce warnings or errors from downstream computations operating on empty or NULL inputs.
req() silently halts execution of a reactive expression if a value is not “truthy”:
d_city <- reactive({
req(input$name)
d |> filter(name %in% input$name)
})input$name is NULL, "", or an empty vector, req() stops execution silently. The output simply stays blank rather than showing an error.
In Shiny, a value is truthy if it is not NULL, not FALSE, not an empty vector, not "", and not NA:
isTruthy(TRUE)[1] TRUEisTruthy("hello")[1] TRUEisTruthy(c(1, 2, 3))[1] TRUEisTruthy(NULL)[1] FALSEisTruthy(FALSE)[1] FALSEisTruthy("")[1] FALSEisTruthy(character(0))[1] FALSEisTruthy(NA)[1] FALSEreq() vs validate()req() silently stops execution; validate() stops execution and displays an error message in the UI:
# req() — silent stop
d_city <- reactive({
req(input$name)
d |> filter(name %in% input$name)
})
# validate() — show error message
d_city <- reactive({
validate(
need(input$name, "Please select an airport")
)
d |> filter(name %in% input$name)
})need(condition, message) evaluates the condition; if it is not truthy, the message is displayed in the output area.
Use req() for initialization guards (where silence is appropriate) and validate() when the reader has provided input that fails a logical check and deserves an informative message.
bindEvent()By default, Shiny automatically detects reactive dependencies — any reactive value read inside a render*(), reactive(), or observe() becomes a dependency. To explicitly control when an expression re-executes, use bindEvent():
output$plot <- renderPlot({
d_city() |>
ggplot(aes(x = date, y = .data[[input$var]])) +
geom_line()
}) |>
bindEvent(input$update_btn)bindEvent(input$update_btn) means the plot only re-renders when the update_btn action button is clicked — not when d_city() or input$var change.
bindEvent() works with reactive(), observe(), and render*() functions. When binding a reactive object, use the functional form: d_city() not d_city.
Reactive graphs must be acyclic — no circular dependencies. Observers that update inputs can accidentally create cycles:
server <- function(input, output, session) {
observe({
updateNumericInput(inputId = "n", value = input$n + 1)
}) |>
bindEvent(input$n)
}input$n and immediately updates input$n. Each update triggers the observer again — an infinite loop. Use bindEvent() carefully and consider whether an update is truly needed.
fileInput()fileInput() lets readers upload files to the server. Before a file is uploaded, input$<id> returns NULL. After upload, it returns a data frame with one row per file:
| Column | Description |
|---|---|
name |
Original filename on the reader’s system |
size |
File size in bytes |
type |
MIME type (e.g., "text/csv") |
datapath |
Path to the temporary file on the server |
ui <- page_fluid(
fileInput("upload", "Upload a file", accept = ".csv"),
tableOutput("data")
)
server <- function(input, output, session) {
output$data <- renderTable({
req(input$upload)
ext <- tools::file_ext(input$upload$datapath)
validate(
need(ext == "csv", "Please upload a CSV file")
)
read_csv(input$upload$datapath) |> head()
})
}accept = ".csv" suggests valid file types in the file picker (not a security guarantee).
req(input$upload) prevents execution before any file is uploaded.
validate() checks the file extension and shows a message if it is wrong.
input$upload$datapath is the server-side path to the uploaded file.
Key points: - datapath points to a temporary location — treat it as ephemeral; new uploads may overwrite previous files - Always validate uploaded file content — the accept argument is a UI hint, not a server-side filter - Anywhere that previously used the static d object must use d() if it becomes a reactive
AE 22: Building a Shiny weather app
reactive({...}) creates a reactive conductor — a cached, shared computation used by multiple downstream outputs. Always access its value with object(), not object.observe({...}) is used for side effects only (e.g., updateSelectInput()). It returns no value.req() silently halts execution if an input is not truthy; validate() / need() halts execution and displays an error message to the reader.downloadButton() + downloadHandler() enable file downloads; fileInput() enables file uploads.bindEvent() lets you explicitly specify which inputs trigger a reactive expression.Material derived in part from posit::conf 2025 - Shiny for R Workshop by Colin Rundel (CC BY 4.0) and Advanced Data Visualization.