React: [छाता] सस्पेंस जारी करना

बेनकाब unstable_AsyncMode (शायद?)

क्या यह पहले से ही उजागर नहीं है ?

मेरा मतलब था unstable_ हटा दें

मैं अनाम कोड-विभाजन पुस्तकालय के स्रोत को

इसका क्या मतलब है [छाता]?🤔☂️

इसका मतलब है, यह एक ऐसी सुविधा है जो कई परियोजनाओं/पैकेजों/उपकरणों को प्रभावित करती है।

@ घोलियर मैं देख रहा हूँ, बहुत बहुत धन्यवाद!

अरे @acdlite , बस एक सवाल है कि इसके लिए सबसे अच्छी तैयारी कैसे करें। किसी भी प्रकार की टाइमलाइन की मांग/उम्मीद नहीं, बल्कि सोच रहा था:

क्या आप वर्तमान में इन सुविधाओं को रिएक्ट 16 में छोड़ने की उम्मीद कर रहे हैं और नए संदर्भ एपीआई की तरह वृद्धिशील रूप से अपनाना आसान हो सकता है जो 16.3 के साथ उतरा है?

या आप सोच रहे हैं कि यह कुछ ऐसा होगा जो रिएक्ट को v17 पर धकेलता है और अपनाने के लिए अधिक काम की आवश्यकता होती है?

पूछ रहा हूं क्योंकि मैं एक रोडमैप पर काम कर रहा हूं जो आपकी सूची में बहुत अधिक सब कुछ के साथ महत्वपूर्ण रूप से पार करता है और यह पता लगाने की कोशिश कर रहा है कि इससे कैसे निपटें।

इसके अलावा, क्या आपके पास सबसे अच्छी तैयारी करने के बारे में कोई सुझाव है (आज लिखे गए कोड के संदर्भ में, जो भविष्य में इन सुधारों के साथ प्रतिक्रिया के अनुकूल होना चाहता है) - पॉलीफिल/तकनीक/आदि?

(क्षमा करें यदि इन प्रश्नों का उत्तर कहीं और दिया गया है और मैंने उन्हें याद किया है)

@JedWatson के प्रश्नों में एक और प्रश्न जोड़ना:

• हमें एक स्थिर रिलीज के लिए समयरेखा प्राप्त करने की आवश्यकता नहीं है/उम्मीद है, लेकिन क्या यह एक नया प्रीरिलीज प्राप्त करना संभव/उपयोगी होगा? (AFAIK नवीनतम रिलीज फरवरी से 16.4.0-alpha.0911da3 है।)

आपको धन्यवाद! ❤️

IMO, वे पहले की तरह एक ब्लॉग पोस्ट को लैंड करने से पहले प्रदान करेंगे।

और मुझे लगता है कि आपको बहुत अधिक तैयारी करने की आवश्यकता नहीं है क्योंकि कोई ब्रेकिंग परिवर्तन नहीं है (इसमें कई विशेषताएं हैं जो शायद वर्तमान प्रथाओं के साथ अलग/संघर्ष प्रतीत होती हैं, जैसे रेडक्स सस्पेंस के साथ लाती है, लेकिन एक कोडमोड या आसान एनकैप्सुलेशन होगा ऐसा करने के लिए, आप जानते हैं, fb में 3W+ घटक हैं)। और यदि आप @acdlite (ZEIT में @gaearon (आइसलैंड में क्लाइंट सस्पेंस के बारे में) की बात देखते हैं, तो आपको पता चल जाएगा कि आपको बहुत अधिक चिंता करने की आवश्यकता नहीं है और यह आक्रामक नहीं है।

वैसे, आप रेपो में बस 'अम्ब्रेला' कुंजी खोज सकते हैं और आपको #8830 और #12152 जैसी और जानकारी मिलेगी।

AFAIK फरवरी से नवीनतम रिलीज 16.4.0-alpha.0911da3 है।

आईआईआरसी, यह एक गलत संचालन है?

@JedWatson इस टिप्पणी ने मुझे यह समझने में मदद की कि एक डेवलपर को यह सुनिश्चित करने में सहायता के लिए क्या करना चाहिए कि उनका एप्लिकेशन एसिंक सुरक्षित है ।

मैं फेसबुक में सस्पेंस मॉड्यूल और नए एपीआई को रोल आउट करने पर काम कर रहा हूं। यदि @acdlite किसी और चीज़ में व्यस्त है, तो मैं अपने अनुभव के बारे में अपने कुछ विचार फ़ेसबुक पर साझा करना चाहता हूँ और @JedWatson के कुछ सवालों के जवाब देना चाहता हूँ।

क्या आप वर्तमान में इन सुविधाओं को रिएक्ट 16 में छोड़ने की उम्मीद कर रहे हैं और नए संदर्भ एपीआई की तरह वृद्धिशील रूप से अपनाना आसान हो सकता है जो 16.3 के साथ उतरा है?

मुझे यकीन नहीं है कि यह रिएक्ट 16 या 17 के साथ आएगा। रिएक्ट टीम के अनुसार, यह इस साल के अंत से पहले जारी होने की संभावना है, जो इस बात पर निर्भर करता है कि यह फेसबुक पर कितना अच्छा चलता है और संबंधित एपीआई कैसे तैयार है या नहीं। लेकिन कोड-वार, मुझे यह कहते हुए खुशी हो रही है कि इसे अपनाना आसान होगा, क्योंकि हम फेसबुक में काफी समय से प्रयोग कर रहे हैं। सस्पेंस फीचर अभी भी मौजूदा कोडबेस के लिए काम करेगा। लेकिन अतिरिक्त परिवर्तनों (जैसे async रेंडरिंग) के साथ, आपके पास अधिक बोनस होगा जो नई सुविधा आपके लिए लाएगी।

क्या आपके पास सबसे अच्छी तैयारी करने के बारे में कोई सुझाव है (आज लिखे गए कोड के संदर्भ में, जो भविष्य में इन सुधारों के साथ प्रतिक्रिया के अनुकूल होना चाहता है) - पॉलीफिल/तकनीक/आदि?

मैं कहूंगा कि प्रवासन वृद्धिशील और प्रगतिशील है। जैसे @NE-SmallTown ने कहा, हम कोई महत्वपूर्ण बदलाव नहीं लाना चाहते हैं। फेसबुक पर रोल आउट करना भी दर्दनाक होगा क्योंकि हमारे पास इतना बड़ा कोडबेस है। लेकिन अब तक, रोल आउट सुचारू रहा है और इसके लिए आपको अतिरिक्त परिवर्तन करने की आवश्यकता नहीं है।

@ जेड वाटसन

क्या आप वर्तमान में इन सुविधाओं को रिएक्ट 16 में छोड़ने की उम्मीद कर रहे हैं और नए संदर्भ एपीआई की तरह वृद्धिशील रूप से अपनाना आसान हो सकता है जो 16.3 के साथ उतरा है?

वृद्धिशील रूप से। हमेशा वृद्धिशील :) अन्यथा ऐसा कोई तरीका नहीं है जिससे हम इसे Facebook पर भेज सकें।

यहाँ मैं क्या उम्मीद कर रहा हूँ:

| | ग्राहक | सर्वर-साइड प्रतिपादन |
|----------------------------|----------------------------|-- ------------------------------------------|
| सस्पेंस | हर जगह काम करता है* | मौजूदा सर्वर रेंडरर के समान बाधाएं |
| अतुल्यकालिक प्रतिपादन | <AsyncMode> का उपयोग करके ऑप्ट-इन करें | मौजूदा सर्वर रेंडरर के समान बाधाएं |

*सिंक मोड में, delayMs हमेशा 0 । प्लेसहोल्डर तुरंत दिखाई देते हैं।

सस्पेंस आपके मौजूदा घटकों में बिना किसी बदलाव के काम करेगा। एक बिंदु पर हमने सोचा था कि हमें <StrictMode> संगतता की आवश्यकता हो सकती है, लेकिन हमारे आंतरिक परीक्षण के दौरान हमने सस्पेंस का उपयोग करने के लिए सख्त मोड में अपग्रेड करने के सर्वोत्तम तरीकों में से एक की खोज की। मुर्गी-अंडे की दुविधा। इसलिए हमने इसे सख्त मोड के बाहर भी काम करने का एक तरीका ढूंढ लिया।

तो विचार यह है कि उपयोगकर्ता एसिंक्रोनस रेंडरिंग में माइग्रेट करने के लिए तैयार होने से पहले ही सस्पेंस में माइग्रेट करना शुरू कर देंगे। फिर एक बार सबट्री तैयार हो जाने पर, वे <AsyncMode> में लपेटकर ऑप्ट-इन कर सकते हैं।

नए ऐप्स के लिए, हालांकि, कहानी अलग है: डिफ़ॉल्ट रूप से async जाओ। हम एक नया रूट API ( ReactDOM.render लिए एक प्रतिस्थापन) पेश करेंगे जो केवल async है।

प्रारंभिक रिलीज के बाद एक अजीब अवधि होगी जहां कई तृतीय-पक्ष ढांचे (रेडक्स, अपोलो, रिएक्ट राउटर ...) एसिंक मोड में ठीक से काम नहीं कर सकते हैं। यह कुछ समय के लिए गोद लेने को नुकसान पहुंचा सकता है। लेकिन विचार यह है कि नई सुविधाएँ इतनी सम्मोहक होंगी कि पुस्तकालयों को या तो अनुकूलित करने या async- संगत विकल्प द्वारा प्रतिस्थापित होने में देर नहीं लगेगी।

इसके अलावा, क्या आपके पास सबसे अच्छी तैयारी करने के बारे में कोई सुझाव है (आज लिखे गए कोड के संदर्भ में, जो भविष्य में इन सुधारों के साथ प्रतिक्रिया के अनुकूल होना चाहता है) - पॉलीफिल/तकनीक/आदि?

सब कुछ <StrictMode> में लपेटें और सुनिश्चित करें कि कोई चेतावनी नहीं है। जैसे-जैसे हम रिलीज़ होने वाले हैं, हमारे पास और अधिक विस्तृत माइग्रेशन मार्गदर्शिकाएँ होंगी।

प्रारंभिक रिलीज के बाद एक अजीब अवधि होगी जहां कई तृतीय-पक्ष ढांचे (रेडक्स, अपोलो, रिएक्ट राउटर ...) एसिंक मोड में ठीक से काम नहीं कर सकते हैं।

अपोलो अजीब नहीं करता - हम तैयार रहेंगे! मैं

गंभीरता से हालांकि, हम: दिल: सभी चीजें प्रतिक्रिया करती हैं, इसलिए यह सुनिश्चित करना कि हम प्रारंभिक रिलीज के लिए इन परिवर्तनों के अनुरूप हैं, न केवल एक उच्च प्राथमिकता है, बल्कि यह कुछ ऐसा भी है जिसके बारे में हम बहुत उत्साहित हैं! इस @acdlite पर आपके सभी अद्भुत कार्यों के लिए धन्यवाद!

मैं झंकार करूंगा और कहूंगा कि Redux टीम React-Redux के लिए async कॉम्पैट पर काम कर रही है।

मैंने https://github.com/reduxjs/react-redux/issues/950 पर एक संभावित रोडमैप तैयार किया है। टीएल; डॉ:

• रिएक्ट-रेडक्स 5.1 बिना किसी चेतावनी के <StrictMode> साथ काम करेगा (वर्तमान पीआर: https://github.com/reduxjs/react-redux/pull/980)
• 6.0 नए संदर्भ एपीआई का उपयोग करने के लिए एक आंतरिक पुनर्लेखन होगा, रेफरी अग्रेषण जोड़ें, और संभवतः अन्य परिवर्तन, लेकिन जितना संभव हो सके वर्तमान सार्वजनिक एपीआई को रखने की कोशिश करें (यानी, <Provider> और connect() )। हम देखेंगे कि एसिंक्स रेंडरिंग के साथ यह कितनी अच्छी तरह काम करता है, और आगे के सर्वोत्तम मार्ग का पता लगाता है। (मेरा पूर्व प्रूफ-ऑफ-कॉन्सेप्ट पीआर https://github.com/reactjs/react-redux/pull/898 पर है, लेकिन हम संभवतः 5.1 कार्य से सीखे गए अन्य पाठों के आधार पर इसे फिर से करेंगे।) यह संभावना है कि नए संदर्भ की आवश्यकता के कारण इस रिलीज़ को न्यूनतम के रूप में रिएक्ट 16.5 की आवश्यकता होगी और संभवत: अभी तक अप्रकाशित "जीवनचक्र विधियों से संदर्भ पढ़ें" पीआर जो अभी विलय किया गया था।
• उसके बाद, हम एक अलग रिएक्ट-रेडक्स एपीआई के लिए विचारों के लिए खुले हैं (हाँ, हाँ, इसमें संभवतः रेंडर प्रॉप्स, लोग शामिल हैं)।

हम अपने डब्ल्यूआईपी पर अधिक नजर रखने की सराहना करेंगे, और उम्मीद है कि लोग हमें कुछ और प्रतिक्रिया और चर्चा दे सकते हैं कि वे रिएक्ट सस्पेंस और एसिंक रेंडरिंग के साथ रेडक्स का उपयोग कैसे कर रहे हैं ताकि हम सुनिश्चित कर सकें कि उपयोग के मामलों को ठीक से कवर किया जा सके। हम रिएक्ट टीम के साथ कुछ और चर्चा करने की भी उम्मीद कर रहे हैं कि हमें किन बाधाओं के साथ काम करने की आवश्यकता है, और यह मददगार होगा यदि हम कुछ नमूना ऐप प्राप्त कर सकते हैं जो हमें यह देखने देंगे कि हमें किन समस्याओं को हल करने की आवश्यकता है सभी के लिए यह सही ढंग से काम करने के लिए।

Async रेंडरिंग और सस्पेंस की रिलीज़ की प्रतीक्षा कर रहा है

@acdlite सस्पेंस और
मेरा सवाल यह है कि एक बार उन्हें पेश किया जाता है और कोई प्रतिक्रिया के उस नए संस्करण के साथ ऐप्स लिखना शुरू कर देता है: क्या इसका मतलब यह है कि प्रतिक्रिया एपीआई और प्रतिक्रिया में लोगों के कोड भी बदल जाएंगे? (भले ही वे सस्पेंस और एसिंक्स रेंडरिंग की सुविधाओं का उपयोग करने की योजना नहीं बनाते हैं?)

मैं इसे लिखने के लिए जटिल हो सकता है ग्रहण रहस्य के साथ और प्रतिपादन (शायद कुछ नए एपीआई या अन्य सीमाओं के कारण) async कोड प्रतिक्रिया, और जो लोग इसकी आवश्यकता नहीं है के लिए, करने के लिए उपयोग एक नए तरीके से प्रतिक्रिया क्यों उन्हें मजबूर? और उन्हें प्रतिक्रिया में कोड करने की अनुमति न दें जिस तरह से वे अभी करते हैं?

मुझे लगता है कि सस्पेंस के साथ प्रतिक्रिया कोड लिखना मुश्किल हो सकता है

क्या आपको मेरी बात का दूसरा भाग देखने का मौका मिला है? मैं इसके बिल्कुल विपरीत कहूंगा - यह किसी भी चीज़ की तुलना में डेटा लाने के लिए रहस्य का उपयोग करने के लिए कम मुश्किल है (Redux, स्थानीय राज्य, या कुछ अन्य पुस्तकालय सहित)।

@gaearon मैंने नहीं किया। मैं थ्योरी में ज्यादा बोल रहा था। कल्पना कीजिए कि पहले से ही ऐसे लोगों का समूह है जो प्रतिक्रिया करना जानते हैं। अगर लोगों को एसिंक्स रेंडरिंग और सस्पेंस की सुविधा की आवश्यकता नहीं है, तो उन्हें "नई" प्रतिक्रिया सीखने के लिए क्यों मजबूर किया जाए? खासकर अगर "नई" प्रतिक्रिया का उपयोग करना मुश्किल है? लेकिन: मुझे अच्छी तरह से सूचित नहीं किया गया है इसलिए मैं "ट्रिकियर" भाग के बारे में गलत कह सकता हूं - मैं बस अपने कुछ विचार साझा कर रहा हूं :)।

एक तरह से मैं कह रहा हूं कि अगर 10% ऐप्स को सस्पेंस और एसिंक्स रेंडरिंग की सुविधा की आवश्यकता है, तो उन 90% मामलों में लोगों को "नई" प्रतिक्रिया सीखने के लिए क्यों मजबूर किया जाता है? लेकिन फिर से मैं गलत हो सकता हूं, क्योंकि मैंने अभी तक सस्पेंस और एसिंक्स रेंडरिंग के बारे में ज्यादा जानकारी नहीं जुटाई है।

मुझे लगता है कि अगर आपने अभी तक मेरे डेमो को नहीं देखा है तो बातचीत करना मुश्किल है।

स्पष्ट होने के लिए: कोई "नई प्रतिक्रिया" नहीं है, ये सुविधाएँ किसी भी मौजूदा पैटर्न को नहीं तोड़ती हैं। वे योगात्मक हैं। आपको उन सुविधाओं का उपयोग करने के लिए पूरी तरह से अलग तरीके से कोड लिखने की आवश्यकता नहीं है - हालांकि उनमें से कुछ केवल तभी काम करते हैं जब आप आधुनिक जीवनचक्र विधियों का उपयोग करते हैं ।

हालांकि यह सीधे आपकी चिंता से संबंधित नहीं है, मैं असहमत हूं कि वे "उपयोग करने में अधिक कठिन" हैं। मुझे लगता है कि वर्तमान में मौजूद किसी भी अन्य लोडिंग तंत्र की तुलना में रहस्य का उपयोग करना बहुत आसान है। यही कारण है कि मैं इसे लेकर बहुत उत्साहित हूं। लेकिन फिर, यदि आप नहीं चाहते हैं तो आपको किसी भी नई सुविधा का उपयोग करने की आवश्यकता नहीं है। पुराने पैटर्न काम करते रहेंगे।

मैं वास्तव में मेरी बात देखने की सलाह देता

@gaearon

सभी पुराने पैटर्न काम करते रहते हैं।

प्रतिक्रिया के लिए धन्यवाद डैन। हाँ, मैंने ऐसा ही सोचा था, मुझे लगता है कि अगर लोगों को उन सुविधाओं की आवश्यकता नहीं है, तो वे उन सुविधाओं को जोड़ने से पहले जिस तरह से उपयोग करते थे, उन्हें लिखने में सक्षम होना चाहिए।

आपको कामयाबी मिले।

अरे डैन (@gaearon), मैं नाइटपिकिंग नहीं कर रहा हूं, लेकिन इसका पता लगाना चाहता हूं। ऊपर आपने कहा:

लेकिन फिर, यदि आप नहीं चाहते हैं तो आपको किसी भी नई सुविधा का उपयोग करने की आवश्यकता नहीं है। पुराने पैटर्न काम करते रहेंगे।

जो यह सुझाव देगा कि मैं नए रिएक्ट में उसी तरह कोड कर सकता हूं जैसे मैंने "पुराने" रिएक्ट में किया था, उदाहरण के लिए मैं उसी तरह से जीवन चक्र के तरीकों का उपयोग कर सकता हूं, आदि।

हालाँकि, यहाँ , bvaughn का कहना है कि getDerivedStateFromProps (या कंपोनेंटWillReceiveProps) को एक अपडेट के लिए कई बार कॉल किया जा सकता है, इसलिए उसका समाधान इसके अंदर डेटा नहीं लाना है।

तो मेरा सवाल यह है कि आखिरकार, ऐसा लगता है कि हम नए रिएक्ट का ठीक उसी तरह उपयोग नहीं कर सकते जैसे पहले किया था? चूंकि AFAIK वर्तमान प्रतिक्रिया घटक में WillReceiveProps को एक अपडेट के लिए कई बार कॉल नहीं किया जाता है, है ना?

@ जियोर्गी-एम: हाँ, जीवनचक्र के तरीके बदल रहे हैं, लेकिन बात यह है कि सस्पेंस अपने आप में एक ऑप्ट-इन फीचर है। आपके सभी मौजूदा रिएक्ट रेंडर मेथड्स और रिएक्ट का रेंडरिंग बिहेवियर इस तरह काम करेगा। हालांकि, _if_ आप अपने ऐप के एक हिस्से में <AsyncMode> टैग जोड़कर ऑप्ट इन करते हैं, _और_ आप एसिंक्स डेटा जरूरतों को इंगित करने के लिए सस्पेंस के दृष्टिकोण का उपयोग करना शुरू करते हैं, _तब_ आप इसका लाभ उठा सकते हैं। यदि आप इसे अपने कोडबेस में नहीं जोड़ते हैं तो इनमें से कुछ भी नहीं होता है।

componentWillReceiveProps या getDerivedStateFromProps बजाय @ giorgi-m componentDidUpdate का उपयोग किया जाना चाहिए।

@markerikson तो आप कहते हैं कि bvaughn ने यहां क्या कहा, कि _getDerivedStateFromProps_ को एक अपडेट के लिए कई बार कॉल किया जा सकता है, जरूरी नहीं कि ऐसा ही हो, अगर मैंने <AsyncMode/> सक्षम नहीं किया है?
(इस तरह के प्रश्न पूछने के लिए खेद है, वे समय-समय पर मेरे पास पॉपअप करते हैं, और संसाधन नहीं मिला जो सभी को कवर कर सके)।

पुनश्च bvaughn ने लिंक किए गए धागे में इसकी वैकल्पिकता का भी उल्लेख नहीं किया, इसलिए इसने मेरा संदेह बढ़ा दिया।

क्या एसिंक्रोनस अपडेट को कतारबद्ध करने के लिए एक विधि (उदाहरण के लिए वर्ग घटकों के लिए deferSetState() रेंडरर-विशिष्ट unstable_deferredUpdates() विपरीत) को कोर चेकलिस्ट में जोड़ा जाना चाहिए?

मेरी समझ से, async mode में फाइबर के लिए कोई भी अपडेट अतुल्यकालिक होगा, जिसका सिद्धांत रूप में अर्थ है कि deferSetState() अनावश्यक होगा। हालांकि, unstable-async/suspense डेमो एक सिंक्रोनस अपडेट और एक एसिंक अपडेट को मिलाता है और मुझे यकीन नहीं है कि इसे async मोड ("सार्वभौमिक" घटकों के लिए) में कैसे पूरा किया जा सकता है।

यह छाता काटने के समय के लिए चेक लिस्ट में है।

घटक प्रकार के रूप में समर्थन वादा

इससे संबंधित, जब आपके पास:

const PromiseType = new Promise(() => {})
class A extends Component {
    componentDidMount() {}
    componentDidUpdate() {}
    render() {
        return <div><PromiseType></PromiseType></div>
    }
}

क्या कोई अनुमान है कि componentDidMount और componentDidUpdate जीवनचक्र कब कॉल किए जाएंगे।

1. जब सभी बच्चों को हल कर दिया गया है (वादे सहित), जिसका इस मामले में मतलब है कि उन्हें बुलाया नहीं जाएगा वादा कभी हल नहीं किया गया है?
2. जब सभी तत्काल मेजबान बच्चों का प्रतिपादन किया गया हो?

@thysultan : componentDidMount और componentDidUpdate को प्रतिबद्ध चरण में कहा जाता है, जब यूआई पेड़ पूरी तरह से प्रस्तुत किया जाता है और डीओएम पर लागू होता है।

तो, सस्पेंस की मेरी समझ के आधार पर, मुझे लगता है कि इसका उत्तर यह है कि A उदाहरण वास्तव में कभी माउंट नहीं होगा। यदि PromiseType _did_ हल हो जाता है, लेकिन इसके एक और वंशज ने भी एक ऐसे वादे की प्रतीक्षा करने का प्रयास किया जो कभी हल नहीं होता, तो यह फिर कभी माउंट नहीं होगा। इस प्रकार, उन उदाहरणों में cDM और cDU को कभी भी निष्पादित नहीं किया जाएगा।

(अगर मेरी धारणाएं यहां गलत हैं तो कोई मुझे सही करने के लिए स्वतंत्र महसूस करता है :))

हाँ, componentDidMount या componentDidUpdate केवल प्रतिबद्ध चरण में निष्पादित होता है जो पूरे पेड़ को हल करने के बाद ही निष्पादित

मैं वास्तव में इसके साथ खेलने में सक्षम होने के लिए उत्सुक हूं (यहां तक ​​​​कि बहुत सारे स्रोत कोड के माध्यम से भी यह पता लगाने के लिए कि आपने अभी तक वर्ल्ड वाइड वेब पर इसका वर्किंग वर्जन नहीं डाला है)।

क्या इसे जारी करने में मदद के लिए हम कुछ कर सकते हैं? :डी

यदि आप खेलना चाहते हैं तो आप मास्टर से संकलन कर सकते हैं। fixtures/unstable-async/suspense में निर्देश देखें

@gaearon क्या मैं सही हूं कि यह केवल अपने वर्तमान राज्य क्लाइंट साइड में है (सर्वर साइड रेंडरिंग का समर्थन करने के लिए और अधिक काम किया जाना है)?

संपादित करें, उत्तर मिला: सार्वभौमिक ऐप्स के लिए एसएसआर में सस्पेंस का उपयोग करने के लिए उत्सुकता से किसी और के लिए। मुझे डैन की यह टिप्पणी मिली जिससे हमें पता चलता है कि यह अभी के लिए क्लाइंट साइड है। हालाँकि, वह टिप्पणी https://www.youtube.com/watch?v=z-6JC0_cOns की ओर भी

हम वास्तव में जल्द ही एसएसआर मामले से संबंधित कुछ काम शुरू कर रहे हैं।

एक निम्न-स्तरीय मोबाइल डिवाइस में चल रहे एसिंक रिएक्ट ऐप में इस परिदृश्य की कल्पना करें:

1. सभी CPU (😓) का उपयोग करते हुए एक बाहरी विज्ञापन लोड हो रहा है
2. उपयोगकर्ता एक लिंक पर क्लिक करता है और राउटर एक नया रेंडर ट्रिगर करता है
3. प्रतिक्रिया एसिंक मोड में है, इसलिए यह तब तक प्रतीक्षा करता है जब तक क्रोम/सफारी इसे सीपीयू का उपयोग करने की अनुमति नहीं देता है, लेकिन विज्ञापन 3 सेकंड के लिए लोड होता रहता है
4. उपयोगकर्ता को लगता है कि ऐप काम नहीं कर रहा है

उदाहरण के लिए 1 सेकंड के बाद स्पिनर दिखाते हुए, सस्पेंस के लिए चर्चा की गई उसी <Placeholder> तकनीक का उपयोग करके इस समस्या से बचा जा सकता है।

क्या इस परिदृश्य पर विचार किया गया है? क्या <Placeholder> धीमी async रेंडरर्स के लिए काम करेगा?

@luisherranz इसे रोकने के लिए दो तंत्र हैं:

1. रिएक्ट में हर अपडेट से जुड़ी एक समय सीमा होती है। क्लिक और इस तरह के अन्य इंटरैक्शन के अपडेट ~150ms के भीतर फ़्लश होने चाहिए, जब तक कि आप स्पष्ट रूप से एक लंबी समय सीमा (जैसे गैर-आवश्यक अपडेट के लिए) का विकल्प नहीं चुनते हैं। तो अगर कुछ थ्रेड को हॉगिंग कर रहा है तो रिएक्ट सिंक्रोनस फ्लश को मजबूर कर देगा।

2. रिएक्ट वास्तव में अब requestIdleCallback उपयोग नहीं करता है क्योंकि वास्तव में ब्राउज़र इसे शेड्यूल करने के बारे में पर्याप्त आक्रामक नहीं हैं। समय के साथ सटीक शेड्यूलिंग दृष्टिकोण भी बदल सकता है, लेकिन यह निश्चित रूप से ऐसी चीज है जिसका हम ध्यान रखते हैं।

त्वरित उत्तर दान के लिए बहुत धन्यवाद।

1. रिएक्ट की हर अपडेट से जुड़ी एक समय सीमा होती है

विस्मयकारी। क्या पहले से ही एक एपीआई है जिसका हम परीक्षण कर सकते हैं?

1. प्रतिक्रिया वास्तव में अब requestIdleCallback का उपयोग नहीं करती है क्योंकि वास्तव में ब्राउज़र इसे शेड्यूल करने के बारे में पर्याप्त आक्रामक नहीं हैं।

हमने भी यही प्रयोग किया है। कभी-कभी बाहरी विज्ञापनों के साथ भीड़-भाड़ वाले ऐप में और ट्विटर या यूट्यूब से एम्बेड होने में कई सेकंड लग सकते हैं जब तक कि requestIdleCallback को कॉल नहीं किया जाता है और रेंडर समाप्त हो जाता है। तो उस के लिए।

BTW, हमारे लिए आपके पहले उत्तर से संबंधित एक और उपयोग का मामला है: हम दो ऑफसेट के साथ आलसी लोड का उपयोग करने का प्रयास कर रहे हैं। पहला एक async रेंडर को ट्रिगर करता है, दूसरा एक सिंक रेंडर को ट्रिगर करता है यदि async समाप्त नहीं हुआ है। कुछ इस तरह:

1. उपयोगकर्ता नीचे स्क्रॉल करता है और यह भारी तत्व से 1200px पर है: उदाहरण के लिए ब्लॉग की अगली पोस्ट।
2. पहला ऑफ़सेट अगले पोस्ट के एसिंक्स रेंडर को ट्रिगर करता है।
3. उपयोगकर्ता नीचे स्क्रॉल करता रहता है और यह अगली पोस्ट के 600px पर है।
4. दूसरा ऑफसेट ट्रिगर: यदि async पोस्ट समाप्त हो गया है (componentDidMount कहा जाता है) कुछ नहीं होता है, लेकिन अगर ऐसा नहीं होता है, तो यह पूरे पोस्ट के सिंक रेंडर को ट्रिगर करता है।

इसलिए समय के बजाय, हम दूसरे ट्रिगर से फ्लश को नियंत्रित करना चाहेंगे। क्या इस का कोई मतलब निकलता है? क्या यह संभव हो सकता है?

क्या पहले से ही एक एपीआई है जिसका हम परीक्षण कर सकते हैं?

मुझे यकीन नहीं है कि आपका मतलब मास्टर पर है या नहीं (एनपीएम रिलीज में एसिंक मोड आधिकारिक तौर पर उपलब्ध नहीं है), लेकिन हर अपडेट के लिए समाप्ति समय स्वचालित रूप से असाइन किया जाता है। क्लिक जैसी घटनाओं के लिए यह उत्पाद मोड में ~150ms है। आप इसे सेट नहीं कर सकते हैं, हालांकि यदि आप एक विशेष अस्थिर एपीआई के साथ चाहते हैं तो आप एक आस्थगित (लंबे समय तक) अपडेट का विकल्प चुन सकते हैं।

इसलिए समय के बजाय, हम दूसरे ट्रिगर से फ्लश को नियंत्रित करना चाहेंगे। क्या इस का कोई मतलब निकलता है? क्या यह संभव हो सकता है?

हाँ यह संभव है। मैंने यहां इस तरह के एक तंत्र का वर्णन किया है: https://github.com/oliviertassinari/react-swipeable-views/issues/453#issuecomment -417939459।

मुझे यकीन नहीं है कि आपका मतलब मास्टर पर है या नहीं (async मोड आधिकारिक तौर पर npm रिलीज़ में उपलब्ध नहीं है)

हां, हम <unstable_AsyncMode> , flushSync और unstable_deferredUpdates साथ npm पैकेज का उपयोग कर रहे हैं।

कृपया, एनपीएम में इन परिवर्तनों के साथ अल्फा/बीटा संस्करण जारी करना शुरू करें! 🙏

हाँ यह संभव है। मैंने यहाँ इस तरह की एक क्रियाविधि का वर्णन किया है: oliviertassinari/react-swipeable-views#453 (टिप्पणी)।

प्रतिभाशाली। unstable_deferredUpdates का उपयोग करके हमारे वर्तमान कार्यान्वयन से बहुत बेहतर :)

<div hidden> का उपयोग शुरू करने के लिए इंतजार नहीं कर सकता। आप लोग अद्भुत काम कर रहे हैं।

@luisherranz सावधान रहें, वे चीजें _are_ अस्थिर हैं। बग हो सकते हैं या बहुत अक्षम हो सकते हैं (उदाहरण के लिए एक महत्वपूर्ण अनुकूलन - "फिर से शुरू करना" - अभी तक लागू नहीं किया गया है)। हम नए schedule मॉड्यूल ( schedule.unstable_scheduleWork ) के पक्ष में unstable_deferredUpdates भी हटा रहे हैं।

हां, हम इसे केवल ऐप के एक छोटे से हिस्से के लिए उपयोग कर रहे हैं और गहन परीक्षण कर रहे हैं लेकिन अभी तक बहुत अच्छा है :)

ऑफटॉपिक हो सकता है:
requestIdleCallback प्रति सेकंड केवल 20 बार कॉल किया जाता है - मेरी 6x2 कोर लिनक्स मशीन पर क्रोम, यह वास्तव में UI कार्य के लिए उपयोगी नहीं है।
requestAnimationFrame को अधिक बार कहा जाता है, लेकिन उस कार्य के लिए विशिष्ट है जो नाम से पता चलता है।

हमने इस कारण से requestIdleCallback का उपयोग बंद कर दिया है।

आप सभी requestIdleCallback बजाय क्या उपयोग कर रहे हैं?

@TejasQ https://github.com/facebook/react/tree/master/packages/scheduler

आह, बिल्कुल। मुझे मूर्ख। मैं सोच रहा था कि शेड्यूलर मॉड्यूल requestIdleCallback बजाय हुड के तहत किस ब्राउज़र एपीआई का उपयोग करता है। मुझे प्रश्न को और स्पष्ट रूप से प्रस्तुत करना चाहिए था। मैं

अरे वाह, मिल गया।
https://github.com/facebook/react/blob/eeb817785c771362416fd87ea7d2a1a32dde9842/packages/scheduler/src/Scheduler.js#L212 -L222

यह अगले स्तर का अच्छा है।

नमस्ते,

सस्पेंस को समझने की कोशिश करते समय मैंने पहचाना कि मुझे नहीं पता कि Suspend घटक 😳😱 का उपयोग करते समय ऐप का कौन सा हिस्सा वास्तव में "निलंबित" है।

निम्नलिखित उदाहरण में मुझे उम्मीद है कि Title तुरंत दिखाई देगा, Spinner 1000ms के बाद और UserData ~2000ms के बाद (जैसा कि उस घटक के डेटा को "लोड करने" में 2000ms लगते हैं)।
लेकिन मैं जो देख रहा हूं वह यह है कि Title पहले 1000ms के बाद Spinner साथ दिखाई देता है।

// longRunningOperation returns a promise that resolves after 2000ms
const UserResource = createResource(longRunningOperation);

function UserData() {
  const userData = UserResource.read(cache, "Lorem Ipsum");
  return <p>User Data: {userData}</p>;
}

function Spinner() {
  return <h1>Fallback Loading Spinner</h1>;
}

function Title() {
  return <h1>Hello World</h1>;
}

function App() {
  return (
    <React.Fragment>
      <Title />
      <Suspense maxDuration={1000} fallback={<Spinner />}>
        <UserData />
      </Suspense>
    </React.Fragment>
  );
}

unstable_createRoot(document.getElementById("mount")).render(<App />);

(आप पूरा उदाहरण पा सकते हैं जो रिएक्ट 16.6.0-alpha.8af6728 का उपयोग करता है

क्या Title तुरंत दृश्यमान बनाने और एप्लिकेशन के केवल दूसरे भाग को "निलंबित" करने का कोई तरीका है? या मैंने शायद सस्पेंस को पूरी तरह से गलत समझा? (यदि इस तरह के प्रश्न पूछने का कोई बेहतर तरीका है, तो कृपया मुझे बताएं)

धन्यवाद!

हाय @nilsartmann! बढ़िया सवाल!

क्या शीर्षक को तुरंत दृश्यमान बनाने और एप्लिकेशन के दूसरे भाग को "निलंबित" करने का कोई तरीका है?

अगर मैं सही ढंग से समझता हूं, तो आपको Title को डीओएम में फ्लश करने से पहले _not Wait_ को प्रतिक्रिया स्पष्ट रूप से बताना होगा क्योंकि इस उदाहरण में Title तुरंत दिखाई देने के लिए और केवल अन्य को "निलंबित" करने के लिए एप्लिकेशन का हिस्सा उन हिस्सों को लपेटकर जो आप तुरंत <Suspense maxDuration={0}> में प्रस्तुत किए जाने की अपेक्षा करते हैं।

मुझे लगता है कि कुछ अंतर्निहित निचले स्तर के अनुसूचक यांत्रिकी के कारण यह मामला है? मुझे इसे बेहतर ढंग से समझना भी अच्छा लगेगा, लेकिन इससे आपकी समस्या अभी हल होनी चाहिए।

मैं यह सुनने के लिए उत्साहित हूं कि वास्तव में वहां क्या हो रहा है।

(यदि इस तरह के प्रश्न पूछने का कोई बेहतर तरीका है, तो कृपया मुझे बताएं)

मुझे यकीन नहीं है कि वहाँ है। यह मुझे काफी स्पष्ट लगता है। पूछने के लिए धन्यवाद!

@TejasQ मेरे ब्राउज़र में, आपका उदाहरण लोड करने से फ़ॉलबैक स्पिनर तुरंत बन जाता है। क्या इसे 1000ms के बाद लोड नहीं करना चाहिए?

@TejasQ आपके उत्तर के लिए धन्यवाद, लेकिन @karlhorky सही है: अब स्पिनर तुरंत दिखाई देता है।

ओह! मैंने यह खो दिया। मैंने कोशिश की। मुझे इसे एक बार फिर से देखने दें और आपके पास वापस आएं। मेरी ओर से ज़रूर कुछ न कुछ भूल गया होगा। ‍♂️

~अपडेट: मैं इसे यहां समझने की कोशिश कर रहा हूं और अगर किसी को रीयलटाइम में इसे एक साथ करने में दिलचस्पी है तो हम सहयोग कर सकते हैं।~

दूसरा अपडेट: @ फिलिप-जासूस और मैंने इसे देखा है और मैं वास्तव में स्टम्प्ड हूं। मैं अभी भी इसे समझ नहीं पा रहा हूं। इस बिंदु पर, मुझे यकीन नहीं है कि यह एक बग है क्योंकि यह वास्तव में एक unstable_ और अल्फा फीचर है, या यदि यह कुछ ऐसा है जिसे मैं बस नहीं देख रहा हूं।

किसी भी मामले में, मुझे लगता है कि कोर टीम के पास या तो उपयोगी उत्तर होंगे, या रिएक्ट को और भी बेहतर/अधिक पहुंच योग्य बनाने के लिए आपके प्रश्न का उपयोग करने में सक्षम होंगे।

आइए देखें कि उनका क्या कहना है। इसे इंगित करने के लिए धन्यवाद, @nilsartmann!

क्या यह रिएक्ट v16.6 के हिस्से के रूप में जारी किया गया था? ब्लॉग पोस्ट सस्पेंस का उपयोग करके उदाहरण कोड दिखाता है:

import React, {lazy, Suspense} from 'react';
const OtherComponent = lazy(() => import('./OtherComponent'));

function MyComponent() (
  <Suspense fallback={<div>Loading...</div>}>
    <OtherComponent />
  </Suspense>
);

क्या यह रिएक्ट v16.6 के हिस्से के रूप में जारी किया गया था?

केवल आलसी लोडिंग उपयोग के मामले, और केवल सिंक मोड में। समवर्ती मोड अभी भी WIP है।

@nilsartmann

निम्नलिखित उदाहरण में मुझे उम्मीद है कि शीर्षक तुरंत दिखाई देगा, 1000ms के बाद स्पिनर और ~ 2000ms के बाद UserData (उस घटक के डेटा को "लोड करने" के रूप में 2000ms लगते हैं)।

मुझे लगता है कि आप थोड़ा भ्रमित हैं कि maxDuration क्या करता है। यह एक नया मानसिक मॉडल है लेकिन हमारे पास अभी तक इसका दस्तावेजीकरण करने का समय नहीं है। इसलिए यह कुछ समय के लिए भ्रमित करता रहेगा जब तक कि समवर्ती मोड स्थिर रिलीज़ में न हो।

हुक प्रस्ताव की घोषणा के लिए बधाई। मैं टीम के साथ कुछ साझा करना चाहता हूं। कुछ समय पहले मैंने रिएक्ट एसिंक नामक एक घटक जारी किया, जिसमें सस्पेंस के समान विशेषताएं हैं। अनिवार्य रूप से यह प्रॉमिस रिज़ॉल्यूशन को संभालता है, और मेटाडेटा प्रदान करता है जैसे कि isLoading, startAt और रीलोड और कैंसिल जैसी विधियाँ, सभी एक घोषणात्मक API के साथ (और एक useAsync हुक रास्ते में है)।

अब मेरी मुख्य चिंता यह है कि यह सस्पेंस के साथ कैसे एकीकृत होगा। अधिकांश भाग के लिए मैं शायद रिएक्ट एसिंक्स से सस्पेंस एपीआई का उपयोग कर सकता हूं और सस्पेंस की शेड्यूलिंग सुविधाओं को मुफ्त में पेश करते हुए उपयोगकर्ताओं को परिचित और सरल रिएक्ट एसिंक एपीआई प्रदान कर सकता हूं। मैंने जो देखा है, उसके लिए मुझे वास्तव में लगता है कि रिएक्ट एसिंक एपीआई अधिक सारगर्भित सस्पेंस एपीआई की तुलना में अधिक समझदार और स्वीकार्य है। अनिवार्य रूप से रिएक्ट Async एक अधिक ठोस एपीआई की पेशकश करने की कोशिश करता है जो उपयोग के मामलों के थोड़े छोटे सबसेट के लिए काम करता है।

रिएक्ट कैश लाइब्रेरी के बारे में जानकर मुझे आश्चर्य हुआ। रिएक्ट एसिंक्स के लिए मैंने जानबूझकर कैश मैकेनिज्म को शामिल नहीं किया, लेकिन वैनिला प्रॉमिस से निपटने के लिए चुना। उसके ऊपर कैशिंग जोड़ना काफी आसान है।

अंत में मैं कस्टम हुक से सस्पेंस सुविधाओं तक पहुँचने के बारे में चिंतित हूँ। सस्पेंस कई अंतर्निहित घटकों पर बहुत अधिक निर्भर करता है, जो इसे एक हुक से उपयोग करना असंभव (मुझे लगता है?) बनाता है। क्या सस्पेंस हुक होंगे? या दोनों को एकीकृत करने का कोई और तरीका है?

नमस्कार। मैं सस्पेंस/आलसी के साथ कोड का परीक्षण कैसे कर सकता हूं?
अब renderer.create(...)toTree() फेंकता है
"toTree () अभी तक नहीं जानता कि टैग = 13 के साथ नोड्स को कैसे संभालना है"

प्रोप maxDuration में Suspense का उपयोग सिंक और समवर्ती मोड दोनों के बजाय केवल Concurrent Mode में ही क्यों किया जाता है। क्या कोई समझाने में मदद कर सकता है?

(अभी) इसका मतलब है कि Concurrent Mode को इस पेड़ को प्रतिबद्ध करने के लिए मजबूर करने से पहले लंबित छोड़ने की अनुमति है - यह समय काटने की समय सीमा को प्रभावी ढंग से नियंत्रित करता है, और सिंक मोड में टाइम स्लाइसिंग मौजूद नहीं है। पेड़ करने से पहले प्रतीक्षा करना अनिवार्य रूप से प्रतिबद्ध होगा ... सिंक नहीं।

मैं डेटा लाने के लिए एक आंतरिक एप्लिकेशन में सस्पेंस का उपयोग कर रहा हूं और बहुत जल्दी इस कारण से आ गया हूं कि इसका उपयोग अभी तक डेटा लाने के लिए नहीं किया गया है।

आखिरकार, हालांकि, इसका उपयोग डेटा लाने के लिए किया जाना है। यह देखते हुए कि ऐसा लगता है कि शायद कैश प्रदाता को छोड़कर एपीआई महत्वपूर्ण रूप से बदलने जा रहा है, अगर आपको डेटा प्राप्त करने के बाद आपको संशोधित करने की आवश्यकता है तो सस्पेंस कैसे काम करता है?

उदाहरण के तौर पर, यहां मेरे आवेदन से वास्तव में एक भयानक हुक है।

function useComponentList(id) {
  const incomingComponents = useSuspenseFetch(
    React.useCallback(() => getComponentAPI().listComponents(id), [id])
  )

  const map = React.useMemo(
    () =>
      Map(
        (incomingComponents || []).map(component => [component.id, component])
      ),
    [incomingComponents]
  )

  return useCacheValue(map)
}

यह हुक:

1. दिए गए समापन बिंदु से दिए गए कॉलबैक का उपयोग करके डेटा प्राप्त करता है
2. उस डेटा को एक इम्यूटेबलजेएस मैप में बदल देता है - चूंकि यह संभावित रूप से महंगा है, इसलिए मैं ऑपरेशन को याद करता हूं।
3. useCacheValue में लिपटे मानचित्र को लौटाता है, जो विशेष रूप से अजीब सा है।

useCacheValue इस तरह दिखता है:

export default function useCacheValue(value) {
  const [state, setState] = React.useState(value)
  React.useEffect(() => {
    setState(value)
  }, [value])

  return [state, setState]
}

इस विचार के साथ कि यह एक हुक है जो value बदलने का जवाब देगा (जो इंगित करता है कि डेटा फिर से किया गया था) लेकिन उपयोगकर्ता को उस राज्य के प्रतिक्रिया ऐप्स प्रतिनिधित्व को संशोधित करने की अनुमति देता है। एक तरह से यह बहुत खराब कैश (इसलिए नाम) की तरह काम करता है।

मैं यह देखने के लिए संघर्ष कर रहा हूं कि यह पैटर्न अपनी वर्तमान स्थिति में Redux के साथ कैसे अच्छा काम करता है। क्या इस बात की कोई खोज हुई है कि यह कैसे दिख सकता है जब एक प्रोग्रामर द्वारा लिखा जाता है जो मैं नहीं हूं और जब डेटा लाने के लिए सस्पेंस 'तैयार' है? जैसा कि यह खड़ा है, यह अनिवार्य रूप से लाने वाले झंडे के साथ Redux का उपयोग करने से कहीं अधिक श्रमसाध्य है।

एक बार Redux के अपने हुक होने के बाद यह शायद बहुत सरल हो जाता है क्योंकि दोनों को एक साथ खेलने में मुख्य कठिनाई यह है कि Redux एक HOC का उपयोग एक ऐसे संदर्भ के साथ करता है जिसे उजागर करने के लिए नहीं है, लेकिन मैं अभी भी देखना चाहता हूं कि आधिकारिक क्या है जवाब है :)

सस्पेंस बाहरी कैश (राज्य द्वारा संचालित हुक नहीं ) के साथ काम करने के लिए है। हम ऐसे कैश का संदर्भ कार्यान्वयन प्रदान करेंगे जो साधारण उपयोग के मामलों के लिए काम करता है। रिले अपने स्वयं के कैशिंग तंत्र को लागू करेगा। कोई भी अन्य उपकरण (जैसे अपोलो) अपने स्वयं के कैश को भी लागू करने में सक्षम होंगे जो कि संगत है, संभवतः इन दो कार्यान्वयनों से प्रेरित हो रहा है।

उत्परिवर्तन/अमान्यता एकमात्र ऐसा प्रश्न नहीं है जिसके उत्तर की आवश्यकता है। हमें इस बारे में भी सोचने की जरूरत है: स्पिनरों को कब दिखाना है, "इनलाइन इंडिकेटर" जैसे सामान्य पैटर्न जो निलंबित पेड़ के बाहर हो सकते हैं, लोडिंग राज्यों को समन्वयित कर सकते हैं (उन चीजों के लिए जिन्हें टॉप-डाउन ऑर्डर में अनलॉक करने की आवश्यकता होती है या वे आते हैं जैसे वे हैं रेडी), सूचियों का स्ट्रीमिंग रेंडरिंग, यह आंशिक हाइड्रेशन को कैसे प्रभावित करता है, इत्यादि। हम इन चीजों पर काम कर रहे हैं लेकिन इनमें से किसी पर अभी तक कोई "आधिकारिक सिफारिश" नहीं है। जब होगा, तो आप उस ब्लॉग से जानेंगे जहां हम अपडेट की घोषणा करते हैं।

एक साइड नोट के रूप में, डेटा लाने के लिए सस्पेंस लोगों की आदत से काफी अलग मानसिक मॉडल है। मुझे नहीं लगता कि यह अपेक्षा करना उचित है कि Redux जैसे बहुत ही अप्रतिबंधित तंत्र के साथ एकीकृत होने पर यह आवश्यक रूप से शक्तिशाली होगा। लेकिन हम देखेंगे। अभी कुछ भी कहना मुश्किल है।

@gaearon जब आप कहते हैं "हम इन चीजों पर काम कर रहे हैं", क्या कोई ऐसा मुद्दा है जिसे मैं सब्सक्राइब कर सकता हूं या ये चर्चाएं निजी तौर पर हो रही हैं?

धन्यवाद, @gaearon :)

@ntucker हमेशा की तरह, आप चल रही गतिविधि को https://github.com/facebook/react/pull/14717 , https://github.com/facebook/react/pull/14884 , https://github.com/facebook/react/pull/15061 , https://github.com/facebook/react/pull/15151 , https://github.com/facebook/react/pull/15272 , https://github.com/facebook/react/pull/15358 , https ://github.com/facebook/react/pull/15367 , इत्यादि। हम प्रत्येक पीआर में कुछ वर्णनात्मक जानकारी डालने का प्रयास करते हैं, और आप परीक्षणों से व्यवहार परिवर्तन देख सकते हैं। प्रयोगों के लिए प्रलेखन बार कई कारणों से कम है।

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

यह और भी बुरा है कि इसका परिणाम अक्सर लोगों को किसी ऐसी चीज़ के इर्द-गिर्द एक मानसिक मॉडल बनाने में होता है जिसे हम बाद में महसूस करते हैं कि मूल रूप से डिज़ाइन किए गए तरीके से काम नहीं करता है। (जैसे कि यह maxDuration साथ हो रहा है जिसे हमने अभी-अभी हटाया है।) इसलिए हम आधे-अधूरे विचारों को तब तक साझा करना बंद करना पसंद करेंगे जब तक कि यह आपके समय और हमारे समय दोनों का अच्छा उपयोग न हो जाए। यह इस बात के अनुरूप है कि हमने अतीत में भी रिएक्ट कैसे विकसित किया। जब कुछ वास्तव में तैयार होता है (मानसिक मॉडल के सैद्धांतिक लेखन के लिए भी), तो हम अपना सारा ध्यान इसे दस्तावेज और समझाने पर केंद्रित करेंगे।

एक साइड नोट के रूप में, डेटा लाने के लिए सस्पेंस लोगों की आदत से काफी अलग मानसिक मॉडल है। मुझे नहीं लगता कि यह अपेक्षा करना उचित है कि Redux जैसे बहुत ही अप्रतिबंधित तंत्र के साथ एकीकृत होने पर यह आवश्यक रूप से शक्तिशाली होगा। लेकिन हम देखेंगे। अभी कुछ भी कहना मुश्किल है।

@gaearon , सौभाग्य से, सस्पेंस का मानसिक मॉडल पूरी तरह से मेरे साथ मेल खाता है। पहेली के उस टुकड़े को जगह देने के लिए बहुत उत्साहित हैं। आप सभी की कड़ी मेहनत के लिए आपको धन्यवाद!

पिछले नवंबर में घोषित रोडमैप (https://reactjs.org/blog/2018/11/27/react-16-roadmap.html) ने संकेत दिया कि सस्पेंस का "समवर्ती" संस्करण Q2 2019 के लिए निर्धारित किया गया था। अब हम अच्छी तरह से हैं Q3 2019। क्या कोई अपडेट है जो हमें निश्चित रूप से Q3, या शायद Q3, आदि के संदर्भ में नहीं मिल सकता है?

यह नवीनतम रोडमैप अपडेट था जो मुझे मिल सका: https://reactjs.org/blog/2019/08/08/react-v16.9.0.html#an -update-to-the-roadmap

हमने अक्टूबर में एक प्रयोगात्मक रिलीज़ प्रदान की: https://reactjs.org/docs/concurrent-mode-intro.html। यह वही बिल्ड है जिसे हम प्रोडक्शन में चला रहे हैं। अभी और काम करना बाकी है (दोनों एपीआई में बदलाव और उच्च-स्तरीय एपीआई के निर्माण के मामले में) लेकिन आप चाहें तो इसके साथ खेलना शुरू कर सकते हैं।

सस्पेंस मुझे मार रहा है

@gaearon मैं समझता हूं कि आप इसे उत्पादन में उपयोग करते हैं। लेकिन मैं उत्पादन में "प्रयोगात्मक" कोड का उपयोग करने में बहुत अनिच्छुक हूं। आप लोग रोडमैप, स्थिति, प्रगति, समय आदि के बारे में स्पष्ट नहीं हो रहे हैं। क्या यह अल्फा, बीटा, आरसी गुणवत्ता है? यह शब्द "प्रयोगात्मक" मुझे "इसे मत छुओ" कहता है।

हम सभी इस कोड पर अपने व्यवसायों को बैंकिंग कर रहे हैं और मुझे यकीन है कि हम सभी आप लोगों की तरह ही डूबे हुए हैं। थोड़ी सी स्पष्टता, एक ब्लॉग, कुछ वास्तव में मदद करेगा। यह लगभग ऐसा लगता है जैसे "यह फेसबुक पर उत्पादन में है, इसलिए हम कर चुके हैं"।

@mschipperheyn

यह एक बहुवर्षीय परियोजना है। ईमानदार उत्तर यह है कि दो साल पहले जब हमने इसे शुरू किया था, तो हमने जितना सोचा था उससे कहीं अधिक काम किया है।

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

आज विभिन्न कार्यप्रवाहों की एक खराब स्थिति यहां दी गई है:

• <Suspense> के साथ कोड बंटवारे के लिए एपीआई lazy । (रिएक्ट 16.6 में भेज दिया गया)
  
  
  
  • जैसा कि आप जानते होंगे, आप इसे पहले से ही इस्तेमाल कर सकते हैं।
  
  
• समवर्ती मोड API, जैसे createRoot और useTransition । (में उपलब्ध experimental विज्ञप्ति)
  
  
  
  • फ्लक्स जैसी पुस्तकालयों के लिए संगतता समाधान। ( प्रगति में @bvaughn , https://github.com/reactjs/rfcs/pull/147)
  
  
  • प्राथमिकता मॉडल को अधिक समझदार में बदलना। ( प्रगति में @acdlite , https://github.com/facebook/react/pull/18612)
  
  
  • केवल अंतिम लंबित संक्रमण को समाप्त होने दें। ( प्रगति में @acdlite)
  
  
  • ऑफस्क्रीन एपीआई ( प्रगति @lunaruan)
  
  
  • सस्पेंस के लिए सामग्री छुपाने/दिखाने पर आग के प्रभाव
  
  
  • ऑफ़स्क्रीन के लिए सामग्री छुपाने/दिखाने पर आग के प्रभाव
  
  
  • जरूरत पड़ने पर पोर्टल बच्चों को दिखाएं और छिपाएं
  
  
  • शेड्यूलिंग के लिए चल रहे मानकीकरण कार्य के साथ संरेखित करें ( शुरू नहीं हुआ )
  
  
  • प्रमुख ज्ञात बग ठीक करें ( प्रगति @gaearon और @acdlite में)
  
  
  • घटना शब्दार्थ बदलें। ( प्रगति में @sebmarkbage @trueadm)
  
  
  • अधिक क्रमिक अपनाने को सक्षम करने के लिए दस्तावेज़ के बजाय जड़ों को सौंपें ( प्रगति में , @trueadm)
  
  
  • कैप्चर चरण में असतत घटनाओं को फ्लश करें।
  
  
  • अनिवार्य कोड के साथ अच्छा खेलने के लिए event से डिफ़ॉल्ट प्राथमिकता प्राप्त करने पर विचार करें।
  
  
  • अन्य एपीआई शब्दार्थ और डिफ़ॉल्ट को अंतिम रूप दें। ( शुरू नहीं हुआ )
  
  
  • टाइपिंग और दस्तावेज़ीकरण अपडेट करें।
  
  
• डेटा फ़ेचिंग के लिए सस्पेंस
  
  
  
  • एक घटक को संकेत देने के लिए निम्न-स्तरीय समर्थन प्रस्तुत करने के लिए तैयार नहीं है (तकनीकी रूप से स्थिर प्रतिक्रिया में भी
  
  
  • सर्वर रेंडरर तुरंत सस्पेंस फ़ॉलबैक फ़्लश करता है (प्रयोगात्मक रिलीज़ में उपलब्ध )
  
  
  • GraphQL उपयोग के मामलों के लिए एक समाधान (रिले हुक, शिप किया गया )।
  
  
  • गैर-ग्राफक्यूएल उपयोग मामलों के लिए एक समाधान ( नेक्स्ट.जेएस के सहयोग से @sebmarkbage प्रगति पर है )।
  
  
  • डेटा-संचालित निर्भरता के लिए एक बंडलर एकीकरण। ( प्रगति में )
  
  
  • संदर्भ सहित, ब्लॉक एपीआई को अंतिम रूप दें।
  
  
  • एक सामान्य कैशिंग समाधान। ( शुरू नहीं हुआ )
  
  
  • किसी प्रकार का राउटर एकीकरण।
  
  

यह लगभग ऐसा लगता है जैसे "यह फेसबुक पर उत्पादन में है, इसलिए हम कर चुके हैं"।

मैं देख सकता हूँ कि यह इस तरह कैसे दिख सकता है, हालाँकि tbh यह पठन थोड़ा मनोबल गिराने वाला है। :-) हम पिछले सभी महीनों से इस पर लगातार काम कर रहे हैं, और कई तकनीकी पहलू या तो समाप्त हो चुके हैं या समाप्त होने के करीब हैं। शेष अधिकांश कार्य दो श्रेणियों में आते हैं:

• शुरुआती डिज़ाइनों में पाई गई खामियों को ठीक करने से पहले हम उन्हें एक स्थिर रिलीज़ में सीमेंट करते हैं। अगर हमें अभी जो कुछ भी है, उसे जारी करना है, तो हमें कुछ महीनों में महत्वपूर्ण ब्रेकिंग परिवर्तनों का पालन करना होगा। यह केवल भ्रमित करने वाला होगा।

• पारिस्थितिकी तंत्र अनुकूलता और अच्छी चूक। अगर हम कुछ ऐसा जारी करते हैं जिसे आज कोई उपयोग नहीं कर सकता है तो यह मदद नहीं करता है क्योंकि यह उनके पुस्तकालयों या मौजूदा दृष्टिकोणों के साथ काम नहीं करता है। तो काम का बड़ा हिस्सा (उदाहरण के लिए फ्लक्स-जैसी पुस्तकालयों के साथ संगतता useMutableSource माध्यम से, बेहतर घटना अर्थशास्त्र चुनना, एक अनुशंसित कैशिंग रणनीति शिपिंग करना) यह सुनिश्चित करने में है कि आप वास्तव में हमारे द्वारा जारी की गई चीज़ों का उपयोग करने में सक्षम होंगे। यह एक लंबी पूंछ है।

"क्या आप आज उपयोग कर सकते हैं" के संदर्भ में... तकनीकी रूप से, आप आज इस सब का उपयोग कर सकते हैं। हम कर। विशेष रूप से, हम रिले हुक और समवर्ती मोड का उपयोग करते हैं। हमारे पास अभी भी महत्वपूर्ण नियोजित परिवर्तन और ज्ञात समस्याएं हैं, इसलिए वर्तमान स्थिति उस बार को पूरा नहीं कर रही है जहां हम इसे व्यापक रूप से अपनाने के लिए तैयार मानेंगे। बेशक, अगर आपको बग या एपीआई को अपने हाथों में बदलने से कोई फर्क नहीं पड़ता है , तो आप @experimental रिलीज का ठीक वैसे ही उपयोग करने के लिए स्वागत करते हैं जैसे हम करते हैं।

मैं यह नहीं कहूंगा कि "किया जा रहा है" के मामले में फेसबुक यहां एक विशेष स्थिति में है। इसके विपरीत, हमने काम नहीं किया है - लेकिन आंतरिक रूप से, हम चलती ट्रेन के ऊपर मंथन और निर्माण को सहन करने के लिए तैयार हैं क्योंकि इस तरह हम जानते हैं कि हम जो बना रहे हैं वह ठोस है। इस भारी डॉगफूडिंग के बिना, छह महीने में हमने जो खामियां खोजीं, उन्हें खोजने और उन्हें फिर से डिजाइन करने में कई साल लगेंगे।

संक्षेप में: करने के लिए और अधिक काम है।

@gaearon इस अपडेट के लिए धन्यवाद! और अगर मेरा लहजा गलत था तो मैं माफी मांगता हूं। मैं मानता हूं कि मैं महीनों से ट्विटर को खंगालने और कुछ नहीं पाने से थोड़ा निराश था। यह पहलू Server renderer immediately flushes Suspense fallbacks (available in experimental releases) कुछ ऐसा दिखता है जिसे मैं अपने कार्यान्वयन के लिए अपोलो ग्राफकल के साथ परीक्षण में समय आवंटित कर सकता हूं।

हां, यह पुस्तकालय लेखकों और जिज्ञासु लोगों के साथ खेलना शुरू करने के लिए तैयार होना चाहिए। लापता टुकड़े ज्यादातर "खुश पथ" प्रदान करने के बारे में हैं, लेकिन अधिकांश नलसाजी वहां होनी चाहिए।

सर्वर रेंडरर तुरंत सस्पेंस फ़ॉलबैक फ़्लश करता है (प्रयोगात्मक रिलीज़ में उपलब्ध)

मैं इसके बारे में कहां पढ़ सकता हूं? मैं समवर्ती मोड एपीआई संदर्भ (प्रायोगिक) की उम्मीद कर रहा था लेकिन कोई भाग्य नहीं।

अगर किसी के पास नेक्स्ट.जेएस, रिले हुक और समवर्ती मोड को एक साथ (एसएसआर के साथ) स्टिचिंग करने वाला डेमो है तो यह बहुत अच्छा होगा। अन्यथा मैं अपनी किस्मत आजमा सकता हूं अगर मुझे पर्याप्त दस्तावेज मिल जाए।

@ क्रोकोडिलन

एसएसआर के बारे में कोई अतिरिक्त दस्तावेज़ नहीं है, लेकिन यह ज्यादातर इसलिए है क्योंकि यह सिर्फ एक नया डिफ़ॉल्ट व्यवहार है।

यदि आपके पास सर्वर पर किसी घटक के किसी भी समय निलंबित होने की तुलना में प्रयोगात्मक रिलीज़ है, तो हम इसके बजाय निकटतम सस्पेंस फ़ॉलबैक फ़्लश करते हैं। फिर क्लाइंट पर आप createRoot(node, { hydrate: true }).render(<App />) उपयोग करेंगे।

ध्यान दें कि यह पहले से ही सभी नई हाइड्रेशन सुविधाओं को सक्षम करता है। तो उदाहरण के लिए आपकी सस्पेंस सीमाएं सर्वर से उत्पन्न फॉलबैक एचटीएमएल से "संलग्न" होंगी और फिर क्लाइंट रेंडर करने का प्रयास करेंगी।

यह भी ध्यान रखें कि आप अपने पूरे ऐप के लोड होने से पहले हाइड्रेटिंग शुरू कर सकते हैं। जब <App> लोड हो जाए, तो आप हाइड्रेट कर सकते हैं। जब तक उनका कोड तैयार नहीं होता (आलसी के समान) तब तक नीचे के घटक निलंबित रहते हैं। इस मामले में रिएक्ट क्या करेगा सर्वर HTML सामग्री रखता है लेकिन इसे सस्पेंस सीमा "संलग्न" करता है। जब बच्चे के घटक लोड होते हैं तो यह हाइड्रेटिंग जारी रखेगा। हाइड्रेटेड हिस्से इंटरैक्टिव और रीप्ले इवेंट बन जाएंगे।

आप अगले एकीकरण प्रयासों/उदाहरणों के लिए शायद @devknoll से पूछ सकते हैं। उसके पास शायद कुछ है।

आप react@experimental और react-dom@experimental करके और निम्नलिखित को next.config.js जोड़कर Next.js में समवर्ती मोड सक्षम कर सकते हैं।

// next.config.js
module.exports = {
  experimental: {
    reactMode: 'concurrent'
  }
}

यहाँ इस पर Next.js चर्चा है: https://github.com/zeit/next.js/discussions/10645

क्या सर्वर रेंडरिंग में किसी सस्पेंस की प्रतीक्षा करना संभव है (उदाहरण के लिए स्टैटिक साइट जेन जैसे मामलों के लिए)? मैं मानता हूं कि कॉलबैक का उपयोग करना एक अच्छा डिफ़ॉल्ट है, बस सोच रहा था कि क्या यह ओवरराइड करने योग्य है?

यह भी ध्यान रखें कि आप अपने पूरे ऐप के लोड होने से पहले हाइड्रेटिंग शुरू कर सकते हैं। कबलोड हो गया है, आप हाइड्रेट कर सकते हैं। जब तक उनका कोड तैयार नहीं होता (आलसी के समान) तब तक नीचे के घटक निलंबित रहते हैं। इस मामले में रिएक्ट क्या करेगा सर्वर HTML सामग्री को रखता है लेकिन इसे सस्पेंस सीमा "संलग्न" करता है। जब बच्चे के घटक लोड होते हैं तो यह हाइड्रेटिंग जारी रखेगा। हाइड्रेटेड हिस्से इंटरैक्टिव और रीप्ले इवेंट बन जाएंगे।

@gaearon क्या आपका मतलब है कि आप सर्वर पर सामान्य रूप से एक घटक प्रस्तुत कर सकते हैं, लेकिन क्लाइंट पर React.lazy का उपयोग करें? आपको सर्वर से पूर्ण मार्क अप वापस करने की अनुमति देता है, लेकिन क्लाइंट पर घटक कोड को पार्स करने और प्रस्तुत करने में देरी करता है। सर्वर प्रदान किया गया मार्कअप यहाँ सस्पेंस फ़ॉलबैक के रूप में कार्य करता है?

@robrichard मैंने वास्तव में इसे React.lazy विशेष रूप से आजमाया नहीं है (हम एफबी पर एक अलग रैपर का उपयोग करते हैं और अगला भी इसका अपना संस्करण है) लेकिन मुझे उम्मीद है कि यह इस तरह काम करेगा। सत्यापन योग्य :-) कुछ सीमाओं के साथ - जैसे यदि आप इसके प्रॉप्स को अपडेट करते हैं और ऊपर कोई मेमो बेलआउट नहीं है, या यदि आप इसके ऊपर संदर्भ अपडेट करते हैं, तो हमें इसे हटाना होगा और फॉलबैक दिखाना होगा क्योंकि हम नहीं जानते कि क्या करना है इसके साथ।

@gaearon वर्तमान स्थिति आंशिक जलयोजन क्या है? मुझे पता है कि #14717 का विलय कर दिया गया था, लेकिन मुझे संदेह है कि इसे किसी रिलीज में बनाया गया है?

जब तक आप unstable_createRoot API का उपयोग करते हैं, तब तक यह लंबे समय से प्रत्येक @experimental रिलीज में चालू है।

यहाँ एक डेमो है: https://codesandbox.io/s/floral-worker-xwbwv?file=/src/index.js

@gaearon क्या आप कृपया "डेटा संचालित निर्भरताओं" से क्या मतलब है, इसका विस्तार करने में सक्षम हैं?

@gaearon क्या आप कृपया "डेटा संचालित निर्भरताओं" से क्या मतलब है, इसका विस्तार करने में सक्षम हैं?

हां बिल्कुल। ऊपर दी गई सूची की संक्षिप्तता के लिए मुझे क्षमा मांगनी चाहिए - यह बहुत संघनित है और इनमें से कई महत्वपूर्ण अलग उप-परियोजनाएं हैं (यही कारण है कि वे समय ले रहे हैं)।

मैं आपके विशिष्ट प्रश्न का उत्तर देने से पहले एक कदम पीछे हटता हूं और कुछ व्यापक संदर्भ देता हूं। व्यापक संदर्भ यह है कि वास्तव में एक

"आधिकारिक" प्रतिक्रिया में जो मिलता है उसके लिए हमारे पास एक बहुत ही उच्च बार है। "रिएक्ट्री" होने के लिए, इसे नियमित रिएक्ट घटकों के साथ-साथ रचना भी करनी होगी। इसका मतलब है कि हम सद्भाव में ऐसे समाधान की अनुशंसा नहीं कर सकते हैं, जिसके बारे में हमें विश्वास नहीं है कि यह हजारों घटकों के पैमाने पर होगा। हम ऐसे समाधान की भी अनुशंसा नहीं कर सकते हैं जो आपको कोड को एक जटिल अनुकूलित तरीके से लिखने के लिए मजबूर करता है ताकि वह प्रदर्शनकारी बना रहे। एफबी में, हमने रिले टीम से इसमें बहुत कुछ सीखा है। हम जानते हैं कि हर कोई ग्राफ़क्यूएल का उपयोग नहीं कर सकता है, या रिले का उपयोग करना चाहेगा (यह अपने आप में बहुत लोकप्रिय नहीं है और टीम ने इसे बाहरी अपनाने के लिए अनुकूलित नहीं किया है)। लेकिन हम यह सुनिश्चित करना चाहते हैं कि सामान्य रिएक्ट के लिए हमारे डेटा फ़ेचिंग सॉल्यूशन में रिले से कड़ी मेहनत से अर्जित पाठ शामिल हैं और प्रदर्शन और कोलोकेशन के बीच चयन करने से पीड़ित नहीं है।

मैं इस बात पर जोर देना चाहता हूं कि यह केवल बड़े ऐप्स के बारे में नहीं है। बड़े ऐप में समस्याएँ सबसे अधिक ध्यान देने योग्य हैं, लेकिन छोटे ऐप जो npm से घटकों का एक गुच्छा आयात करते हैं, वे भी इन अक्षमताओं के सबसेट से ग्रस्त हैं। जैसे कि बहुत अधिक क्लाइंट-साइड कोड भेजना और उसे वॉटरफ़ॉल में लोड करना। या पहले से बहुत अधिक लोड हो रहा है। साथ ही, छोटे ऐप्स हमेशा के लिए छोटे ऐप्स नहीं रहते हैं। हम एक ऐसा समाधान चाहते हैं जो किसी भी आकार के ऐप के लिए बढ़िया काम करे, ठीक उसी तरह जैसे रिएक्ट घटक मॉडल आपके ऐप की जटिलता की परवाह किए बिना उसी तरह काम करता है।

अब, अपने विशिष्ट प्रश्न को संबोधित करने के लिए। रिले में "डेटा-संचालित निर्भरता" नामक एक विशेषता है। इसके बारे में सोचने का एक तरीका गतिशील import । गतिशील import हमेशा कुशल नहीं होता है। यदि आप कुछ कोड केवल तभी लोड करना चाहते हैं जब कोई शर्त सही हो (उदाहरण के लिए "क्या उपयोगकर्ता लॉग इन है" या "क्या उपयोगकर्ता के पास अपठित संदेश हैं"), तो आपका एकमात्र विकल्प इसे आलसी तरीके से ट्रिगर करना है। लेकिन इसका मतलब है कि आप "लात मार रहे हैं" (जैसे कि React.lazy ) केवल तभी जब कुछ उपयोग किया जाता है। वास्तव में बहुत देर हो चुकी है। उदाहरण के लिए, यदि आपके पास कोड-विभाजित घटकों (या डेटा के लिए प्रतीक्षा कर रहे घटक) के कई स्तर हैं, तो अंतरतम केवल ऊपर वाले के लोड होने के बाद ही लोड होना शुरू होगा। यह अक्षम है और एक नेटवर्क "झरना" है। रिले "डेटा-संचालित निर्भरता" आपको उन मॉड्यूल को निर्दिष्ट करने देती है जिन्हें आप क्वेरी के एक भाग के रूप में लाना चाहते हैं। यानी "अगर कुछ शर्त सही है, तो डेटा प्रतिक्रिया के साथ इस कोड खंड को शामिल करें"। यह आपको उन सभी कोड-विभाजित विखंडू को लोड करने देता है जिनकी आपको जितनी जल्दी हो सके आवश्यकता होगी। आपको प्रदर्शन के लिए कॉलोकेशन का व्यापार करने की आवश्यकता नहीं है। ऐसा लग सकता है कि यह कोई बड़ी बात नहीं है, लेकिन इसने उत्पाद कोड में शाब्दिक सेकंडों को काट दिया।

अब, फिर से, हम रिले को रिएक्ट में नहीं डाल रहे हैं, और हम लोगों को ग्राफ़क्यूएल का उपयोग करने के लिए बाध्य नहीं करना चाहते हैं। लेकिन अवधारणात्मक रूप से सुविधा ही सामान्य है, और इसके लिए एक अच्छा ओपन सोर्स समाधान होने से लोगों को आज की तुलना में बहुत अधिक कोड विभाजन करने की सुविधा मिलती है (और इस प्रकार बहुत कम क्लाइंट जेएस कोड शिप करते हैं!) उस सामान्य सुविधा को नहीं कहा जाएगा "डेटा संचालित निर्भरता" - यह सिर्फ एक रिले नाम है जिसका मैंने उल्लेख किया है। यह सुविधा एक बड़े अनुशंसित समाधान का हिस्सा होगी जिसमें ग्राफ़क्यूएल की आवश्यकता नहीं होती है। मैंने इसे सूची में केवल उस नाम से संदर्भित किया क्योंकि यह एक एकल बुलेट सूची बिंदु के लिए बहुत कुछ था।

मुझे आशा है कि यह इसे स्पष्ट करता है।