(ක්‍රියාකාරී) ප්‍රතික්‍රියාශීලී වැඩසටහන්කරණය යනු කුමක්ද?

ප්‍රතික්‍රියාශීලී වැඩසටහන්කරණය පිළිබඳ විකිපීඩියා ලිපිය මම කියවා ඇත්තෙමි . ක්‍රියාකාරී ප්‍රතික්‍රියාශීලී වැඩසටහන්කරණය පිළිබඳ කුඩා ලිපිය ද මම කියවා ඇත්තෙමි . විස්තර තරමක් වියුක්ත ය.

1. ක්‍රියාකාරී ප්‍රතික්‍රියාශීලී වැඩසටහන්කරණය (FRP) ප්‍රායෝගිකව අදහස් කරන්නේ කුමක්ද?
2. ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය (ප්‍රතික්‍රියාශීලී නොවන ක්‍රමලේඛයට වඩා වෙනස්ව) සමන්විත වන්නේ කුමක් ද?

මගේ පසුබිම අත්‍යවශ්‍ය / OO භාෂාවලින් ඇත, එබැවින් මෙම ආදර්ශයට අදාළ පැහැදිලි කිරීමක් අගය කරනු ඇත.

ඔබට එෆ්ආර්පී පිළිබඳ හැඟීමක් ලබා ගැනීමට අවශ්‍ය නම් , සජීවිකරණ නිදර්ශන සහිත පැරණි ෆ්‍රාන් නිබන්ධනය 1998 සිට ආරම්භ කළ හැකිය . කඩදාසි සඳහා, ක්‍රියාකාරී ප්‍රතික්‍රියාශීලී සජීවිකරණයෙන් ආරම්භ කර මගේ මුල් පිටුවේ ප්‍රකාශන සබැඳිය සහ හැස්කල් විකියේ FRP සබැඳිය පසු විපරම් කරන්න .

පුද්ගලිකව, මම එය ක්‍රියාත්මක කරන්නේ කෙසේද යන්න ඇමතීමට පෙර FRP යන්නෙන් අදහස් කරන්නේ කුමක්ද යන්න ගැන සිතා බැලීමට කැමතියි . . ආදිය). ක්‍රියාත්මක කළ හැකි මෝස්තර බොහොමයක් ඇත, නමුත් කිසිදු ක්‍රියාත්මක කිරීමක් FRP යනු කුමක්දැයි නොකියයි .

ලෝරන්ස් ජී ගේ සරල විස්තරය සමඟ මම අනුනාද වන්නේ එෆ්ආර්පී යනු “කාලයත් සමඟ වටිනාකමක් නිරූපණය කරන දත්ත සමුදායන්” ගැන ය. සාම්ප්‍රදායික අත්‍යවශ්‍ය ක්‍රමලේඛනය මඟින් මෙම ගතික අගයන් ග්‍රහණය කරගන්නේ වක්‍රව, රාජ්‍ය හා විකෘති හරහා පමණි. සම්පූර්ණ ඉතිහාසයට (අතීත, වර්තමාන, අනාගත) පළමු පන්තියේ නියෝජනයක් නොමැත. එපමණක් නොව, අත්යවශ්ය පරමාදර්ශය තාවකාලිකව විවික්ත වන බැවින් (වක්රයෙන්) අල්ලා ගත හැක්කේ විචක්ෂණ ලෙස පරිණාමය වන අගයන් පමණි . ඊට වෙනස්ව, එෆ්ආර්පී විසින් මෙම පරිණාමය වන අගයන් කෙලින්ම ග්‍රහණය කර ගන්නා අතර අඛණ්ඩව විකාශනය වන අගයන් සමඟ කිසිදු අපහසුතාවයක් නොමැත .

අත්‍යවශ්‍ය සහසම්බන්ධතාවයට පීඩා කරන න්‍යායාත්මක හා ප්‍රායෝගික මීයන්ගේ කූඩුව නොතකා සමගාමීව එෆ්ආර්පී ද අසාමාන්‍යය. ශබ්දාර්ථයෙන්, FRP ගේ සමගාමී වේ සියුම් , determinate , සහ අඛණ්ඩ . . සමගාමී මුදල් අත්‍යවශ්‍ය ක්‍රමලේඛනය සඳහා අතිවිශාල සංකීර්ණත්වයක් එක් කරන අතර (නොන්ඩෙටර්මිනිස්ටික් අන්තර් සම්බන්ධතා හේතුවෙන්), එෆ්ආර්පී හි එය උත්සාහයක් නැත.

ඉතින්, FRP යනු කුමක්ද? ඔබට එය තනිවම නිර්මාණය කළ හැකිය. මෙම අදහස් සමඟ ආරම්භ කරන්න:

• ගතික / පරිණාමය වන අගයන් (එනම්, "කාලයත් සමඟ" අගයන්) තමන් තුළම පළමු පන්තියේ අගයන් වේ. ඔබට ඒවා අර්ථ දැක්විය හැකි අතර ඒවා ඒකාබද්ධ කළ හැකිය. මම මේ දේවල් හැඳින්වූයේ "හැසිරීම්" ලෙසයි.

• චර්යා රටා සෑදී ඇත්තේ නියත (ස්ථිතික) හැසිරීම් සහ වේලාව (ඔරලෝසුවක් වැනි) වැනි ප්‍රාථමිකයන් කිහිපයකින් වන අතර පසුව අනුක්‍රමික හා සමාන්තර සංයෝජනයෙන්. n හැසිරීම් ඒකාබද්ධ වන්නේ n-ary ශ්‍රිතයක් (ස්ථිතික අගයන් මත), “ලක්ෂ්‍යය අනුව”, එනම්, කාලයත් සමඟ අඛණ්ඩව යෙදීමෙනි.

• විවික්ත සංසිද්ධි සඳහා ගණනය කිරීම සඳහා, "සිදුවීම්" හි තවත් වර්ගයක් (පවුලක්) ඇති අතර, ඒ සෑම අවස්ථාවකම ප්‍රවාහයක් (සීමිත හෝ අනන්ත) ඇත. සෑම සිදුවීමක්ම ආශ්‍රිත කාලය හා වටිනාකම ඇත.

• සියළුම හැසිරීම් සහ සිදුවීම් ගොඩනගා ගත හැකි සංයුතියේ වාග් මාලාව ඉදිරිපත් කිරීම සඳහා, උදාහරණ කිහිපයක් සමඟ සෙල්ලම් කරන්න. වඩාත් සාමාන්‍ය / සරල කෑලි වලට නැවත සකස් කිරීම දිගටම කරගෙන යන්න.

• එබැවින් ඔබ ස්ථිර භූමියක සිටින බව ඔබ දන්නා බැවින්, නිරූපණ අර්ථකථන තාක්‍ෂණය භාවිතා කරමින් සමස්ත ආකෘතියට සංයුති පදනමක් ලබා දෙන්න, එයින් අදහස් කරන්නේ (අ) සෑම වර්ගයකටම අනුරූප සරල හා නිරවද්‍ය ගණිතමය “අර්ථයන්” ඇති බවත්, ( ආ) සෑම ප්‍රාථමික හා ක්‍රියාකරුවෙකුටම සං .ටකවල අර්ථයන්හි ශ්‍රිතයක් ලෙස සරල හා නිරවද්‍ය අර්ථයක් ඇත. කිසි විටෙකත්, ඔබේ ගවේෂණ ක්‍රියාවලියට ක්‍රියාත්මක කිරීමේ කරුණු මිශ්‍ර නොකරන්න . මෙම විස්තරය ඔබට අශෝභන නම්, (අ) වර්ග පංති මෝෆිම් සහිත විස්තාරණ සැලසුම , (ආ) ක්‍රියාකාරී ප්‍රතික්‍රියාකාරී ක්‍රමලේඛනය තල්ලු කිරීම (ක්‍රියාත්මක කිරීමේ බිටු නොසලකා හැරීම) සහ (ඇ) ඩෙනෝටේෂන් සෙමන්ටික්ස් හැස්කල් විකිබුක්ස් පිටුව. එහි ආරම්භකයින් දෙදෙනා වන ක්‍රිස්ටෝපර් ස්ට්‍රැචී සහ ඩනා ස්කොට් යන දෙදෙනාගේ අර්ථකථන අර්ථ නිරූපණයට කොටස් දෙකක් ඇති බව පරෙස්සම් වන්න: පහසු සහ වඩා ප්‍රයෝජනවත් ස්ට්‍රැචේ කොටස සහ වඩා දුෂ්කර හා අඩු ප්‍රයෝජනවත් (මෘදුකාංග නිර්මාණය සඳහා) ස්කොට් කොටස.

ඔබ මෙම මූලධර්ම සමඟ බැඳී සිටින්නේ නම්, ඔබට FRP හි ආත්මයට වඩා අඩු හෝ අඩු යමක් ලැබෙනු ඇතැයි මම අපේක්ෂා කරමි.

මෙම මූලධර්ම මා ලබාගත්තේ කොහෙන්ද? මෘදුකාංග නිර්මාණයේදී, මම සෑම විටම එකම ප්‍රශ්නය අසමි: "එහි තේරුම කුමක්ද?". අර්ථ දැක්වීමේ අර්ථ නිරූපණය මට මෙම ප්‍රශ්නයට නිවැරදි රාමුවක් ලබා දුන් අතර මගේ සෞන්දර්යයට ගැළපෙන එකක් (ක්‍රියාකාරී හෝ අක්ෂීය අර්ථකථන මෙන් නොව, මේ දෙකම මා සෑහීමකට පත් නොවේ). ඉතින් මම මගෙන්ම ඇහුවා හැසිරීම යනු කුමක්ද? අත්යවශ්ය ගණනය කිරීමේ තාවකාලික විවික්ත ස්වභාවය හැසිරීම පිළිබඳ ස්වාභාවික විස්තරයකට වඩා විශේෂිත ශ්රව්ය යන්ත්රයකට නවාතැන් පහසුකම් බව මම ඉක්මනින් තේරුම් ගතිමි . මට සිතිය හැකි හැසිරීම පිළිබඳ සරලම නිරවද්‍ය විස්තරය හුදෙක් "(අඛණ්ඩ) වේලාවේ ක්‍රියාකාරිත්වය", එබැවින් එය මගේ ආකෘතියයි. සතුටුදායක ලෙස, මෙම ආකෘතිය අඛණ්ඩ, නිර්ණායක සහසම්බන්ධය පහසුවෙන් සහ කරුණාවෙන් හසුරුවයි.

මෙම ආකෘතිය නිවැරදිව හා කාර්යක්ෂමව ක්‍රියාත්මක කිරීම තරමක් අභියෝගයකි, නමුත් එය තවත් කතාවකි.

පිරිසිදු ක්‍රියාකාරී වැඩසටහන්කරණයේදී අතුරු ආබාධ නොමැත. බොහෝ වර්ගවල මෘදුකාංග සඳහා (නිදසුනක් ලෙස, පරිශීලක අන්තර්ක්‍රියා සහිත ඕනෑම දෙයක්) අතුරු ආබාධ යම් මට්ටමකින් අවශ්‍ය වේ.

ක්‍රියාකාරී ශෛලියක් පවත්වා ගෙන යන අතරම හැසිරීම වැනි අතුරු ආබාධ ලබා ගත හැකි එක් ක්‍රමයක් නම් ක්‍රියාකාරී ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය භාවිතා කිරීමයි. මෙය ක්‍රියාකාරී ක්‍රමලේඛන සහ ප්‍රතික්‍රියාශීලී වැඩසටහන් වල සංයෝජනයයි. (ඔබ සම්බන්ධ කළ විකිපීඩියා ලිපිය දෙවැන්න ගැන ය.)

ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය පිටුපස ඇති මූලික අදහස නම් “කාලයත් සමඟ” වටිනාකමක් නිරූපණය කරන ඇතැම් දත්ත වර්ග තිබේ. මෙම වෙනස්වන-අතිකාල අගයන් සම්බන්ධ වන ගණනය කිරීම් වලට කාලයත් සමඟ වෙනස් වන අගයන් ඇත.

නිදසුනක් ලෙස, ඔබට මවුස් ඛණ්ඩාංක පූර්ණ-අතිකාල අගයන් යුගලයක් ලෙස නිරූපණය කළ හැකිය. අපි කියමු අපිට මේ වගේ දෙයක් තිබුණා (මෙය ව්‍යාජ කේතය):

x = <mouse-x>;
y = <mouse-y>;

ඕනෑම වේලාවක x සහ y මූසිකයේ ඛණ්ඩාංක ඇත. ප්‍රතික්‍රියාශීලී නොවන ක්‍රමලේඛන මෙන් නොව, අපට මෙම පැවරුම එක් වරක් පමණක් කළ යුතු අතර x සහ y විචල්‍යයන් ස්වයංක්‍රීයව "යාවත්කාලීනව" පවතිනු ඇත. ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය සහ ක්‍රියාකාරී ක්‍රමලේඛනය එකට වැඩ කරන්නේ මේ නිසා ය: ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය මඟින් විචල්‍ය විකෘති කිරීමේ අවශ්‍යතාවය ඉවත් කරන අතරම විචල්‍ය විකෘති සමඟ ඔබට කළ හැකි දේ බොහෝමයක් කිරීමට ඉඩ ලබා දේ.

අප මේ මත පදනම්ව යම් ගණනය කිරීම් කළහොත් එහි ප්‍රති values ​​ලයක් ලෙස ලැබෙන අගයන් කාලයත් සමඟ වෙනස් වන අගයන් වේ. උදාහරණයක් වශයෙන්:

minX = x - 16;
minY = y - 16;
maxX = x + 16;
maxY = y + 16;

මෙම උදාහරණයේ දී, minXසෑම විටම මූසික දර්ශකයේ x ඛණ්ඩාංකයට වඩා 16 අඩු වනු ඇත. ප්‍රතික්‍රියාශීලී දැනුවත් පුස්තකාල සමඟ ඔබට පසුව එවැනි දෙයක් පැවසිය හැකිය:

rectangle(minX, minY, maxX, maxY)

මූසික දර්ශකය වටා 32x32 කොටුවක් ඇද ගන්නා අතර එය චලනය වන ඕනෑම තැනක එය නිරීක්ෂණය කරනු ඇත.

මෙන්න ක්‍රියාකාරී ප්‍රතික්‍රියාශීලී වැඩසටහන්කරණය පිළිබඳ හොඳ ලිපියක් .

එය කෙබඳු දැයි පළමු ප්‍රතිභාවට ලඟාවිය හැකි පහසු ක්‍රමයක් නම් ඔබේ වැඩසටහන පැතුරුම්පතක් යැයි සිතීම සහ ඔබේ සියලු විචල්‍යයන් සෛල වේ. පැතුරුම්පතක ඇති ඕනෑම සෛලයක් වෙනස් වුවහොත්, එම සෛලයට යොමු වන ඕනෑම සෛල වෙනස් වේ. එෆ්ආර්පී සම්බන්ධයෙන් ද එය එසේම ය. දැන් සිතන්න සමහර සෛල තනිවම වෙනස් වන බව (හෝ ඒ වෙනුවට බාහිර ලෝකයෙන් ලබාගෙන ඇත): GUI තත්වයකදී, මූසිකයේ පිහිටීම හොඳ උදාහරණයක් වනු ඇත.

එය අනිවාර්යයෙන්ම බොහෝ දේ මග හැරේ. ඔබ සැබවින්ම FRP පද්ධතියක් භාවිතා කරන විට රූපකය ඉතා වේගයෙන් බිඳී යයි. එකක් සඳහා, සාමාන්‍යයෙන් විවික්ත සිදුවීම් ආදර්ශනය කිරීමට උත්සාහ දරයි (උදා: මූසිකය ක්ලික් කිරීම). මම මෙය මෙහි තබන්නේ එය කෙබඳු දැයි ඔබට අදහසක් ලබා දීමට පමණි.

මට එය සංකේතයේ විවිධ අර්ථ 2 ක් පමණ වේ =:

1. උපහැරණ x = sin(t)මාර්ගයෙන්, ඒ xවන වෙනස් නමක් සඳහා sin(t). එබැවින් ලිවීම x + yඑකම දෙයකි sin(t) + y. ක්‍රියාකාරී ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය මේ සම්බන්ධයෙන් ගණිතයට සමානය: ඔබ ලියන්නේ නම් x + y, එය tභාවිතා කරන වේලාවේ වටිනාකම කුමක් වුවත් එය ගණනය කෙරේ.
2. සී-වැනි ක්‍රමලේඛන භාෂාවල (අත්‍යවශ්‍ය භාෂා), x = sin(t)පැවරුමකි: එයින් අදහස් වන්නේ පැවරුමේදී xගත් වටිනාකම ගබඩා කිරීමයි sin(t).

හරි, පසුබිම් දැනුමෙන් සහ ඔබ පෙන්වා දුන් විකිපීඩියා පිටුව කියවීමෙන්, ප්‍රතික්‍රියාකාරී ක්‍රමලේඛනය යනු දත්ත ප්‍රවාහ පරිගණනය වැනි දෙයක් බව පෙනේ, නමුත් නිශ්චිත බාහිර “උත්තේජක” සමඟ නෝඩ් සමූහයක් ගිනි තබා ඒවායේ ගණනය කිරීම් සිදු කරයි.

මෙය UI සැලසුමට බෙහෙවින් ගැලපේ, උදාහරණයක් ලෙස, පරිශීලක අතුරුමුහුණත් පාලනයක් ස්පර්ශ කිරීම (එනම්, සංගීත වාදනය කරන යෙදුමක පරිමාව පාලනය කිරීම) විවිධ සංදර්ශක අයිතම සහ ශ්‍රව්‍ය ප්‍රතිදානයේ සත්‍ය පරිමාව යාවත්කාලීන කිරීමට අවශ්‍ය විය හැකිය. ඔබ පරිමාව වෙනස් කරන විට (ස්ලයිඩරයක්, අපි කියමු) එය යොමු කරන ලද ප්‍රස්ථාරයක ඇති නෝඩයක් හා සම්බන්ධ අගය වෙනස් කිරීමට අනුරූප වේ.

එම “පරිමාවේ අගය” නෝඩයෙන් දාර ඇති විවිධ නෝඩ් ස්වයංක්‍රීයව අවුලුවන අතර අවශ්‍ය ඕනෑම ගණනය කිරීම් සහ යාවත්කාලීනයන් ස්වභාවිකවම යෙදුම හරහා ඉරිතලා යනු ඇත. යෙදුම පරිශීලක උත්තේජනයට "ප්‍රතික්‍රියා කරයි". ක්‍රියාකාරී ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය යනු මෙම අදහස ක්‍රියාකාරී භාෂාවකින් හෝ සාමාන්‍යයෙන් ක්‍රියාකාරී ක්‍රමලේඛන පරාමිතියක් තුළ ක්‍රියාත්මක කිරීමයි.

"දත්ත ප්‍රවාහ පරිගණනය" පිළිබඳ වැඩි විස්තර සඳහා, විකිපීඩියාවේ එම වචන දෙක සොයන්න හෝ ඔබේ ප්‍රියතම සෙවුම් යන්ත්‍රය භාවිතා කරන්න. සාමාන්‍ය අදහස මෙයයි: වැඩසටහන යනු නෝඩ් වල සෘජු ප්‍රස්ථාරයකි, සෑම එකක්ම සරල ගණනය කිරීම් සිදු කරයි. සමහර නෝඩ් වල ප්‍රතිදානයන් අනෙක් අයගේ යෙදවුම් වලට සපයන ප්‍රස්ථාර සම්බන්ධතා මගින් මෙම නෝඩ් එකිනෙක හා සම්බන්ධ වේ.

නෝඩයක් වෙඩි තැබීම හෝ ගණනය කිරීම සිදු කරන විට, එහි ප්‍රතිදානයන් හා සම්බන්ධිත නෝඩ් වලට අනුරූප ආදාන “අවුලුවන” හෝ “සලකුණු” කර ඇත. සියලු යෙදවුම් ඇති ඕනෑම නෝඩයක් ස්වයංක්‍රීයව ගිනි ගනී. ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය ක්‍රියාත්මක කරන්නේ කෙසේද යන්න මත පදනම්ව ප්‍රස්ථාරය ව්‍යංග හෝ පැහැදිලි විය හැකිය.

නෝඩ් සමාන්තරව වෙඩි තැබීමක් ලෙස සැලකිය හැකි නමුත් බොහෝ විට ඒවා අනුක්‍රමිකව හෝ සීමිත සමාන්තරකරණයකින් ක්‍රියාත්මක වේ (නිදසුනක් ලෙස, ඒවා ක්‍රියාත්මක කරන නූල් කිහිපයක් තිබිය හැක). සුප්‍රසිද්ධ උදාහරණයක් වන්නේ මැන්චෙස්ටර් දත්ත ප්‍රවාහ යන්ත්‍රයයි (IIRC) ප්‍රස්ථාරයේ නෝඩ් ක්‍රියාත්මක කිරීම උපලේඛනගත කිරීම සඳහා ටැග් කළ දත්ත සැකැස්මක් භාවිතා කළේය. ගණනය කිරීම් අවුලුවාලමින් ගණනය කිරීම් අවුලුවන අවස්ථාවන්හිදී දත්ත ප්‍රවාහ ගණනය කිරීම තරමක් හොඳින් ගැලපේ. එය ක්‍රියාත්මක කිරීම ඔරලෝසුවකින් (හෝ ඔරලෝසු) පාලනය කිරීමට උත්සාහ කරනවාට වඩා හොඳය.

ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය මඟින් මෙම “ක්‍රියාත්මක කිරීමේ කඳුරැල්ල” අදහස ආනයනය කරන අතර දත්ත ප්‍රවාහයක් වැනි ආකාරයකින් වැඩසටහන ගැන සිතන බවක් පෙනේ, නමුත් සමහර නෝඩ් “බාහිර ලෝකයට” සම්බන්ධ කර ඇති අතර මෙම සංවේදක විට ක්‍රියාත්මක කිරීමේ කඳුරැල්ල අවුලුවනු ලැබේ. සමාන නෝඩ් වෙනස් වේ. ක්‍රමලේඛ ක්‍රියාත්මක කිරීම සංකීර්ණ ප්‍රතීක චාපයකට සමාන දෙයක් මෙන් පෙනේ. වැඩසටහන මූලික වශයෙන් උත්තේජක අතර අස්ථිර හෝ නොවිය හැකිය හෝ උත්තේජක අතර මූලික වශයෙන් අස්ථිර තත්වයකට පත්විය හැකිය.

“ප්‍රතික්‍රියා නොකරන” ක්‍රමලේඛනය යනු ක්‍රියාත්මක කිරීමේ ප්‍රවාහය සහ බාහිර යෙදවුම් සමඟ ඇති සම්බන්ධතාවය පිළිබඳ වෙනස් මතයක් සහිත වැඩසටහන්කරණයකි. බාහිර යෙදවුම් වලට ප්‍රතිචාර දක්වන ඕනෑම දෙයක් ඔවුන්ට “ප්‍රතික්‍රියා” කිරීමට මිනිසුන් පෙළඹෙනු ඇති බැවින් එය තරමක් ආත්මීය විය හැකිය. නමුත් කාරණයේ ආත්මය දෙස බලන විට, සිදුවීම් පෝලිම ස්ථාවර කාල පරතරයකින් ඡන්දය ප්‍රකාශ කරන සහ කාර්යයන් (හෝ නූල්) සඳහා සොයාගත් ඕනෑම සිදුවීමක් අඩු ප්‍රතික්‍රියාශීලී වේ (මන්ද එය පරිශීලක ආදානයට ස්ථාවර කාල පරාසයකට පමණක් සහභාගී වන බැවිනි). නැවතත්, එය මෙහි ඇති දෙයයි: වේගවත් ඡන්ද කාල පරතරයක් සහිත ඡන්ද විමසීමක් ඉතා පහත් මට්ටමක පවතින පද්ධතියකට සහ ඊට ඉහළින් ප්‍රතික්‍රියාශීලී ආකාරයකින් වැඩසටහනක් තැබීම කෙනෙකුට සිතාගත හැකිය.

එෆ්ආර්පී ගැන බොහෝ පිටු කියවීමෙන් පසුව, එෆ්ආර්පී ගැන මෙම බුද්ධිමත් ලිවීම මට හමු විය , අවසානයේදී එෆ්ආර්පී යනු කුමක්ද යන්න මට වැටහුණි.

මම පහත සඳහන් කරන්නේ හෙන්රිච් අප්ෆෙල්මස් (ප්‍රතික්‍රියාශීලී කෙසෙල් කතුවරයා).

ක්‍රියාකාරී ප්‍රතික්‍රියාශීලී වැඩසටහන්කරණයේ සාරය කුමක්ද?

පොදු පිළිතුරක් වනුයේ “එෆ්ආර්පී යනු විකෘති තත්වයක් වෙනුවට කාල වෙනස්වන කාර්යයන් අනුව පද්ධතියක් විස්තර කිරීමයි”, එය නිසැකවම වැරදිය. මෙය අර්ථකථන දෘෂ්ටිකෝණයයි. නමුත් මගේ මතය අනුව, ගැඹුරු, වඩා තෘප්තිමත් පිළිතුර පහත දැක්වෙන තනිකරම සින්ටැක්ටික් නිර්ණායකයෙන් ලබා දී ඇත:

ක්‍රියාකාරී ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනයේ සාරය නම් ප්‍රකාශ කරන අවස්ථාවේ දී අගයක ගතික හැසිරීම සම්පූර්ණයෙන්ම නියම කිරීමයි.

උදාහරණයක් ලෙස, කවුන්ටරයක උදාහරණය ගන්න: ඔබට “ඉහළ” සහ “පහළට” යනුවෙන් ලේබල් කර ඇති බොත්තම් දෙකක් ඇති අතර ඒවා කවුන්ටරය වැඩි කිරීමට හෝ අඩු කිරීමට භාවිතා කළ හැකිය. අත්‍යවශ්‍යයෙන්ම, ඔබ මුලින් ආරම්භක අගයක් නියම කර බොත්තමක් එබූ සෑම විටම එය වෙනස් කරයි; මේ වගේ දෙයක්:

counter := 0                               -- initial value
on buttonUp   = (counter := counter + 1)   -- change it later
on buttonDown = (counter := counter - 1)

කාරණය වන්නේ ප්‍රකාශ කරන අවස්ථාවේදී, කවුන්ටරය සඳහා ආරම්භක අගය පමණක් දක්වා ඇති බවයි; කවුන්ටරයේ ගතික හැසිරීම සෙසු වැඩසටහන් පෙළෙහි ගම්‍ය වේ. ඊට හාත්පසින්ම වෙනස්ව, ක්‍රියාකාරී ප්‍රතික්‍රියාකාරී ක්‍රමලේඛනය ප්‍රකාශ කරන අවස්ථාවේ දී සමස්ත ගතික හැසිරීම නියම කරයි, මේ ආකාරයට:

counter :: Behavior Int
counter = accumulate ($) 0
            (fmap (+1) eventUp
             `union` fmap (subtract 1) eventDown)

කවුන්ටරයේ ගතිකතාවයන් ඔබට තේරුම් ගැනීමට අවශ්‍ය සෑම විටම, ඔබ කළ යුත්තේ එහි අර්ථ දැක්වීම දෙස පමණි. එයට සිදුවිය හැකි සෑම දෙයක්ම දකුණු පැත්තේ දිස්වනු ඇත. මෙය පසුව ප්‍රකාශයට පත් කළ අගයන්හි ගතික හැසිරීම වෙනස් කළ හැකි අත්‍යවශ්‍ය ප්‍රවේශයට වඩා බෙහෙවින් වෙනස් ය.

ඉතින්, මගේ අවබෝධය අනුව FRP වැඩසටහන යනු සමීකරණ සමූහයකි:

j විවික්තයි: 1,2,3,4 ...

fරඳා පවතින්නේ tමෙය බාහිර උත්තේජක ආකෘතිකරණය කිරීමේ හැකියාව ඇතුළත් කරයි

වැඩසටහනේ සියලුම තත්වය විචල්‍යයන්ගෙන් සංයුක්ත වේ x_i

මෙම FRP පුස්තකාල සේවා කාලය හැමදා, වෙනත් වචන වලින් කිවහොත්, ගැනීම ගනී jකිරීමට j+1.

මෙම වීඩියෝව තුළ මම මෙම සමීකරණ වඩාත් විස්තරාත්මකව විස්තර කරමි .

සංස්කරණය කරන්න:

මුල් පිළිතුරෙන් වසර 2 කට පමණ පසු, මෑතකදී මම නිගමනය කළේ FRP ක්‍රියාත්මක කිරීම සඳහා තවත් වැදගත් අංගයක් ඇති බවයි. ඔවුන්ට වැදගත් ප්‍රායෝගික ගැටළුවක් විසඳීමට (සහ සාමාන්‍යයෙන්) අවශ්‍ය වේ: හැඹිලි අවලංගු කිරීම .

x_i-S සඳහා වන සමීකරණ මඟින් පරායත්ත ප්‍රස්ථාරයක් විස්තර කෙරේ. මෙම සමහර විට x_iඅවස්ථාවේ දී වෙනස් jඅනතුරුව සියලු නොවේ x_i'දී අගයන් j+1අවශ්ය යාවත්කාලීන කළ යුතු, ඒ නිසා නොවන සියලු පරායත්තයන් සමහර නිසා දැන් සිදු කළ යුතු x_i'සිට ස්වාධීන විය හැකි x_i.

තවද, x_iවෙනස් වන -s වැඩි වැඩියෙන් යාවත්කාලීන කළ හැකිය. උදාහරණයක් ලෙස ගේ සිතියමක් මෙහෙයුම අපි දැන් සලකා බලමු f=g.map(_+1)එහිදී Scala, දී fහා gය Listක Ints. මෙන්න fඅනුරූප වේ x_i(t_j)සහ gවේ x_j(t_j). දැන් මම මූලද්‍රව්‍යයක් සූදානම් කරන්නේ gනම්, එහි ඇති mapසියලුම මූලද්‍රව්‍ය සඳහා මෙහෙයුම සිදු කිරීම නාස්තියකි g. සමහර FRP ක්‍රියාත්මක කිරීම් (උදාහරණයක් ලෙස reflex-frp ) මෙම ගැටළුව විසඳීම අරමුණු කරයි. මෙම ගැටළුව වර්ධක පරිගණකකරණය ලෙසද හැඳින්වේ .

වෙනත් වචන වලින් කිවහොත්, x_iඑෆ්ආර්පී හි හැසිරීම් ( -s) හැඹිලි ගණනය කිරීම් ලෙස සිතිය හැකිය. x_iසමහර f_i-s වෙනස් වුවහොත් මෙම හැඹිලි (s ) කාර්යක්ෂමව අවලංගු කර නැවත ගණනය කිරීම FRP එන්ජිමේ කාර්යය වේ .

කඩදාසි සරලව කාර්යක්ෂම ක්රියාකාරී ප්රතික්රිකාරීත්වය Conal එලියට් (විසින් සෘජු PDF , 233 කි.බ.) තරමක් හොඳ හඳුන්වා ඇත. අනුරූප පුස්තකාලය ද ක්‍රියාත්මක වේ.

පුෂ්-අදින්න ක්‍රියාකාරී ප්‍රතික්‍රියාකාරී වැඩසටහන් ( සෘජු පී.ඩී.එෆ්. , 286 කේ.බී.) තවත් කඩදාසි මගින් දැන් කඩදාසි අතික්‍රමණය කර ඇත.

වියාචනය: මගේ පිළිතුර rx.js සන්දර්භය තුළ - ජාවාස්ක්‍රිප්ට් සඳහා 'ප්‍රතික්‍රියාශීලී ක්‍රමලේඛන' පුස්තකාලයකි.

ක්‍රියාකාරී ක්‍රමලේඛනයේදී, එකතුවක එක් එක් අයිතමය හරහා නැවත ක්‍රියා කිරීම වෙනුවට, ඔබ එකතු කිරීම සඳහාම ඉහළ ඇණවුම් කාර්යයන් (HoFs) යොදනු ලැබේ. එබැවින් එෆ්ආර්පී හි අදහස වන්නේ එක් එක් සිදුවීම සැකසීම වෙනුවට සිදුවීම් ප්‍රවාහයක් නිර්මාණය කිරීම (නිරීක්ෂණය කළ හැකි * සමඟ ක්‍රියාත්මක කිරීම) සහ ඒ වෙනුවට හොෆ්ස් යොදන්න. මේ ආකාරයෙන් ඔබට ප්‍රකාශකයන් ග්‍රාහකයින් හා සම්බන්ධ කරන දත්ත නල මාර්ගයක් ලෙස දර්ශනය කළ හැකිය.

නිරීක්‍ෂණය කළ හැකි භාවිතා කිරීමේ ප්‍රධාන වාසි වනුයේ:
i) එය ඔබගේ කේතයෙන් state ත්වී ඇත, උදා., සිදුවීම් හසුරුවන්නා සෑම 'n' සිදුවීමක් සඳහාම පමණක් සේවයෙන් පහ කිරීමට ඔබට අවශ්‍ය නම්, හෝ පළමු 'n' සිදුවීම් වලින් පසුව වෙඩි තැබීම නතර කරන්න, හෝ පළමු 'n' සිදුවීම් වලින් පසුව පමණක් වෙඩි තැබීම ආරම්භ කරන්න, ඔබට කවුන්ටර සැකසීම, යාවත්කාලීන කිරීම සහ පරීක්ෂා කිරීම වෙනුවට HoFs (පිළිවෙලින් පෙරණය, රැගෙන යාම, මඟ හැරීම) භාවිතා කළ හැකිය.
ii) එය කේත ප්‍රදේශය වැඩි දියුණු කරයි - ඔබට විවිධ සිදුවීම් හසුරුවන්නන් 5 දෙනෙකු සංරචකයක තත්වය වෙනස් කරන්නේ නම්, ඔබට ඒවායේ නිරීක්‍ෂණ ඒකාබද්ධ කළ හැකි අතර ඒකාබද්ධ කළ හැකි නිරීක්‍ෂණය කළ හැකි තනි සිදුවීම් හසුරුවන්නෙකු අර්ථ දැක්විය හැකිය. ඔබේ මුළු පද්ධතියේම සිදුවීම් සංරචකයකට බලපාන්නේ කෙසේද යන්න පිළිබඳව තර්ක කිරීම පහසුය.

• නිරීක්‍ෂණය කළ හැකි දෙයකි.

ඉතෙරබල් යනු කම්මැලි ලෙස පරිභෝජනය කරන අනුක්‍රමයකි - සෑම අයිතමයක්ම එය භාවිතා කිරීමට අවශ්‍ය සෑම විටම අනුකාරක විසින් ඇද ගනු ලැබේ, එබැවින් ගණනය කිරීම පාරිභෝගිකයා විසින් මෙහෙයවනු ලැබේ.

නිරීක්‍ෂණය කළ හැකි වන්නේ කම්මැලි ලෙස නිපදවන අනුක්‍රමයකි - සෑම අයිතමයක්ම අනුක්‍රමයට එකතු කරන සෑම විටම නිරීක්‍ෂකයා වෙත තල්ලු කරනු ලැබේ, එබැවින් ගණනය කිරීම නිෂ්පාදකයා විසින් මෙහෙයවනු ලැබේ.

මචන්, මේක විකාර සහගත අදහසක්! 1998 දී මම මේ ගැන සොයා නොගත්තේ ඇයි? කෙසේ හෝ වේවා, මෙන්න මගේ නිබන්ධනය ෆ්‍රාන් නිබන්ධනය. යෝජනා වඩාත් සාදරයෙන් පිළිගනිමු, මම මේ මත පදනම්ව ක්‍රීඩා එන්ජිමක් ආරම්භ කිරීම ගැන සිතමි.

import pygame
from pygame.surface import Surface
from pygame.sprite import Sprite, Group
from pygame.locals import *
from time import time as epoch_delta
from math import sin, pi
from copy import copy

pygame.init()
screen = pygame.display.set_mode((600,400))
pygame.display.set_caption('Functional Reactive System Demo')

class Time:
    def __float__(self):
        return epoch_delta()
time = Time()

class Function:
    def __init__(self, var, func, phase = 0., scale = 1., offset = 0.):
        self.var = var
        self.func = func
        self.phase = phase
        self.scale = scale
        self.offset = offset
    def copy(self):
        return copy(self)
    def __float__(self):
        return self.func(float(self.var) + float(self.phase)) * float(self.scale) + float(self.offset)
    def __int__(self):
        return int(float(self))
    def __add__(self, n):
        result = self.copy()
        result.offset += n
        return result
    def __mul__(self, n):
        result = self.copy()
        result.scale += n
        return result
    def __inv__(self):
        result = self.copy()
        result.scale *= -1.
        return result
    def __abs__(self):
        return Function(self, abs)

def FuncTime(func, phase = 0., scale = 1., offset = 0.):
    global time
    return Function(time, func, phase, scale, offset)

def SinTime(phase = 0., scale = 1., offset = 0.):
    return FuncTime(sin, phase, scale, offset)
sin_time = SinTime()

def CosTime(phase = 0., scale = 1., offset = 0.):
    phase += pi / 2.
    return SinTime(phase, scale, offset)
cos_time = CosTime()

class Circle:
    def __init__(self, x, y, radius):
        self.x = x
        self.y = y
        self.radius = radius
    @property
    def size(self):
        return [self.radius * 2] * 2
circle = Circle(
        x = cos_time * 200 + 250,
        y = abs(sin_time) * 200 + 50,
        radius = 50)

class CircleView(Sprite):
    def __init__(self, model, color = (255, 0, 0)):
        Sprite.__init__(self)
        self.color = color
        self.model = model
        self.image = Surface([model.radius * 2] * 2).convert_alpha()
        self.rect = self.image.get_rect()
        pygame.draw.ellipse(self.image, self.color, self.rect)
    def update(self):
        self.rect[:] = int(self.model.x), int(self.model.y), self.model.radius * 2, self.model.radius * 2
circle_view = CircleView(circle)

sprites = Group(circle_view)
running = True
while running:
    for event in pygame.event.get():
        if event.type == QUIT:
            running = False
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            running = False
    screen.fill((0, 0, 0))
    sprites.update()
    sprites.draw(screen)
    pygame.display.flip()
pygame.quit()

කෙටියෙන් කිවහොත්: සෑම සංරචකයක්ම සංඛ්‍යාවක් ලෙස සැලකිය හැකි නම්, මුළු පද්ධතියම ගණිත සමීකරණයක් ලෙස සැලකිය හැකිය, නේද?

පෝල් හුඩාක්ගේ කෘතිය වන ද හැස්කල් ස්කූල් ඔෆ් එක්ස්ප්‍රස්ෂන් යනු හස්කල් පිළිබඳ කදිම හැඳින්වීමක් පමණක් නොව එය එෆ්ආර්පී සඳහා සාධාරණ කාලයක් වැය කරයි. ඔබ FRP සමඟ ආරම්භකයකු නම්, FRP ක්‍රියා කරන ආකාරය පිළිබඳ අවබෝධයක් ලබා දීමට මම එය තරයේ නිර්දේශ කරමි.

මෙම පොතේ නව නැවත ලිවීමක් මෙන් පෙනේ (2011 නිකුත් කරන ලදි, 2014 යාවත්කාලීන කරන ලදි), ද හස්කල් සංගීත පාසල .

පෙර පිළිතුරු වලට අනුව, ගණිතමය වශයෙන්, අපි හුදෙක් ඉහළ අනුපිළිවෙලකින් සිතන බව පෙනේ. ඒ වෙනුවට එහි වටිනාකම හිතන x වර්ගය සහිත එක්ස් , අපි උත්සවයකට හිතන්න x : ටී → X කොහේද, ටී කාලය වර්ගය වන අතර, එය ස්වභාවික සංඛ්යා, නිඛිල හෝ සන්තති විය. දැන් අපි ක්‍රමලේඛන භාෂාවෙන් y : = x + 1 ලියන විට , ඇත්ත වශයෙන්ම අපි අදහස් කරන්නේ y ( t ) = x ( t ) + 1 සමීකරණයයි .

සඳහන් කළ පරිදි පැතුරුම්පතක් මෙන් ක්‍රියා කරයි. සාමාන්‍යයෙන් සිදුවීම් මත පදනම් වූ රාමුවක් මත පදනම් වේ.

සියලු "උපමා" මෙන්, එය නවකතාව විවාදාත්මක ය.

නළු නිළියන්ගේ බෙදා හරින ලද ජාල ජාල පිළිබඳ මගේ අත්දැකීම් වලින්, එය පහසුවෙන් නෝඩ් ජාලය හරහා රාජ්‍ය අනුකූලතාවයේ පොදු ගැටලුවකට ගොදුරු විය හැකිය, එනම් ඔබ බොහෝ දෝලනය හා අමුතු ලූපවල සිරවීම සමඟ අවසන් වේ.

සමහර අර්ථ නිරූපණයන් යොමු යොමු ලූප හෝ විකාශනය ඇඟවුම් කරන බැවින් මෙය වළක්වා ගැනීම දුෂ්කර වන අතර නළු නිළියන්ගේ ජාලය කිසියම් අනපේක්ෂිත තත්වයකට එක්වන විට (හෝ නොවේ) තරමක් අවුල් සහගත විය හැකිය.

ඒ හා සමානව, හොඳින් අර්ථ දක්වා ඇති දාර තිබියදීත්, සමහර රාජ්‍යයන් වෙත ළඟා නොවිය හැකිය, මන්ද ගෝලීය රාජ්‍යය විසඳුමෙන් er ත් වන බැවිනි. 2 + 2 විය හැක්කේ කවදාද යන්න මත පදනම්ව 2 + 2 4 විය හැකිය හෝ නොතිබිය හැකිය. පැතුරුම්පත් වල සමමුහුර්ත ඔරලෝසු සහ ලූප හඳුනාගැනීම ඇත. බෙදා හරින ලද නළුවන් සාමාන්‍යයෙන් එසේ නොවේ.

සියලු හොඳ විනෝදය :).

එෆ්ආර්පී ගැන ක්ලෝජුර් උපසිරැසි ගැන්වීමේදී මෙම ලස්සන වීඩියෝව මට හමු විය. ඔබ ක්ලෝජුර් නොදැන සිටියත් එය තේරුම් ගැනීම පහසුය.

මෙන්න වීඩියෝව: http://www.youtube.com/watch?v=nket0K1RXU4

දෙවන භාගයේදී වීඩියෝව යොමු කරන මූලාශ්‍රය මෙන්න: https://github.com/Cicayda/yolk-examples/blob/master/src/yolk_examples/client/autocomplete.cljs

ඇන්ඩ්‍රේ ස්ටාල්ට්ස්ගේ මෙම ලිපිය මා මෙතෙක් දැක ඇති හොඳම හා පැහැදිලි පැහැදිලි කිරීම වේ.

ලිපියේ සමහර උපුටා දැක්වීම්:

ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය යනු අසමමුහුර්ත දත්ත ප්‍රවාහයන් සමඟ ක්‍රමලේඛනය කිරීමයි.

ඊට ඉහළින්, ඔබට ඕනෑම ධාරාවක් ඒකාබද්ධ කිරීම, නිර්මාණය කිරීම සහ පෙරීම සඳහා විස්මිත මෙවලම් පෙට්ටියක් ලබා දෙනු ලැබේ.

ලිපියේ කොටසක් වන අපූරු රූපසටහන් සඳහා උදාහරණයක් මෙන්න:

එය කාලයත් සමඟ ගණිතමය දත්ත පරිවර්තනයන් (හෝ කාලය නොසලකා හැරීම) ගැන ය.

කේතයෙන් මෙයින් අදහස් කරන්නේ ක්‍රියාකාරී සංශුද්ධතාවය සහ ප්‍රකාශන වැඩසටහන්කරණයයි.

රාජ්ය දෝෂ යනු සම්මත අත්යවශ්ය පරමාදර්ශයේ විශාල ගැටළුවකි. වැඩසටහන් ක්‍රියාත්මක කිරීමේදී විවිධ බිටු කේතයන් විවිධ "වේලාවන්හි" සමහර හවුල් තත්වයන් වෙනස් කළ හැකිය. මෙය සමඟ කටයුතු කිරීමට අපහසුය.

එෆ්ආර්පී හි ඔබ විස්තර කරන්නේ (ප්‍රකාශන වැඩසටහන්කරණයේදී මෙන්) දත්ත එක් ප්‍රාන්තයකින් තවත් රාජ්‍යයකට පරිවර්තනය වන්නේ කෙසේද සහ එය අවුලුවන දේ. ඔබේ ක්‍රියාකාරිත්වය හුදෙක් එහි යෙදවුම් වලට ප්‍රතික්‍රියා කරන අතර ඒවායේ වර්තමාන අගයන් භාවිතා කරමින් නව එකක් නිර්මාණය කිරීම නිසා මෙය කාලය නොසලකා හැරීමට ඔබට ඉඩ සලසයි. මෙයින් අදහස් කරන්නේ පරිණාමන නෝඩ් වල ප්‍රස්ථාරයේ (හෝ ගසෙහි) තත්වය අඩංගු වන අතර එය ක්‍රියාකාරී ලෙස පිරිසිදු බවය.

මෙය සංකීර්ණත්වය සහ නිදොස් කිරීමේ කාලය විශාල වශයෙන් අඩු කරයි.

වැඩසටහනක ගණිතයේ A = B + C සහ A = B + C අතර වෙනස ගැන සිතන්න. ගණිතයේදී ඔබ විස්තර කරන්නේ කිසි විටෙකත් වෙනස් නොවන සම්බන්ධතාවයක්. වැඩසටහනක, එහි පවසන්නේ "දැන්" A යනු B + C බවයි. නමුත් ඊළඟ විධානය B ++ විය හැකි අතර ඒ අවස්ථාවේ A A B + C ට සමාන නොවේ. ගණිත හෝ ප්‍රකාශන වැඩසටහන්කරණයේදී ඔබ ඉල්ලන වේලාව කුමක් වුවත් A සෑම විටම B + C ට සමාන වේ.

එබැවින් හවුල් රාජ්‍යයේ සංකීර්ණතා ඉවත් කිරීමෙන් සහ කාලයත් සමඟ අගයන් වෙනස් කිරීමෙන්. ඔබේ වැඩසටහන ගැන තර්ක කිරීම වඩා පහසුය.

EventStream යනු EventStream + සමහර පරිවර්තන ශ්‍රිතයකි.

හැසිරීම යනු EventStream + මතකයේ යම් අගයක්.

සිදුවීම ක්‍රියාත්මක වන විට පරිණාමන ශ්‍රිතය ක්‍රියාත්මක කිරීමෙන් අගය යාවත්කාලීන වේ. මෙය නිපදවන අගය හැසිරීම් මතකයේ ගබඩා වේ.

එන් වෙනත් හැසිරීම් වල පරිවර්තනයක් වන නව හැසිරීම් බිහි කිරීම සඳහා හැසිරීම් රචනා කළ හැකිය. ආදාන සිදුවීම් (හැසිරීම්) ගින්නක් ලෙස මෙම සංයුක්ත අගය නැවත ගණනය කෙරේ.

"නිරීක්ෂකයින් අස්ථායි බැවින්, ඇදගෙන යාමේ උදාහරණයේ දී මෙන් රාජ්‍ය යන්ත්‍රයක් අනුකරණය කිරීම සඳහා අපට බොහෝ විට ඒවායින් කිහිපයක් අවශ්‍ය වේ. ඉහත විචල්‍ය මාවත වැනි සියලු සම්බන්ධිත නිරීක්ෂකයින්ට ප්‍රවේශ විය හැකි රාජ්‍යය සුරැකිය යුතුය."

උපුටා ගැනීම - ඔබ්සර්වර් රටාව අවලංගු කිරීම http://infoscience.epfl.ch/record/148043/files/DeprecatingObserversTR2010.pdf

ප්‍රතික්‍රියාශීලී ක්‍රමලේඛනය පිළිබඳ කෙටි හා පැහැදිලි පැහැදිලි කිරීම Cyclejs - Reactive Programming හි දිස් වේ , එය සරල හා දෘශ්‍ය සාම්පල භාවිතා කරයි.

[මොඩියුලය / සංරචකය / වස්තුව] ප්‍රතික්‍රියාශීලී යන්නෙන් අදහස් වන්නේ බාහිර සිදුවීම් වලට ප්‍රතික්‍රියා කිරීමෙන් තමන්ගේම තත්වය කළමනාකරණය කිරීම සඳහා එය සම්පූර්ණයෙන්ම වගකිව යුතු බවයි.

මෙම ප්‍රවේශයේ ඇති ප්‍රයෝජනය කුමක්ද? එය පාලනයේ ප්‍රතිලෝමය වේ , ප්‍රධාන වශයෙන් [මොඩියුලය / සංරචකය / වස්තුව] තමාටම වගකිව යුතු නිසා, මහජනතාවට එරෙහිව පුද්ගලික ක්‍රම භාවිතා කරමින් සංසරණය වැඩි දියුණු කරයි.

එය හොඳ ආරම්භක ලක්ෂ්‍යයක් මිස දැනුමේ සම්පූර්ණ ප්‍රභවයක් නොවේ. එතැන් සිට ඔබට වඩාත් සංකීර්ණ හා ගැඹුරු කඩදාසි වෙත යා හැකිය.

.NET සඳහා Rx, ප්‍රතික්‍රියාශීලී දිගු බලන්න. ඔවුන් පෙන්වා දෙන්නේ IEnumerable සමඟ ඔබ මූලික වශයෙන් ධාරාවකින් 'අදින' බවයි. IQueryable / IEnumerable පිළිබඳ ලින්ක් විමසීම් යනු කට්ටලයක ප්‍රති results ල 'උරා බොන' මෙහෙයුම් කට්ටල වේ. නමුත් IObservable හරහා එකම ක්‍රියාකරුවන් සමඟ ඔබට 'ප්‍රතික්‍රියා කරන' ලින්ක් විමසුම් ලිවිය හැකිය.

උදාහරණයක් ලෙස, ඔබට (MyObservableSetOfMouseMovements හි mX <100 සහ mY <100 නව ලක්ෂ්‍යයක් (mX, mY) තෝරන්න) වැනි ලින්ක් විමසුමක් ලිවිය හැකිය.

සහ Rx දිගු සමඟ, එය එයයි: ඔබට එන මූසික චලනයට ප්‍රතිචාර දක්වන UI කේතයක් ඇති අතර ඔබ 100,100 කොටුව තුළ සිටින සෑම විටම ඇද ගනී ...

එෆ්ආර්පී යනු ක්‍රියාකාරී ක්‍රමලේඛනය (සෑම දෙයක්ම පිළිබඳ අදහස මත ගොඩනගා ඇති ක්‍රමලේඛන පරාමිතිය ශ්‍රිතයකි) සහ ප්‍රතික්‍රියාශීලී ක්‍රමලේඛන ආදර්ශනය (සියල්ල ප්‍රවාහයක් යන අදහස මත ගොඩනගා ඇත (නිරීක්ෂකයා සහ නිරීක්ෂණය කළ හැකි දර්ශනය)). එය ලෝකයේ හොඳම ඒවා විය යුතුය.

ආරම්භ කිරීම සඳහා ප්‍රතික්‍රියාශීලී වැඩසටහන්කරණය පිළිබඳ ඇන්ඩ්‍රේ ස්ටෝල්ට්ස්ගේ සටහන බලන්න.