🎶 👽 🌗 मानव भाषा में "बीजगणितीय प्रभाव" 👌🏿 👸🏾 ⏱️

अनुवादक टिप्पणी: यह दान Abramov, एक प्रतिक्रिया योगदानकर्ता द्वारा एक महान लेख का अनुवाद है। उनके उदाहरण जेएस के लिए लिखे गए हैं, लेकिन वे किसी भी भाषा में डेवलपर्स के लिए समान रूप से स्पष्ट होंगे। विचार सभी के लिए सामान्य है।

क्या आपने बीजीय प्रभावों के बारे में सुना है?

मेरी पहली कोशिश यह पता लगाने की है कि वे कौन हैं और मुझे क्यों उत्तेजित करना चाहिए वे असफल थे। मुझे कई पीडीएफ मिले, लेकिन उन्होंने मुझे और भी अधिक भ्रमित किया। (किसी कारण से, मैं अकादमिक लेख पढ़ते हुए सो जाता हूं।)

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

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

(अस्वीकरण: मैं प्रोग्रामिंग भाषाओं के क्षेत्र में शोधकर्ता नहीं हूं और मेरे स्पष्टीकरण में कुछ गड़बड़ हो सकती है। तो मुझे बताएं कि क्या आप गलत हैं!)

यह अभी भी उत्पादन में जल्दी है

वर्तमान में बीजगणितीय प्रभाव प्रोग्रामिंग भाषाओं के अध्ययन के क्षेत्र से एक प्रयोगात्मक अवधारणा है। इसका मतलब यह है कि इसके विपरीत if , के for या यहां तक कि async/await अभिव्यक्तियों, आप सबसे अधिक संभावना है कि उत्पादन में अभी उनका उपयोग नहीं कर पाएंगे। वे केवल कुछ भाषाओं द्वारा समर्थित हैं जो विशेष रूप से इस विचार का अध्ययन करने के लिए बनाए गए थे। OCaml में उनके कार्यान्वयन में प्रगति है, जो ... अभी भी जारी है । दूसरे शब्दों में, देखें, लेकिन अपने हाथों से स्पर्श न करें।

यह मुझे क्यों परेशान करना चाहिए?

कल्पना करें कि आप goto का उपयोग करके कोड लिख रहे हैं, और कोई आपको बता रहा है कि if और निर्माण के लिए। या हो सकता है कि आपको कॉलबैक नरक में रखा गया हो और कोई व्यक्ति आपको async/await । बहुत अच्छा है, है ना?

यदि आप उस व्यक्ति के प्रकार हैं जो फैशनेबल बनने से कुछ साल पहले प्रोग्रामिंग नवाचार सीखना पसंद करता है, तो यह बीजीय प्रभावों में रुचि लेने का समय हो सकता है। हालांकि जरूरी नहीं है। यह कैसे 1999 में async/await बारे में बात करने के लिए है।

खैर, ये किस तरह के प्रभाव हैं?

नाम थोड़ा भ्रमित करने वाला हो सकता है, लेकिन विचार सरल है। यदि आप try/catch ब्लॉक से परिचित हैं, तो आप जल्दी से बीजीय प्रभाव को समझेंगे।

आइए try/catch याद try/catch । मान लें कि आपके पास एक फ़ंक्शन है जो अपवादों को फेंकता है। शायद इसके और catch बीच कई नेस्टेड कॉल हैं:

 function getName(user) { let name = user.name; if (name === null) { throw new Error('  '); } return name; } function makeFriends(user1, user2) { user1.friendNames.add(getName(user2)); user2.friendNames.add(getName(user1)); } const arya = { name: null }; const gendry = { name: '' }; try { makeFriends(arya, gendry); } catch (err) { console.log(",   : ", err); }

हम getName अंदर एक अपवाद को फेंक देते हैं, लेकिन यह "पॉप अप" makeFriends माध्यम से निकटतम catch तक makeFriends जाता है। यह try/catch की मुख्य संपत्ति है। त्रुटि से निपटने के लिए इंटरमीडिएट कोड की आवश्यकता नहीं है।

C जैसी भाषाओं में त्रुटि कोड के विपरीत, जब आप try/catch हैं तो आपको शीर्ष स्तर पर त्रुटि को संभालने के लिए प्रत्येक मध्यवर्ती स्तर के माध्यम से त्रुटियों को मैन्युअल रूप से पारित करना होगा। अपवाद अपने आप पॉप अप हो जाते हैं।

बीजगणितीय प्रभावों से इसका क्या लेना-देना है?

उपरोक्त उदाहरण में, जैसे ही हमें कोई त्रुटि दिखाई देती है, हम प्रोग्राम को निष्पादित करना जारी नहीं रख पाएंगे। जब हम खुद को catch में पाते हैं, तो सामान्य प्रोग्राम निष्पादन बंद हो जाएगा।

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

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

 function getName(user) { let name = user.name; if (name === null) { name = perform 'ask_name'; } return name; } function makeFriends(user1, user2) { user1.friendNames.add(getName(user2)); user2.friendNames.add(getName(user1)); } const arya = { name: null }; const gendry = { name: '' }; try { makeFriends(arya, gendry); } handle(effect) { if (effect === 'ask_name') { resume with ' '; } }

(मैं २०२५ से उन सभी पाठकों से माफी माँगता हूँ जो "ईएस २०२५" के लिए इंटरनेट पर खोज करते हैं और इस लेख में आते हैं। यदि तब तक बीजीय प्रभाव जावास्क्रिप्ट का हिस्सा बन जाएंगे, तो मुझे लेख को अपडेट करने में खुशी होगी! "

throw बजाय throw हम काल्पनिक कीवर्ड perform उपयोग perform । इसी तरह, try/catch बजाय try/catch हम काल्पनिक try/handle उपयोग करते हैं। सटीक सिंटैक्स यहाँ मायने नहीं रखता है - मैं सिर्फ इस विचार को स्पष्ट करने के लिए कुछ के साथ आया था।

तो यहाँ क्या हो रहा है? आइए एक नज़र डालें।

एक त्रुटि को फेंकने के बजाय, हम प्रभाव को पूरा करते हैं । जिस तरह हम किसी भी वस्तु को फेंक सकते हैं, यहाँ हम प्रसंस्करण के लिए कुछ मूल्य पारित कर सकते हैं। इस उदाहरण में, मैं एक स्ट्रिंग पास करता हूं, लेकिन यह एक ऑब्जेक्ट या किसी अन्य डेटा प्रकार हो सकता है:

 function getName(user) { let name = user.name; if (name === null) { name = perform 'ask_name'; } return name; }

जब हम एक अपवाद फेंकते हैं, तो इंजन कॉल स्टैक में निकटतम try/catch हैंडलर की तलाश करता है। इसी तरह, जब हम किसी प्रभाव को निष्पादित करते हैं , तो इंजन स्टैक के शीर्ष पर निकटतम try/handle इफेक्ट हैंडलर की तलाश करेगा:

 try { makeFriends(arya, gendry); } handle(effect) { if (effect === 'ask_name') { resume with ' '; } }

यह प्रभाव हमें यह तय करने की अनुमति देता है कि नाम निर्दिष्ट न होने पर स्थिति को कैसे संभालना है। यहां नया (अपवादों की तुलना में) के resume with काल्पनिक resume with :

 try { makeFriends(arya, gendry); } handle(effect) { if (effect === 'ask_name') { resume with ' '; } }

यह कुछ ऐसा है जिसे आप try/catch साथ नहीं कर सकते। यह हमें उस स्थान पर वापस जाने की अनुमति देता है जहां हमने प्रभाव डाला था और हैंडलर से कुछ वापस पारित किया था । : -ओ

 function getName(user) { let name = user.name; if (name === null) { // 1.     name = perform 'ask_name'; // 4. ...     (name   ' ') } return name; } // ... try { makeFriends(arya, gendry); } handle(effect) { // 2.    ( try/catch)  (effect === 'ask_name') { // 3. ,      (    try/catch!) resume with ' '; } }

आरामदायक होने में थोड़ा समय लगता है, लेकिन वैचारिक रूप से यह वापसी के साथ try/catch से बहुत अलग नहीं है।

ध्यान दें, हालांकि, बीजीय प्रभाव केवल try/catch तुलना में बहुत अधिक शक्तिशाली उपकरण हैं। त्रुटि पुनर्प्राप्ति कई संभावित उपयोग मामलों में से एक है। मैंने इस उदाहरण के साथ ही शुरुआत की क्योंकि मेरे लिए इसे समझना सबसे आसान था।

समारोह का कोई रंग नहीं है

बीजगणितीय प्रभावों के अतुल्यकालिक कोड के लिए दिलचस्प निहितार्थ हैं।

async/await भाषाओं में async/await फ़ंक्शंस में आमतौर पर एक "रंग" ( रूसी ) होता है। उदाहरण के लिए, जावास्क्रिप्ट में, हम सिर्फ getName असिंक्रोनस नहीं बना सकते हैं बिना makeFriends को संक्रमित makeFriends और async के साथ इसके कॉलिंग फ़ंक्शन। यह एक वास्तविक दर्द हो सकता है यदि कोड का हिस्सा कभी-कभी तुल्यकालिक और कभी-कभी अतुल्यकालिक होना चाहिए।

 //       ... async getName(user) { // ... } //       ... async function makeFriends(user1, user2) { user1.friendNames.add(await getName(user2)); user2.friendNames.add(await getName(user1)); } //   ... async getName(user) { // ... }

जावास्क्रिप्ट जनरेटर एक समान तरीके से काम करते हैं: यदि आप जनरेटर के साथ काम करते हैं, तो सभी मध्यवर्ती कोड को जनरेटर के बारे में भी जानना चाहिए।

खैर, इससे क्या लेना-देना है?

एक पल के लिए, आइए हम async / इंतजार के बारे में भूल जाएं और अपने उदाहरण पर वापस जाएं:

 function getName(user) { let name = user.name; if (name === null) { name = perform 'ask_name'; } return name; } function makeFriends(user1, user2) { user1.friendNames.add(getName(user2)); user2.friendNames.add(getName(user1)); } const arya = { name: null }; const gendry = { name: '' }; try { makeFriends(arya, gendry); } handle(effect) { if (effect === 'ask_name') { resume with ' '; } }

क्या होगा अगर हमारे प्रभाव हैंडलर "स्पेयर नाम" को सिंक्रोनाइज़ नहीं कर सकते हैं? यदि हम इसे डेटाबेस से प्राप्त करना चाहते हैं तो क्या होगा?

यह पता चला है कि हम getName या makeFriends कोई बदलाव किए बिना अपने प्रभाव हैंडलर से एसिंक्रोनसली के resume with कर सकते हैं:

 function getName(user) { let name = user.name; if (name === null) { name = perform 'ask_name'; } return name; } function makeFriends(user1, user2) { user1.friendNames.add(getName(user2)); user2.friendNames.add(getName(user1)); } const arya = { name: null }; const gendry = { name: '' }; try { makeFriends(arya, gendry); } handle(effect) { if (effect === 'ask_name') { setTimeout(() => { resume with ' '; }, 1000); } }

इस उदाहरण में, हम केवल एक सेकंड के बाद resume with कहते हैं। आप resume with कॉलबैक के resume with पर विचार कर सकते हैं, जिसे आप केवल एक बार कॉल कर सकते हैं। (आप इस बात को '' एक बार सीमित निरंतरता '' कहकर मित्रों को दिखा सकते हैं (शब्द का निरन्तर जारी रहना अभी तक रूसी में एक स्थिर अनुवाद नहीं हुआ है - लगभग अनुवाद।)।

अब बीजीय प्रभावों के यांत्रिकी थोड़ा स्पष्ट होना चाहिए। जब हम एक त्रुटि फेंकते हैं, तो जावास्क्रिप्ट इंजन प्रक्रिया में स्थानीय चर को नष्ट करके स्टैक को स्पिन करता है। हालांकि, जब हम प्रभाव को निष्पादित करते हैं, तो हमारा काल्पनिक इंजन कॉलबैक बनाता है (वास्तव में एक "निरंतरता फ्रेम", लगभग अनुवाद।) हमारे फ़ंक्शन के बाकी हिस्सों के resume with , और इसके resume with करें।

फिर से, एक अनुस्मारक: विशिष्ट वाक्यविन्यास और विशिष्ट कीवर्ड पूरी तरह से केवल इस लेख के लिए आविष्कार किए गए हैं। बिंदु इसमें नहीं है, लेकिन यांत्रिकी में है।

स्वच्छता नोट

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

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

वे आपको कोड लिखने की अनुमति देते हैं जो यह बताता है कि आप क्या कर रहे हैं:

 function enumerateFiles(dir) { const contents = perform OpenDirectory(dir); perform Log('Enumerating files in ', dir); for (let file of contents.files) { perform HandleFile(file); } perform Log('Enumerating subdirectories in ', dir); for (let directory of contents.dir) { //           enumerateFiles(directory); } perform Log('Done'); }

और बाद में इसे कुछ इस तरह से लपेटें कि यह "आप" कैसे करें:

 let files = []; try { enumerateFiles('C:\\'); } handle(effect) { if (effect instanceof Log) { myLoggingLibrary.log(effect.message); resume; } else if (effect instanceof OpenDirectory) { myFileSystemImpl.openDir(effect.dirName, (contents) => { resume with contents; }); } else if (effect instanceof HandleFile) { files.push(effect.fileName); resume; } } //  `files`

जिसका अर्थ है कि ये हिस्से एक पुस्तकालय बन सकते हैं:

 import { withMyLoggingLibrary } from 'my-log'; import { withMyFileSystem } from 'my-fs'; function ourProgram() { enumerateFiles('C:\\'); } withMyLoggingLibrary(() => { withMyFileSystem(() => { ourProgram(); }); });

Async / प्रतीक्षा या जनरेटर के विपरीत, बीजीय प्रभाव को "मध्यवर्ती" कार्यों की जटिलता की आवश्यकता नहीं होती है। हमारे प्रोग्राम के अंदर हमारी कॉल गहरी हो सकती है, लेकिन जब तक प्रत्येक प्रभाव के लिए एक प्रभाव हैंडलर है कि यह ऊपर कहीं निष्पादित कर सकता है, तो हमारा कोड काम करना जारी रखेगा।

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

 import { withFakeFileSystem } from 'fake-fs'; function withLogSnapshot(fn) { let logs = []; try { fn(); } handle(effect) { if (effect instanceof Log) { logs.push(effect.message); resume; } } // Snapshot  . expect(logs).toMatchSnapshot(); } test('my program', () => { const fakeFiles = [ /* ... */ ]; withFakeFileSystem(fakeFiles, () => { withLogSnapshot(() => { ourProgram(); }); }); });

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

प्रकार नोट

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

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

क्या मुझे जावास्क्रिप्ट में बीजगणितीय प्रभावों की आवश्यकता है?

ईमानदारी से, मुझे नहीं पता। वे बहुत शक्तिशाली हैं, और यह तर्क दिया जा सकता है कि वे जावास्क्रिप्ट जैसी भाषा के लिए बहुत शक्तिशाली हैं।

मुझे लगता है कि वे उन भाषाओं के लिए बहुत उपयोगी हो सकते हैं, जहां परिवर्तनशीलता दुर्लभ है और जहां मानक पुस्तकालय पूरी तरह से प्रभावों का समर्थन करते हैं। यदि आप पहली बार perform Timeout(1000), perform Fetch('http://google.com') , और perform ReadFile('file.txt') , और आपकी भाषा में "पैटर्न मिलान" और प्रभावों के लिए स्थिर टाइपिंग है, फिर यह एक बहुत अच्छा प्रोग्रामिंग वातावरण हो सकता है।

शायद यह भाषा जावास्क्रिप्ट में भी संकलित होगी!

रिएक्ट से इसका क्या लेना-देना है?

बहुत बड़ा नहीं है। आप यहां तक कह सकते हैं कि मैं एक ग्लोब पर उल्लू को खींचता हूं।

यदि आपने टाइम स्लाइसिंग और सस्पेंस के बारे में मेरी बात देखी, तो दूसरे भाग में ऐसे घटक शामिल हैं जो कैश से डेटा पढ़ते हैं:

 function MovieDetails({ id }) { //         ? const movie = movieCache.read(id); }

(रिपोर्ट कुछ भिन्न API का उपयोग करती है, लेकिन यह बात नहीं है।)

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

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

हुक एक और उदाहरण है जो आपको बीजीय प्रभावों की याद दिला सकता है। लोगों द्वारा पूछे जाने वाले पहले प्रश्नों में से एक है: यूज़स्टेट कॉल "पता" कहाँ करता है जो इसे संदर्भित करता है?

 function LikeButton() { //  useState ,    ? const [isLiked, setIsLiked] = useState(false); }

मैंने पहले ही इस लेख के अंत में इसे समझाया: रिएक्ट ऑब्जेक्ट में एक उत्परिवर्तनीय स्थिति "वर्तमान डिस्पैचर" है, जो उस कार्यान्वयन को इंगित करता है जिसे आप वर्तमान में उपयोग कर रहे हैं (उदाहरण के लिए, जैसे react-dom )। इसी तरह, एक वर्तमान घटक संपत्ति है जो लाइकबटन आंतरिक डेटा संरचना की ओर इशारा करती है। यहां बताया गया है कि कैसे उपयोग किया जाता है।

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

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

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

संक्षेप में, हम कह सकते हैं कि जावास्क्रिप्ट throw I / O इफेक्ट्स के लिए पहले सन्निकटन के रूप में काम कर सकते हैं (बशर्ते कि कोड को बाद में सुरक्षित रूप से फिर से निष्पादित किया जा सकता है, और जब तक यह सीपीयू से बंधा नहीं है), और चर क्षेत्र " डिस्पैचर "कोशिश में बहाल / अंत में तुल्यकालिक प्रभाव संचालकों के लिए किसी न किसी सन्निकटन के रूप में सेवा कर सकता है।

आप जनरेटर का उपयोग करके बहुत अधिक गुणवत्ता वाले प्रभाव प्राप्त कर सकते हैं, लेकिन इसका मतलब है कि आपको जावास्क्रिप्ट कार्यों की "पारदर्शी" प्रकृति को छोड़ना होगा और आपको जनरेटर के साथ सब कुछ करना होगा। और यह "ठीक है, यह है ..."

और कहां पता लगाना है

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

मुझे नहीं पता कि क्या वे कभी थोक में इस्तेमाल होने लगेंगे। मुझे लगता है कि 2025 तक मुख्य भाषाओं में से किसी में भी जड़ नहीं लेने पर मुझे निराशा होगी। पांच साल में जांच करने के लिए मुझे याद दिलाएं!

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

कई लोगों ने यह भी बताया है कि यदि आप टाइपिंग पहलू को छोड़ देते हैं (जैसा कि मैंने इस लेख में किया है), तो आप कॉमन लिस्प में एक शर्त प्रणाली में इस तरह की तकनीक का एक पूर्व उपयोग पा सकते हैं। , , call/cc .

मानव भाषा में "बीजगणितीय प्रभाव"