कैसे एक चमकदार घटना के भीतर एक से अधिक घटना अभिव्यक्ति के लिए सुनने के लिए

Question

मैं अपने ऐप में विभिन्न प्लॉट / आउटपुट द्वारा उपयोग किए जा रहे डेटा के अपडेट को ट्रिगर करने के लिए दो अलग-अलग ईवेंट चाहता हूं। एक बटन पर क्लिक किया जा रहा है ( input$spec_button) और दूसरा एक बिंदु पर क्लिक किया जा रहा है ( mainplot.click$click) है।

असल में, मैं एक ही समय में दोनों के लिए सूचीबद्ध करना चाहता हूं, लेकिन मुझे यकीन नहीं है कि कोड कैसे लिखना है। यहाँ अब मेरे पास क्या है:

server.R में:

data <- eventReactive({mainplot.click$click | input$spec_button}, {
    if(input$spec_button){
      # get data relevant to the button
    } else {
      # get data relevant to the point clicked
    }
  })

लेकिन अगर-और क्लॉज काम नहीं करता है

Error in mainplot.click$click | input$spec_button : operations are possible only for numeric, logical or complex types

-> क्या कुछ प्रकार के एक्शन-कॉम्बिनेटर फ़ंक्शन हैं जो मैं mainplot.click$click | input$spec_buttonक्लॉज के लिए उपयोग कर सकता हूं ?

Comments

क्या आप .null (इनपुट $ spec_button) का आउटपुट चेक कर सकते हैं?

— गोपाला

Answer 1

मुझे पता है कि यह पुराना है, लेकिन मेरा भी यही सवाल था। मुझे अंत में यह समझ आ गया। आप ब्रेसिज़ में एक अभिव्यक्ति शामिल करते हैं और बस घटनाओं / प्रतिक्रियाशील वस्तुओं को सूचीबद्ध करते हैं। मेरा (असंदिग्ध) अनुमान यह है कि चमकदार बस एक मानक reactiveब्लॉक के रूप में इस अभिव्यक्ति ब्लॉक के लिए एक ही प्रतिक्रियाशील सूचक विश्लेषण करता है ।

observeEvent({ 
  input$spec_button
  mainplot.click$click
  1
}, { ... } )

संपादित करें

उस मामले को संभालने के लिए अपडेट किया गया है जहां अभिव्यक्ति में अंतिम पंक्ति NULL देता है। बस एक स्थिर मान लौटाएं।

Comments

इसे स्वीकार करने का उत्तर बदलना क्योंकि यह मेरे मूल समाधान से बेहतर समाधान है।

— हिलेरी सैंडर्स

क्या आप पहचान सकते हैं कि किस घटना को ट्रिगर किया गया था?

— पीटरवर्मोंट

यह नही है कि मैं जानता हूँ। मैंने कुछ मामलों में उन्हें अलग-अलग चरों में ट्रैक करके और खुद की तुलना करके यह देखने के लिए किया है कि जो बदल गया है। लेकिन यह बदसूरत है। संभवतः किसी फ़ंक्शन में मुख्य कोड डालने के लिए बेहतर है, फिर दो अवलोकन करें जो fn को कॉल करते हैं और फिर प्रत्येक घटना के लिए विशिष्ट सामान करते हैं।

— डंकन ब्राउन

बस एक चेतावनी: डिफ़ॉल्ट रूप से observeEventउपयोग करता ignoreNULL = TRUEहै, जिसका अर्थ है अगर mainplot.click$click(वापसी मूल्य) है NULL, तो हैंडलर को कभी भी नहीं input$spec_buttonबदला जाएगा। मैं इस जाल में गिरने से रोकने के लिए @ JustAnother के उत्तर जैसा कुछ सुझाऊंगा।

— greg एल

एक और चेतावनी: मेरे परीक्षण में मैंने पाया कि यह ब्रैकेट सिंटेक्स ( {}) प्रत्येक घटना को अपनी नई सीमा पर होने की पुष्टि करता है, अन्यथा यह "पार्स में त्रुटि ..." के साथ विफल होता है जैसे ही पार्सर दूसरी घटना का सामना करता है। उदाहरण के लिए, एक पंक्ति में सभी: observeEvent({input$spec_button mainplot.click$click}, {...})विफल रहता है। @ S3 जेनेरिक कंबाइन सिंटैक्स ( c()) का उपयोग करके JustAnother का जवाब नई कहानियों की परवाह किए बिना काम करता है।

— ब्रायन डी

Answer 2

इसके अलावा:

observeEvent(c( 
  input$spec_button,
  mainplot.click$click
), { ... } )

Comments

हालांकि यह @DuncanBrown के उत्तर के समान दिखता है, मुझे ऐसी स्थिति मिली जहां 2 एक्शन बटन दोनों एक मोडल को ट्रिगर करते हैं, यह काम करता है, और {संस्करण नहीं हुआ। मैं ऐसा क्यों है के लिए हिसाब नहीं कर सकते।

— जॉन पॉल

@Duncan Brown के जवाब में एक टिप्पणी जोड़ी कि यह उत्तर अलग कैसे है (और बेहतर IMO)

— greg L

यह मेरे लिए काम नहीं करता है - मुझे एक त्रुटि मिलती है (चमकदार 1.0.5)

— पोटॉकैन

क्या यह पता लगाने का एक तरीका है कि किस घटना को ट्रिगर किया गया था? मान लें कि मेरे पास दो बटन हैं, input$button1और input$button2यह बहुत ही समान चीजें हैं, बस एक अलग सूचकांक के साथ। मैं कोड को कई बार कॉपी करने से बचना चाहूंगा क्योंकि मैं सूचकांक नहीं जानता। धन्यवाद!

— निकोस बोस

Answer 3

मैंने इस मुद्दे को एक प्रतिक्रियाशील वस्तु बनाने के साथ हल किया है और इसे घटना परिवर्तन अभिव्यक्ति में उपयोग करें। नीचे के अनुसार:

xxchange <- reactive({
paste(input$filter , input$term)
})

output$mypotput <- eventReactive( xxchange(), {
...
...
...
} )

Comments

यह एक बहुत अच्छा जवाब है जो अधिक स्पष्टीकरण से लाभान्वित हो सकता है। जबकि स्वीकृत उत्तर अधिक सीधा है, यह अल्पविकसित कार्यक्रमों के लिए बेहतर है, यह उत्तर बड़े और जटिल कोड के लिए बेहतर है। उत्तर से दो अंक गायब प्रतीत होते हैं (1) पेस्ट (या सूची) दो घटनाओं को एक ही पंक्ति में रखता है जिससे कोड अधिक कॉम्पैक्ट हो जाता है। (२) प्रतिक्रियात्मक वस्तु समान घटनाओं के एक ही सेट के लिए एक से अधिक श्रोता सुन रहा है तो एक ही दो घटनाओं को दोहराने के प्रयास को बचाता है।

— कृषक

Answer 4

यहां मैं इसका समाधान कर रहा हूं: मूल रूप से, एक खाली reactiveValuesडेटा धारक बनाएं , और फिर दो अलग-अलग observeEventउदाहरणों के आधार पर इसके मूल्यों को संशोधित करें ।

  data <- reactiveValues()
  observeEvent(input$spec_button, {
    data$data <- get.focus.spec(input=input, premise=premise, 
                                itemname=input$dropdown.itemname, spec.info=spec.info)
  })
  observeEvent(mainplot.click$click, {
    data$data <- get.focus.spec(input=input, premise=premise, mainplot=mainplot(),
                                mainplot.click_focus=mainplot.click_focus(),
                                spec.info=spec.info)  
  })

Comments

list(mainplot.click$click, input$spec_button)ओपी के रास्ते के लिए भी काम करेगा ।

— जॉन

Answer 5

यह अभी भी घटना के साथ किया जा सकता है। केवल एक वेक्टर में अपने कार्यों को रखकर।

eventReactive(
  c(input$spec_button, mainplot.click$click), 
{ ... } )

Answer 6

यहां विचार एक प्रतिक्रियाशील फ़ंक्शन बनाने के लिए है जो उस स्थिति को निष्पादित करेगा जिसे आप अवलोकन में पास करना चाहते हैं और फिर आप बयान की वैधता की जांच करने के लिए इस प्रतिक्रियाशील फ़ंक्शन को पारित कर सकते हैं। उदाहरण के लिए:

validate_event <- reactive({
    # I have used OR condition here, you can use AND also
    req(input$spec_button) || req(mainplot.click$click)
})

observeEvent(validate_event(), 
    { ... } 
)

कोडिंग रखें!