क्या तुल्यकालिक XMLHttpRequest का उपयोग करने का कोई कारण है?

Question 1

ऐसा लगता है कि हर कोई XMLHttpRequest के साथ अतुल्यकालिक अनुरोध करता है, लेकिन जाहिर है कि तुल्यकालिक अनुरोध करने की क्षमता इंगित करती है कि ऐसा करने के लिए एक वैध कारण हो सकता है। तो वह वैध कारण क्या हो सकता है?

Question 2

मुझे लगता है कि वे HTML 5 मानकों की प्रगति के रूप में अधिक लोकप्रिय हो सकते हैं। अगर एक वेब एप्लिकेशन को वेब श्रमिकों तक पहुंच दी जाती है, तो मैं डेवलपर्स को समर्पित वेब कार्यकर्ता का उपयोग करने के लिए समझदारी से अनुरोध कर सकता हूं, जैसा कि जोनाथन ने कहा, यह सुनिश्चित करने के लिए कि एक अनुरोध दूसरे से पहले होता है। एक धागे की वर्तमान स्थिति के साथ, यह आदर्श डिजाइन से कम है क्योंकि यह अनुरोध पूरा होने तक ब्लॉक करता है।

Question 3

उपयोगकर्ता डेटा सहेजने के लिए सिंक्रोनस XHRs उपयोगी हैं। यदि आप beforeunloadईवेंट को हैंडल करते हैं तो आप सर्वर को डेटा अपलोड कर सकते हैं क्योंकि उपयोगकर्ता पेज को बंद कर देता है।

यदि यह async विकल्प का उपयोग करके किया गया था, तो अनुरोध पूरा होने से पहले पृष्ठ बंद हो सकता है। इसे सिंक्रोनाइज़ करने से यह अनुरोध पूरा हो जाता है या अपेक्षित तरीके से विफल हो जाता है।

Question 4

अपडेट करें:

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

हालांकि, यह बुरा लग सकता है, ऐसे समय हो सकते हैं जहां यह महत्वपूर्ण है कि उपयोगकर्ता द्वारा पृष्ठ छोड़ने से पहले एक अनुरोध (या अनुरोधों की श्रृंखला) होती है, या एक कार्रवाई करने से पहले - अन्य कोड निष्पादन को अवरुद्ध करना (जैसे, बैक बटन को रोकना) हो सकता है। संभवतः खराब डिज़ाइन की गई प्रणाली के लिए त्रुटियों / रखरखाव को कम करना ; उस ने कहा, मैंने इसे जंगली और तनाव में कभी नहीं देखा है कि इसे टाला जाना चाहिए।

लाइब्रेरीज़, वादे की तरह , कॉलबैक के माध्यम से प्रक्रियाओं का पीछा करते हुए समकालिकता को बढ़ाती हैं। यह उन अधिकांश विकास आवश्यकताओं के अनुकूल है जहाँ इच्छा का आदेश दिया गया है, गैर-अवरुद्ध घटनाएँ जो ब्राउज़र को उपयोगकर्ता के लिए जवाबदेही बनाए रखने में सक्षम बनाती हैं (अच्छा UX)।

जैसा कि मोज़िला डॉक्स में कहा गया है कि ऐसे मामले हैं जहां आपको सिंक्रोनस अनुरोधों का उपयोग करना पड़ता है; हालाँकि, सूचीबद्ध भी एक वर्कअराउंड है जो ऐसे मामलों के लिए बीकन (आईई / सफारी में उपलब्ध नहीं) का उपयोग करता है । हालांकि यह प्रायोगिक है, अगर यह कभी भी मानकों-स्वीकृति तक पहुंच जाता है, तो यह संभवतः सिंक्रोनस-अनुरोध ताबूत में एक कील लगा सकता है।

आप किसी भी प्रकार के लेन-देन-प्रसंस्करण में या जहां भी संचालन का कोई आदेश आवश्यक है, समकालिक कॉल करना चाहते हैं।

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

एक और कारण होगा जब एक वेबसर्विस के साथ काम करना, खासकर जब सर्वर पर गणित प्रदर्शन करना।

उदाहरण: सर्वर में 1 का मान वाला एक चर है।
 Step (1) Perform Update: add 1 to variable
 Step (2) Perform Update: set variable to the power of 3
 End Value: variable equals 8
यदि चरण (2) पहले होता है, तो अंतिम मूल्य 2 है, 8 नहीं; इस प्रकार ऑपरेशन मामलों और सिंक्रनाइज़ेशन के आदेश की जरूरत है।

बहुत कम बार कहा जाता है कि एक सामान्य वास्तविक दुनिया उदाहरण में एक तुल्यकालिक कॉल को उचित ठहराया जा सकता है। शायद जब लॉगिन पर क्लिक करते हैं और फिर उस साइट के एक हिस्से पर क्लिक करते हैं जिसमें उपयोगकर्ता को लॉग इन करने की आवश्यकता होती है।

जैसा कि दूसरों ने कहा है, यह आपके ब्राउज़र को टाई करेगा, इसलिए जहाँ आप कर सकते हैं, उससे दूर रहें।

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

Question 5

मेरा कहना है कि यदि आप अनुरोध को पूरा करने के दौरान उपयोगकर्ता के ब्राउज़र को अवरुद्ध करने पर विचार करते हैं, तो निश्चित रूप से एक तुल्यकालिक अनुरोध का उपयोग करें।

यदि अनुरोधों का क्रमांकन आपका उद्देश्य है, तो आपके पिछले अनुरोध के ऑन-लाइन कॉलबैक को अगली पंक्ति में पूरा करने के लिए, यह async अनुरोधों का उपयोग करके पूरा किया जा सकता है।

Question 6

कई वास्तविक दुनिया के मामले हैं जहां UI अवरुद्ध करना बिल्कुल वांछित व्यवहार है।

कई फ़ील्ड्स के साथ एक ऐप लें और कुछ फ़ील्ड्स को इस क्षेत्र के मूल्य और अन्य फ़ील्ड मानों के रूप में इनपुट प्रदान करने वाले एक दूरस्थ सर्वर को xmlhttp कॉल द्वारा मान्य किया जाना चाहिए।

तुल्यकालिक मोड में, तर्क सरल है, उपयोगकर्ता द्वारा अनुभव किया गया अवरोध बहुत कम है और कोई समस्या नहीं है।

Async मोड में, उपयोगकर्ता किसी भी अन्य फ़ील्ड के मूल्यों को बदल सकता है जबकि प्रारंभिक एक को मान्य किया जा रहा है। ये परिवर्तन अन्य xmlhttp कॉल को आरंभिक क्षेत्र के मानों के साथ ट्रिगर करेंगे जो अभी तक मान्य नहीं हैं। यदि प्रारंभिक सत्यापन विफल हो गया तो क्या होगा? शुद्ध गंदगी। यदि सिंक मोड अपग्रेड और निषिद्ध हो जाता है, तो एप्लिकेशन लॉजिक को संभालने के लिए दुःस्वप्न बन जाता है। मूल रूप से ताले को प्रबंधित करने के लिए आवेदन को फिर से लिखा जाना चाहिए (जैसे सत्यापन प्रक्रियाओं के दौरान अन्य मदों को अक्षम करें)। कोड जटिलता काफी बढ़ जाती है। ऐसा करने में विफल रहने से तर्क विफलता और अंततः डेटा भ्रष्टाचार हो सकता है।

मूल रूप से सवाल यह है कि क्या अधिक महत्वपूर्ण, गैर-अवरुद्ध यूआई अनुभव या डेटा भ्रष्टाचार का खतरा है? उत्तर एप्लिकेशन डेवलपर के पास रहना चाहिए, न कि डब्ल्यू 3 सी।

Question 7

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

यह विचार नींव वास्तव में Vol7ron के उत्तर पर फैलता है। लेन-देन-आधारित प्रक्रिया वास्तव में एकमात्र समय है जहां तुल्यकालिक अनुरोध किए जाने चाहिए। ज्यादातर अन्य मामलों में, एसिंक्रोनस कॉल बेहतर विकल्प हैं, जिसमें कॉल के बाद, डोम को आवश्यक रूप से अपडेट किया जाता है। कई मामलों में, जैसे कि उपयोगकर्ता-आधारित प्रणालियाँ, आपके पास "अनधिकृत उपयोगकर्ताओं" के लिए कुछ सुविधाएँ लॉक हो सकती हैं, जब तक उनके पास, se, लॉग इन नहीं हो। अतुल्यकालिक कॉल के बाद उन सुविधाओं को DOM अद्यतन प्रक्रिया के माध्यम से अनलॉक किया जाता है।

मुझे अंत में कहना होगा कि मैं इस मामले पर अधिकांश व्यक्तियों के बिंदुओं से सहमत हूं: जहां भी संभव हो, तुल्यकालिक XHR अनुरोधों से बचा जाना चाहिए, जिस तरह से यह काम करता है, ब्राउज़र तुल्यकालिक कॉल के साथ लॉक हो जाता है। सिंक्रोनस अनुरोधों को लागू करते समय, उन्हें ऐसे तरीके से किया जाना चाहिए जहां ब्राउज़र सामान्य रूप से लॉक हो जाएगा, वैसे भी, पेज लोड होने से पहले HEAD सेक्शन में वास्तव में होता है।

Question 8

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

Question 9

jQuery कुछ परिस्थितियों में आंतरिक रूप से AJAX का उपयोग करता है। HTML में स्क्रिप्ट्स सम्मिलित करते समय, ब्राउज़र उन्हें निष्पादित नहीं करेगा। स्क्रिप्ट को मैन्युअल रूप से निष्पादित करने की आवश्यकता है। ये स्क्रिप्ट क्लिक हैंडलर संलग्न कर सकते हैं। हैंडलर संलग्न होने से पहले एक उपयोगकर्ता पर एक क्लिक पर मान लें और पृष्ठ के रूप में कार्य नहीं करेगा। इसलिए दौड़ की स्थितियों को रोकने के लिए, उन लिपियों को लाने के लिए तुल्यकालिक AJAX का उपयोग किया जाएगा। क्योंकि सिंक्रोनस AJAX प्रभावी रूप से बाकी सब को ब्लॉक करता है, यह सुनिश्चित किया जा सकता है कि स्क्रिप्ट और ईवेंट सही क्रम में निष्पादित होते हैं।

Question 10

कारण:

मान लीजिए कि आपके पास एक अजाक्स एप्लिकेशन है जिसे सर्वर से विभिन्न डेटा लोड करने के लिए आधा दर्जन http करने की आवश्यकता है, इससे पहले कि उपयोगकर्ता कोई भी बातचीत कर सके।

जाहिर है आप चाहते हैं कि यह ऑनलोड से ट्रिगर हो।

कोड के बिना किसी भी जोड़ा जटिलता के लिए सिंक्रोनस कॉल इसके लिए बहुत अच्छी तरह से काम करता है। यह सरल और सीधा है।

दोष यह है:

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

वैकल्पिक?

हालाँकि कई ब्राउज़र सभी विंडो / टैब को बंद कर देते हैं, जबकि जब जावास्क्रिप्ट उनमें से किसी एक में व्यस्त होता है, जो एक बेवकूफ ब्राउज़र डिज़ाइन समस्या है - लेकिन परिणामस्वरूप संभवतः धीमा नेटवर्क पर अवरुद्ध करना विनम्र नहीं है यदि यह उपयोगकर्ताओं को अन्य टैब का उपयोग करने से रोकता है। जबकि ajax पेज लोड होने की प्रतीक्षा कर रहा है।

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

http://www.w3.org/TR/2012/WD-XMLHttpRequest-201201/17/#the-open-method यह देखने में ऐसा नहीं लगता (खंड 4.7.3 देखें) आपको ब्लॉकिंग मोड का उपयोग करते समय एक टाइमआउट सेट करने की अनुमति नहीं है । मेरे लिए सहज ज्ञान युक्त लगता है: जब भी कोई IO को अवरुद्ध करता है तो वह एक उचित समयबाह्य समय निर्धारित करने के लिए विनम्र होता है, इसलिए क्यों io को अवरुद्ध करने की अनुमति देता है लेकिन उपयोगकर्ता द्वारा निर्दिष्ट टाइमआउट के साथ नहीं?

मेरी राय है कि कुछ स्थितियों में अवरोधक IO की महत्वपूर्ण भूमिका है लेकिन इसे सही तरीके से लागू किया जाना चाहिए। हालांकि यह एक ब्राउज़र टैब या विंडो के लिए अन्य सभी टैब या विंडो को लॉक करने के लिए स्वीकार्य नहीं है, यह एक ब्राउज़र डिज़ाइन दोष है। शर्म कहाँ शर्म की वजह से। लेकिन कुछ मामलों में व्यक्तिगत टैब या विंडो कुछ सेकंड के लिए गैर-उत्तरदायी होना (यानी अवरुद्ध IO / HTTP GET का उपयोग करना) के लिए कुछ स्थितियों में यह पूरी तरह स्वीकार्य है - उदाहरण के लिए, पृष्ठ लोड पर, शायद बहुत अधिक डेटा इससे पहले कि कुछ भी किया जा सकता है की जरूरत है। कभी-कभी ठीक से लागू किया गया अवरुद्ध कोड इसे करने का सबसे साफ तरीका है।

बेशक इस मामले में समतुल्य फ़ंक्शन अतुल्यकालिक http का उपयोग करके प्राप्त किया जा सकता है, लेकिन किस प्रकार की नासमझ दिनचर्या की आवश्यकता है?

मुझे लगता है कि मैं इन पंक्तियों के साथ कुछ करने की कोशिश करूंगा:

दस्तावेज़ लोड होने पर, निम्न कार्य करें: 1: 6 ग्लोबल "डन" फ़्लैग वैरिएबल सेट करें, 0. 2 के लिए आरम्भ: सभी 6 पृष्ठभूमि प्राप्त करें

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

यदि प्राप्त करने का क्रम जारी है - या यदि वेबसर्वर एक ही समय में कई अनुरोधों को स्वीकार करने में असमर्थ था - तो आपको इसके लिए कुछ की आवश्यकता होगी:

ऑनलोड () में, पहले http गेट लॉन्च किया जाएगा। कॉलबैक में, दूसरा लॉन्च किया जाएगा। यह कॉलबैक में, तीसरा - और इसी तरह आगे, प्रत्येक कॉलबैक के साथ अगला HTTP GET लॉन्च किया गया है। जब अंतिम वापस आ जाता है, तो इसे वास्तविक इनिट () दिनचर्या कहेंगे।

Question 11

यदि आप उत्पादन कोड में एक तुल्यकालिक कॉल करते हैं तो क्या होगा?

आकाश नीचे गिर जाता है।

गंभीरता से नहीं, उपयोगकर्ता को लॉक अप ब्राउज़र पसंद नहीं है।

Question 12

मैं इसका उपयोग एक यूज़रनेम को मान्य करने के लिए करता हूँ, जाँच के दौरान कि यूज़रनेम पहले से मौजूद नहीं है।

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

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

Question 13

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

इस दृष्टिकोण के साथ समस्या यह है कि आप कार्रवाई समाप्त होने तक उपयोगकर्ता के ब्राउज़र को "ब्लॉक" करते हैं (जब तक कि अनुरोध वापस नहीं आता है, खत्म, लोड, आदि)। इसलिए इसका उपयोग करते समय सावधान रहें।

Question 14

मैं कोड विकसित करते समय सिंक्रोनस कॉल का उपयोग करता हूं- आपने सर्वर से और सर्वर से अनुरोध करते समय जो कुछ भी किया वह एक त्रुटि के कारण को अस्पष्ट कर सकता है।

जब यह काम कर रहा होता है, तो मैं इसे अतुल्यकालिक बना देता हूं, लेकिन मैं एक गर्भपात टाइमर और विफलता कॉलबैक को शामिल करने की कोशिश करता हूं, क्योंकि इससे आपको कभी भी नुकसान नहीं होता है ...

Question 15

SYNC बनाम ASYNC: क्या अंतर है?

मूल रूप से यह इसके लिए उबलता है:

console.info('Hello, World!');
doSomething(function handleResult(result) {
    console.info('Got result!');
});
console.info('Goodbye cruel world!');

जब doSomethingहै तुल्यकालिक इस प्रिंट होगा:

Hello, World!
Got result!
Goodbye cruel world!

इसके विपरीत, यदि doSomethingहै अतुल्यकालिक , इस प्रिंट होगा:

Hello, World!
Goodbye cruel world!
Got result!

क्योंकि फ़ंक्शन doSomethingयह काम कर रहा है अतुल्यकालिक रूप से, यह काम होने से पहले ही वापस आ जाता है। तो हम केवल मुद्रण के बाद परिणाम प्राप्त करते हैंGoodbye cruel world!

यदि हम एक एसिंच कॉल के परिणाम पर निर्भर होते हैं, तो हमें कॉलबैक में निर्भर कोड रखने की आवश्यकता है:

console.info('Hello, World!');
doSomething(function handleResult(result) {
    console.info('Got result!');
    if (result === 'good') {
        console.info('I feel great!');
    }
    else {
        console.info('Goodbye cruel world!');
    }
});

जैसे, सिर्फ इस तथ्य के लिए कि 2 या तीन चीजों को क्रम में होने की आवश्यकता है, उन्हें सिंक्रोनाइज़ करने का कोई कारण नहीं है (हालांकि सिंक कोड ज्यादातर लोगों के लिए काम करना आसान है)।

का उपयोग क्यों करते हैं?

कुछ स्थितियां हैं जहां आपको फ़ंक्शन के पूर्ण होने से पहले परिणाम की आवश्यकता होती है। इस परिदृश्य पर विचार करें:

function lives(name) {
    return (name !== 'Elvis');
}
console.info('Elvis ' + (lives('Elvis') ? 'lives!' : 'has left the building...');

मान लीजिए कि हमें कॉलिंग कोड ( console.infoलाइन) पर कोई नियंत्रण नहीं है और livesसर्वर को पूछने के लिए फ़ंक्शन को बदलने की आवश्यकता है ... कोई रास्ता नहीं है कि हम सर्वर से एक async अनुरोध कर सकते हैं livesऔर अभी भी livesपूर्ण होने से पहले हमारी प्रतिक्रिया है । इसलिए हम नहीं जानते कि वापस लौटना है trueया नहींfalse । फ़ंक्शन पूरा होने से पहले परिणाम प्राप्त करने का एकमात्र तरीका एक सिंक्रोनस अनुरोध है।

जैसा कि Sami Samhuriउनके उत्तर में उल्लेख किया गया है, एक बहुत ही वास्तविक परिदृश्य जहां आपको अपने सर्वर अनुरोध के जवाब की आवश्यकता हो सकती है इससे पहले कि आपका फ़ंक्शन समाप्त हो जाए, यह onbeforeunloadघटना है, क्योंकि यह आपके ऐप से अंतिम फ़ंक्शन है जो कभी भी विंडो बंद होने से पहले चलेगा।

मैं कुछ भी नहीं कहा, लेकिन मैं आसानी से कर रहे हैं के रूप में उन का उपयोग करें

कृपया नहीं। सिंक्रोनस कॉल आपके ब्राउज़र को लॉक कर देते हैं और ऐप को गैर-जिम्मेदार महसूस करते हैं। लेकिन आप सही हैं। Async कोड कठिन है। हालाँकि, इससे निपटने का एक तरीका बहुत आसान है। सिंक कोड जितना आसान नहीं है, लेकिन यह करीब हो रहा है: प्रोमिस एस।

यहाँ एक उदाहरण दिया गया है: कोड के तीसरे खंड के चलने से पहले दो एस्किंच कॉल को पूरी तरह से पूरा करना चाहिए:

var carRented = rentCar().then(function(car){
  gasStation.refuel(car);
});

var hotelBooked = bookHotel().then(function(reservation) {
  reservation.confirm();
});

Promise.all([carRented, hotelBooked]).then(function(){
  // At this point our car is rented and our hotel booked.
  goOnHoliday();
});

यहां बताया गया है कि आप इसे कैसे लागू करेंगे bookHotel:

function bookHotel() {
  return new Promise(function(resolve, reject){
    if (roomsAvailable()) {
      var reservation = reserveRoom();
      resolve(reservation);
    }
    else {
      reject(new Error('Could not book a reservation. No rooms available.'));
    }
  });
}

यह भी देखें: वादे के साथ बेहतर जावास्क्रिप्ट लिखें ।

Question 16

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

आप अपने जेएस कोड में सब कुछ बदले बिना इसे करना चाहेंगे। Async / सिंक फ़्लैग आपको वह क्षमता प्रदान करता है, और यदि सही तरीके से डिज़ाइन किया गया है, तो आपको अपने कोड में केवल एक लाइन बदलने / varनिष्पादन समय के दौरान एक का मान बदलने की आवश्यकता है ।

Question 17

फ़ायरफ़ॉक्स (और सभी गैर-IE ब्राउज़र संभावित) async XHR timeOut का समर्थन नहीं करता है।

HTML5 WebWorkers टाइमआउट का समर्थन करते हैं। तो, आप समयबद्ध व्यवहार के साथ Async की तरह XHR को लागू करने के लिए समय के साथ WebWorker के लिए सिंक XHR अनुरोध को लपेटना चाह सकते हैं।

Question 18

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

Question 19

तुल्यकालिक HTTP अनुरोधों का उपयोग करना मोबाइल विज्ञापन व्यवसाय में एक आम बात है।

कंपनियां (उर्फ "प्रकाशक") जो एप्लिकेशन बनाते हैं, राजस्व उत्पन्न करने के लिए अक्सर विज्ञापन चलाते हैं। इसके लिए वे विज्ञापन एसडीके को अपने ऐप में इंस्टॉल करते हैं। कई मौजूद हैं (MoPub, Ogury, TapJob, AppNext, Google Ads AdMob)।

ये SDK एक वेबव्यू में विज्ञापनों की सेवा देंगे।

जब एक उपयोगकर्ता को विज्ञापन की सेवा है, यह एक हो गया है चिकनी , अनुभव विशेष रूप से जब एक वीडियो खेल रहा है। किसी भी समय कोई बफरिंग या लोडिंग नहीं होनी चाहिए।

इसे हल करने के लिए precachingप्रयोग किया जाता है। जहां मीडिया (चित्र / वीडियो / आदि) वेबव्यू की पृष्ठभूमि में सिंक्रोनाइज़ किए गए हैं।

इसे अतुल्यकालिक रूप से क्यों नहीं किया जाता है?

यह विश्व स्तर पर स्वीकृत मानक का हिस्सा है
SDK इस onloadघटना को यह जानने के लिए सुनता है कि उपयोगकर्ता के लिए विज्ञापन कब "तैयार" किया जाएगा

की निंदा के साथ तुल्यकालिक XMLHttpRequests , विज्ञापन व्यापार सबसे अधिक संभावना है कि भविष्य में मानक बदलने के लिए जब तक एक और तरीका निर्धारित किया जा सकता मजबूर किया जाएगा।

Question 20

तुल्यकालिक XHR (गैर-उत्पादन) आंतरिक उपकरण और / या ढांचे के विकास के लिए बहुत उपयोगी हो सकता है। उदाहरण के लिए, उदाहरण के लिए, आप कोड लाइब्रेरी को पहले एक्सेस पर सिंक्रोनाइज़ करना चाहते थे, जैसे:

get draw() 
{
    if (!_draw)
    {
       let file;
       switch(config.option)
       {
           case 'svg':
              file = 'svgdraw.js';
              break;
           case 'canvas':
              file = 'canvasdraw.js';
              break;
           default:
              file = 'webgldraw.js';
       }

       var request = new XMLHttpRequest();
       request.open('GET', file, false);
       request.send(null);
       _draw = eval(request.responseText);
    }

    return _draw;
}

इससे पहले कि आप खुद को टिज़ी में पाएं और बुराई को हटाने के लिए आँख बंद करके ध्यान रखें कि यह केवल स्थानीय परीक्षण के लिए है। निर्माण के लिए, पहले ही सेट वापस ले लिया जाएगा।

तो, आपका कोड इस तरह दिख सकता है:

foo.drawLib.draw.something(); //loaded on demand

यह किसी चीज का केवल एक उदाहरण है जो सिंक XHR के बिना करना असंभव होगा। आप इस लाइब्रेरी को सामने, हाँ में लोड कर सकते हैं, या एक वादा / कॉलबैक कर सकते हैं, लेकिन आप सिंक एक्सएचआर के बिना समान रूप से काम नहीं कर सकते। इस बारे में सोचें कि इस प्रकार की चीज़ आपके कोड को कितना साफ कर सकती है ...

टूलींग और फ्रेमवर्क (स्थानीय रूप से चलने) के लिए आप इसके साथ क्या कर सकते हैं, इसकी सीमा केवल आपकी कल्पना द्वारा सीमित है। हालाँकि, ऐसा प्रतीत होता है कि कल्पना जावास्क्रिप्ट दुनिया में थोड़ी सीमित है।

Question 21

वैसे यहाँ एक अच्छा कारण है। मैं एक http अनुरोध करना चाहता था, परिणाम के आधार पर, इनपुट प्रकार = फ़ाइल पर कॉल क्लिक करें ()। यह अतुल्यकालिक xhr या लाने के साथ संभव नहीं है। कॉलबैक संदर्भ "उपयोगकर्ता कार्रवाई" खो देता है, इसलिए कॉल क्लिक () को अनदेखा किया जाता है। तुल्यकालिक xhr ने मेरी बेकन को बचाया।

onclick(event){
    //here I can, but I don't want to.
    //document.getElementById("myFileInput").click();
    fetch("Validate.aspx", { method : "POST", body: formData, credentials: "include" })
    .then((response)=>response.json())
    .then(function (validResult) {
        if (validResult.success) {
            //here, I can't.
            document.getElementById("myFileInput").click();
        }
    });
}