programming - shiny app r tutorial

Brillante: ¿cuál es la diferencia entre observeEvent y eventReactive?

Question

Leí la documentación de Shiny sobre programación reactiva algunas veces, pero no puedo entender correctamente la diferencia entre observeEvent y eventReactive .

La documentación dice:

Use observeEvent siempre que desee realizar una acción en respuesta a un evento. (Tenga en cuenta que "recalcular un valor" generalmente no cuenta como realizar una acción; vea eventReactive para eso).

....

Use eventReactive para crear un valor calculado que solo se actualice en respuesta a un evento. Esto es como una expresión reactiva normal, excepto que ignora todas las invalidaciones habituales que provienen de sus dependencias reactivas;

En toda la situación que probé, no vi ninguna diferencia entre el uso de observeEvent y eventReactive (el código funciona bien independientemente de la función que use, sin impacto aparente en las actuaciones).

¿Me pueden ayudar a descubrir cuál es la verdadera diferencia entre los dos? Idealmente, me gustaría algunos ejemplos que muestren cuándo son intercambiables, uno cuando observeEvent funcionaría pero no eventReactive y viceversa.

Answer 1

Como @daatali dice, las dos funciones se usan para diferentes propósitos.

ui <- shinyUI(pageWithSidebar(
  headerPanel("eventReactive and observeEvent"),
  sidebarPanel(
    actionButton("evReactiveButton", "eventReactive"),
    br(),
    actionButton("obsEventButton", "observeEvent"),
    br(),
    actionButton("evReactiveButton2", "eventReactive2")
  ),
  mainPanel(
    verbatimTextOutput("eText"),
    verbatimTextOutput("oText")
  )
))

server <- shinyServer(function(input, output) {
  etext <- eventReactive(input$evReactiveButton, {
    runif(1)
  })
  observeEvent(input$obsEventButton,{
    output$oText <- renderText({ runif(1) })
  })
  eventReactive(input$evReactiveButton2,{
    print("Will not print")
    output$oText <- renderText({ runif(1) })
  })
  output$eText <- renderText({
    etext()
  })
})

shinyApp(ui=ui,server=server) 

eventReactive crea un valor reactivo que cambia según el eventExpr mientras observeEvent simplemente se activa según eventExpr

Answer 2

Creo que los aspectos prácticos de nivel superior deben enfatizarse aquí.

• Un eventReactive crea un objeto que usted define como reactive , pero sin el comportamiento habitual de reacción en cadena que obtiene de reactive . Sin embargo, es vagamente evaluado y almacenado en caché como los otros reactives .

• observeEvent no puede crear un objeto que usted defina (crea algo más). Se evalúa inmediatamente y no se almacena en caché. Es para causar efectos secundarios.

Entonces, si necesita un marco de datos, o un vector, o un gráfico o algo así, pero desea desacoplarse de las reacciones en cadena reactivas habituales, use eventReactive .

Si solo desea causar un efecto secundario inmediato, observeEvent es su boleto.

Answer 3

Es como la diferencia entre observe y reactive . Uno está destinado a ejecutarse cuando alguna variable reactiva se "dispara" y debe tener efectos secundarios ( observeEvent ), y el otro devuelve un valor reactivo y debe usarse como una variable ( eventReactive ). Incluso en la documentación para esas funciones, la primera se muestra sin ser asignada a una variable (porque está destinada a producir un efecto secundario), y la segunda se muestra asignada a una variable y se usa más adelante.

Answer 4

Proporcionando la forma en que entiendo esto, corrígeme y agrega más información según sea necesario. La mayor parte de la información es de https://shiny.rstudio.com/articles/action-buttons.html

• También puede ser que esto se haya preguntado hace mucho tiempo, tuve la misma pregunta al pasar por eventReactive () y observeEvent ()
• ObeserveEvent, siendo más como un desencadenante de un evento mientras eventReactive, siendo más como un retraso
• A continuación intento el mismo código, usando ambas funciones reactivas

Para crear varios botones de acción que controlen el mismo objeto, combine las llamadas a observeEvent () con reactiveValues ​​(). Aquí puedo usar dos botones de acción que funcionan al mismo tiempo en el mismo código.

Code.1 Da el efecto de observeElement ()

Código.2 Usa eventReactive (), pero si trato de usar dos actionButtons diferentes, solo el último funciona, el botón anterior es nulo y no reaccionó

• Código 1

      library(shiny)
  
      ui<-fluidPage(
        actionButton("runif", "uniform"),
        actionButton("rnorm", "Normal"),
        hr(),
        plotOutput("plot")
      )
  
      server<-function(input, output){
        v<-reactiveValues(data=NULL)
  
        observeEvent(
          input$runif,
          {
          v$data<-runif(100)
          }
        )
  
        observeEvent(
          input$rnorm,
          {
          v$data<-rnorm(100)
          }
        )
  
        output$plot <- renderPlot(
          {
            if (is.null(v$data)) return()
            hist(v$data)
          }
        )
      }
  
  shinyApp(ui, server)

• código2

     library(shiny)
  
     ui<-fluidPage(
      actionButton(inputId = "norm", label = "Normal"),
      actionButton(inputId = "unif", label = "Uniform"),
  
    #Normal
    plotOutput("hist")
  )
  
  server <- function(input, output) {
  
    dnorm <- eventReactive(input$norm, {rnorm(100)})
    dunif <- eventReactive(input$unif, {runif(100)})
  
    output$hist <- renderPlot({  
      hist(dfnorm())
    })
  
    output$hist <- renderPlot({  
      hist(dunif())
    })
  }
  
  shinyApp(ui, server)