चमकदार: ObsEvent और eventReactive के बीच क्या अंतर है?

Question

मैंने कुछ बार प्रतिक्रियाशील प्रोग्रामिंग के बारे में चमकदार दस्तावेज पढ़ा है, लेकिन मैं observeEvent और eventReactive के बीच अंतर को सही ढंग से समझ नहीं सकता।

प्रलेखन कहते हैं:

उपयोग observeEvent जब भी आप एक घटना के जवाब में एक काम करवाना चाहते हैं। (ध्यान दें कि आम तौर पर उस के लिए एक कार्य देखने के eventReactive प्रदर्शन के रूप में गिनती नहीं है "एक मूल्य पुनर्गणना"।)

....

उपयोग eventReactive एक गणना मान बनाने के लिए है कि केवल एक घटना के जवाब में अपडेट । यह एक सामान्य प्रतिक्रियाशील अभिव्यक्ति की तरह है, सिवाय इसके कि यह सभी सामान्य अमान्यताओं को अनदेखा करता है जो इसकी प्रतिक्रियाशील निर्भरताओं से आते हैं;

सभी स्थिति में मैंने कोशिश की मैं observeEvent और eventReactive (कोड, ठीक परवाह किए बिना समारोह का उपयोग मैं काम करता है प्रदर्शन में कोई स्पष्ट प्रभाव के साथ) का उपयोग कर के बीच कोई अंतर देखा।

क्या आप यह समझने में मेरी सहायता कर सकते हैं कि दोनों के बीच वास्तविक अंतर क्या है? आदर्श रूप में मुझे कुछ उदाहरण दिखाना चाहिए जब वे अदला-बदले होते हैं, एक जब observeEvent काम करेगा लेकिन eventReactive और इसके विपरीत नहीं होगा।

Answer 1

जैसा कि @daatali कह रहा है कि दो कार्यों का उपयोग विभिन्न उद्देश्यों के लिए किया जाता है।

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 एक प्रतिक्रियाशील मूल्य है कि आधार पर बदलता रहता बनाता eventExpr जबकि observeEvent बस पर eventExpr

Answer 2

यह observe और reactive के बीच अंतर की तरह है। एक को चलाने के लिए इरादा किया जाता है जब कुछ प्रतिक्रियाशील चर "ट्रिगर" होता है और इसका दुष्प्रभाव होता है (observeEvent), और दूसरा एक प्रतिक्रियाशील मान देता है और इसका उपयोग एक चर (eventReactive) के रूप में किया जाता है। यहां तक ​​कि उन कार्यों के लिए प्रलेखन में, पूर्व को एक चर के लिए असाइन किए बिना दिखाया गया है (क्योंकि इसका उद्देश्य केवल साइड इफेक्ट का उत्पादन करना है), और बाद वाला को एक चर में असाइन किया गया है और बाद में उपयोग किया जाता है।

Answer 3

मुझे लगता है कि शीर्ष स्तर व्यावहारिक पहलुओं यहाँ पर जोर दिया जाना करने की जरूरत है आधारित शुरू हो रहा है।

• एक eventReactive एक वस्तु है कि reactive की तरह करता है जो आपके द्वारा निर्धारित बनाता है, लेकिन बाहर हमेशा की तरह श्रृंखला प्रतिक्रिया व्यवहार के साथ आप reactive से मिलता है। हालांकि यह अन्य reactives की तरह आलसी मूल्यांकन और कैश किया गया है।

• एक observeEvent आपके द्वारा परिभाषित ऑब्जेक्ट नहीं बना सकता है (यह कुछ और बनाता है)। इसका तुरंत मूल्यांकन किया जाता है और कैश नहीं किया जाता है। यह दुष्प्रभाव पैदा करने के लिए है।

तो अगर आप एक डेटा फ्रेम, या वेक्टर, या साजिश या कुछ और की जरूरत है, लेकिन हमेशा की तरह प्रतिक्रियाशील श्रृंखला प्रतिक्रियाओं से दसगुणा करना चाहते हैं, eventReactive का उपयोग करें।

यदि आप केवल तत्काल दुष्प्रभाव का कारण बनना चाहते हैं, तो observeEvent आपका टिकट है।

Answer 4

जिस तरह से मैं इसे समझता हूं, मुझे सही करता हूं और आवश्यकतानुसार अधिक जानकारी जोड़ता हूं। जानकारी के अधिकांश है से https://shiny.rstudio.com/articles/action-buttons.html

• भी किया इस बहुत पहले कहा गया है हो सकता है, मैं जा रहा है और अधिक एक के लिए एक ट्रिगर की तरह eventReactive() और observeEvent()
• ObeserveEvent माध्यम से जा रहा है, जबकि एक ही सवाल था घटना जबकि eventReactive, और अधिक देरी
• नीचे मैं एक ही कोड का प्रयास करें, दोनों प्रतिक्रियाशील कार्यों

का उपयोग कर कई कार्रवाई बटन है कि एक ही वस्तु को नियंत्रित निर्माण करने के लिए की तरह किया जा रहा है, जोड़ती e seeEvent() reactiveValues ​​() के साथ कॉल, यहां मैं दो एक्शनबूटन का उपयोग कर सकता हूं जो एक ही कोड में एक ही समय में काम कर रहे हैं।

Code.1 observeElement() के प्रभाव देता है

Code.2 eventReactive() का उपयोग करता है, लेकिन अगर मैं दो अलग अलग actionButtons इस्तेमाल करने की कोशिश, केवल नवीनतम एक काम करता है पहले बटन रिक्त है और प्रतिक्रिया नहीं की

• कोड 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) 
  

• code2

  +०१२३५१६४१०

  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)