ടെംപ്ലേറ്റ് അനുസരിച്ച് ആപ്ലിക്കേഷൻ വികസനം എംവിസി ഡിസൈൻ(മോഡൽ-വ്യൂ-കൺട്രോളർ) ജാവയ്ക്ക് സാധാരണമാണ്, ഡ്രോയിഡ്സ്ക്രിപ്റ്റിൽ പ്രയോഗിക്കുമ്പോൾ, മനസ്സിലാക്കാൻ കഴിയാത്തതും അനാവശ്യവുമാണെന്ന് തോന്നുന്നു. എന്തിനാണ് എല്ലാം സങ്കീർണ്ണമാക്കുന്നത്? ജാവയുടെ പശ്ചാത്തലത്തിൽ മനോഹരവും എന്നാൽ മനസ്സിലാക്കാൻ കഴിയാത്തതുമായ വാക്കുകളും (സങ്കൽപ്പം, മോഡൽ, ബിസിനസ്സ് ലോജിക്, പാറ്റേൺ) സങ്കീർണ്ണമായ പ്രകടനങ്ങളും ഉപയോഗിച്ചതിനാൽ എംവിസി സങ്കീർണ്ണതയും "മാജിക്" നേടിയെടുത്തു. എല്ലാം വളരെ ലളിതമാണ്: എംവിസി നിർമ്മിക്കുന്ന ഡിസൈൻ പാറ്റേണുകളിൽ ഒന്നാണ് അധികകോഡ് പങ്കിടൽഒബ്ജക്റ്റ് ഓറിയൻ്റഡിൽ പരിസ്ഥിതി.
MVC മോഡലിൻ്റെ കേന്ദ്ര ഘടകം കൺട്രോളർ ആണ് - സാധാരണ ആപ്ലിക്കേഷൻ DroidScript, അതിൽ നിന്ന് വിഷ്വൽ മാർക്ക്അപ്പുമായി ബന്ധപ്പെട്ട കോഡ് ബാഹ്യ ഡിസൈൻവിജറ്റുകൾ, കൂടാതെ അവ ആക്സസ് ചെയ്യുന്നതിനുള്ള ഡാറ്റയും രീതികളും. അറേകൾ, ഫയലുകൾ, ഡാറ്റാബേസുകൾ എന്നിവയിൽ സംഭരിച്ചിരിക്കുന്ന വിവരങ്ങൾ മനസ്സിലാക്കാൻ ഡാറ്റ ഉപയോഗിച്ച് ഞങ്ങൾ ശീലിച്ചിരിക്കുന്നു. എന്നാൽ MVC ആശയത്തിൽ, ഡാറ്റ മനസ്സിലാക്കുന്നു വിശാലമായ അർത്ഥത്തിൽആപ്ലിക്കേഷൻ കോഡല്ലാത്ത എല്ലാം വാക്കുകളാണ്:
- ഫയലുകളിൽ നിന്നും ഡാറ്റാബേസുകളിൽ നിന്നുമുള്ള ബാഹ്യ ഡാറ്റ - മെറ്റാഡാറ്റ, ടെക്സ്റ്റ്, ഗ്രാഫിക്സ്, ശബ്ദങ്ങൾ, സംഗീതം മുതലായവ.
- ആന്തരിക ആപ്ലിക്കേഷൻ ഡാറ്റ - ബട്ടണുകളിലും മറ്റ് നിയന്ത്രണങ്ങളിലും ലേബലുകളുള്ള ലൈനുകൾ, ടെക്സ്റ്റ് ഇൻ ഡയലോഗ് ബോക്സുകൾ, ശൈലികളുടെ വിവരണം, സ്ഥിരാങ്കങ്ങൾ, സോഫ്റ്റ്വെയർ സൃഷ്ടിച്ച ഗ്രാഫിക്സ് മുതലായവ.
ഉപയോക്താവിൻ്റെ വീക്ഷണകോണിൽ നിന്ന്, MVC ഉപയോഗിക്കുമ്പോൾ ആപ്ലിക്കേഷനുമായുള്ള അവൻ്റെ അനുഭവം മാറില്ല: അവൻ ബട്ടണുകളിൽ ക്ലിക്കുചെയ്യുകയും ഡാറ്റ തിരഞ്ഞെടുക്കുകയും അത് എങ്ങനെ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. മാറ്റങ്ങൾ ആശങ്കപ്പെടാം സൌകര്യങ്ങൾഈ ജോലി. വികസനത്തിൻ്റെ ഭാഗത്ത്, മാറ്റങ്ങൾ ശ്രദ്ധേയമാണ്: MVC ആശയത്തിൽ ഡാറ്റയും അതിൻ്റെ പ്രദർശനവും തമ്മിലുള്ള ഇടപെടൽ സംഭവിക്കുന്നു. കൺട്രോളർ വഴിയും അതിൻ്റെ നിയന്ത്രണത്തിലുമാണ്.
ഒരു സിംഗിൾ ഫയൽ ആപ്ലിക്കേഷനിൽ MVC ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ലളിതമായ ഉദാഹരണം നമുക്ക് ആദ്യം നോക്കാം.
MVC മോഡലിൻ്റെ ഒറ്റ-ഫയൽ നടപ്പിലാക്കൽ
നമുക്ക് ഒരു ലളിതമായ ആപ്ലിക്കേഷൻ എടുക്കാം.
ഫംഗ്ഷൻ OnStart())( var _lay = app.CreateLayout("linear", "VCenter,FillXY"); var _btnShowVersion = app.CreateButton("പതിപ്പ് കാണിക്കുക", 0.3, 0.1); _btnShowVersion.SetBackColor7(9"7667) . ;)
ഒറ്റനോട്ടത്തിൽ, എല്ലാം നല്ലതാണെന്ന് തോന്നുന്നു, പക്ഷേ നിങ്ങൾ മാറേണ്ടതുണ്ടെന്ന് കരുതുക വർണ്ണ സ്കീംനിരവധി ഭാഷകളിൽ പ്രയോഗങ്ങളും ഡിസ്പ്ലേ ടെക്സ്റ്റും. ഇത് സങ്കീർണതകളിലേക്ക് നയിക്കും, കാരണം കാണിച്ചിരിക്കുന്ന ഉദാഹരണത്തിലെ എല്ലാ ഡാറ്റയും നിശ്ചിത മൂല്യങ്ങളാണ് (അക്ഷരങ്ങൾ). ഇത് കോഡിൻ്റെ വഴക്കം ഗണ്യമായി കുറയ്ക്കുകയും അതിൻ്റെ ഡീബഗ്ഗിംഗും പിന്തുണയും സങ്കീർണ്ണമാക്കുകയും ചെയ്യുന്നു.
മറ്റൊരു പോരായ്മ, ഡാറ്റ - ബട്ടണിലെ ലേബലുകൾ, മാർക്ക്അപ്പ് - വിജറ്റുകൾ പ്രദർശിപ്പിക്കുന്നതിനുള്ള രീതികൾ, പ്രവർത്തനം - ഒരു ബ്ലോക്കിലും ഒരു ഫയലിലും ബട്ടണിലെ ലേബൽ മാറ്റുന്ന കോഡിൻ്റെ ബ്ലോക്ക്. അതായത്, ലേബൽ മാറ്റാൻ നിങ്ങൾ ഈ ഫയൽ തുറന്ന് മുഴുവൻ ആപ്ലിക്കേഷൻ കോഡിലേക്കും ആക്സസ് നേടേണ്ടതുണ്ട്. ഒരു കാർ ടയർ മാറ്റുന്നതിന്, എല്ലാ ഉള്ളടക്കങ്ങളിലേക്കും പ്രവേശനം നേടുന്നതിന് കാറിൻ്റെ ബോഡി ഡിസ്അസംബ്ലിംഗ് ചെയ്യേണ്ടത് പോലെയാണ് ഇത്. എന്തിനുവേണ്ടി? കാർ ബോഡി ഡിസ്അസംബ്ലിംഗ് ചെയ്യുന്ന പ്രക്രിയയിൽ, നിങ്ങൾക്ക് ആകസ്മികമായി എന്തെങ്കിലും പിടിക്കാനും അത് പ്രവർത്തനരഹിതമാക്കാനും കഴിയും. കോഡിലും ഇത് സാധ്യമാണ്: ലൈനിൻ്റെ പേര് ഒരിടത്ത് മാറ്റിസ്ഥാപിക്കാൻ ഞാൻ ആഗ്രഹിച്ചു, പക്ഷേ മാറ്റിസ്ഥാപിക്കൽ മുഴുവൻ ഫയലിലുടനീളം സംഭവിച്ചു, ഇത് പിശകുകളുടെ ചിതറലിന് കാരണമായി. അല്ലെങ്കിൽ ബട്ടണിൻ്റെ നിറം മാറ്റാൻ നിങ്ങൾ ആഗ്രഹിച്ചു, പക്ഷേ അബദ്ധവശാൽ സമീപത്തുള്ള കോഡ് പിടിക്കുകയും മുഴുവൻ ആപ്ലിക്കേഷനും പ്രവർത്തിക്കുകയും ചെയ്തു.
MVC പാറ്റേണിൻ്റെ ചുമതലകളിൽ ഒന്ന്, ആക്സസ് വേർതിരിച്ചറിയുക എന്നതാണ്: ആദ്യം, പിശകിൻ്റെ ഉറവിടമായ മൊഡ്യൂൾ (അല്ലെങ്കിൽ കോഡിൻ്റെ ബ്ലോക്ക്) തിരിച്ചറിഞ്ഞു, തുടർന്ന് അതിലേക്ക് മാത്രമേ പ്രവേശനം നൽകൂ. നിങ്ങൾക്ക് ടയർ മാറ്റണമെങ്കിൽ കാറിൻ്റെ ഇലക്ട്രോണിക്സ്, എഞ്ചിൻ എന്നിവയിലേക്ക് പ്രവേശനം നൽകുന്നത് എന്തുകൊണ്ട്?
ഒരു ഫയലിലാണ് വികസനം നടക്കുന്നതെങ്കിൽ, ഇത് പലപ്പോഴും ഇതുപോലെയാണ് സംഭവിക്കുന്നത്: കോഡിൻ്റെ തുടക്കത്തിലോ അവസാനത്തിലോ പുതിയ ഫംഗ്ഷനുകൾ സ്ഥാപിക്കുന്നു, ഇത് കാലക്രമേണ അവയുടെ മിശ്രിതത്തിലേക്ക് നയിക്കുന്നു. ഫംഗ്ഷനുകളിൽ തന്നെ കോഡിൻ്റെ മിശ്രണം ഇവിടെ ചേർക്കാം, ഒരു മാസത്തിനുള്ളിൽ അഭിപ്രായങ്ങൾക്കൊപ്പം ഇതെല്ലാം മനസ്സിലാക്കാൻ പ്രയാസമാണ്.
MVC യുടെ പശ്ചാത്തലത്തിൽ മുകളിൽ കാണിച്ചിരിക്കുന്ന ഉദാഹരണം നടപ്പിലാക്കാം. ഇത് ചെയ്യുന്നതിന്, എല്ലാ കോഡുകളും വിഭജിച്ച് ഉചിതമായ ബ്ലോക്കുകളിൽ ഗ്രൂപ്പുചെയ്യേണ്ടതുണ്ട്. കോഡിലെ ബ്ലോക്കുകളുടെ ക്രമം പ്രധാനമല്ല, പക്ഷേ യുക്തിക്ക് അനുസൃതമായി പ്രവർത്തിക്കുന്നതാണ് നല്ലത്: കൺട്രോളർ പ്രവർത്തിക്കുന്നതിന്, അവ പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഡാറ്റയും ഘടകങ്ങളും ആവശ്യമാണ്, അതിനാൽ ഇത് അവസാനമായി സ്ഥാപിച്ചിരിക്കുന്നു. ഡാറ്റ പ്രദർശിപ്പിക്കുമ്പോൾ, അത് നിലനിൽക്കണം. മോഡൽ ബ്ലോക്ക് ആദ്യം വരുന്നു എന്നാണ് ഇതിനർത്ഥം:
- മോഡൽ
- പ്രകടനം
- കണ്ട്രോളർ
//+++ ഡാറ്റ ആക്സസ് ചെയ്യുന്നതിനുള്ള പൊതു രീതികൾ _obj.getVersion = ഫംഗ്ഷൻ())( return _version; ) _obj.btnGetTitle = ഫംഗ്ഷൻ())( return _titleShowVersion; ) // ---തുറന്നുഡാറ്റ ആക്സസ് ചെയ്യുന്നതിനുള്ള രീതികൾ window.model = _obj; // ലോക്കൽ ഒബ്ജക്റ്റിലേക്കുള്ള പ്രവേശനം തുറക്കുക ))(); //--- മോഡൽ //+++ അവതരണം (ഫംഗ്ഷൻ ()( var _lay = app.CreateLayout("linear", "VCenter,FillXY"); var _btnShowVersion = app.CreateButton(window.model.btnGetTitle(), 0.3. ലേഔട്ട് (_ലേ);
))(); //--- അവതരണം //+++ കൺട്രോളർ (ഫംഗ്ഷൻ(p_object)( var _obj = ; // പൊതു ഒബ്ജക്റ്റ് തിരയൽ രീതി _obj.findObjectById = ഫംഗ്ഷൻ(p_name)( var _objectList = app.GetObjects(); (var _i) _objectList-ൽ)( if(_objectList[_i].name == p_name)(_objectList തിരികെ നൽകുക[_i]; ) null തിരികെ നൽകുക; ) window.control = _obj; ))(); ഫംഗ്ഷൻ OnStart())( var _buttonShowVersion = window.control.findObjectById("_btnShowVersion"); //+++ പ്രവർത്തനം _buttonShowVersion.SetOnTouch(function())( this.SetText(window.model)ion().getVers); ; // --- പ്രവർത്തനം ) //--- കൺട്രോളർ
ഫംഗ്ഷനുകളുടെ വേർതിരിവ് കാരണം, ആപ്ലിക്കേഷൻ കോഡ് നിരവധി തവണ വർദ്ധിച്ചു.
തുടക്കത്തിൽ, എല്ലാ വേരിയബിളുകളും സ്വകാര്യമാക്കി, അവസാനം, ആവശ്യമെങ്കിൽ, അവയിലേക്കുള്ള പ്രവേശനം ഗ്ലോബൽ വഴി തുറക്കും. വിൻഡോ ഒബ്ജക്റ്റ്, ഇത് ആഗോള വേരിയബിളുകൾ ഇല്ലാതെ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
ഉദാഹരണം ജാവയിലെന്നപോലെ ഒരു വിജറ്റ് തിരയൽ നടപ്പിലാക്കുന്നു, എന്നാൽ ആഗോളതലത്തിൽ ഒബ്ജക്റ്റിലേക്കുള്ള ആക്സസ് തുറന്ന് നിങ്ങൾക്ക് ഇത് ലളിതമാക്കാനും കോഡ് കൂടുതൽ കാര്യക്ഷമമാക്കാനും കഴിയും. അസോസിയേറ്റീവ് അറേ:
Window.controls = ;
window.controls.buttonShowVersion = _btnShowVersion;
ഡാറ്റ, അതിൻ്റെ പ്രദർശനം, പ്രവർത്തനങ്ങളോടുള്ള പ്രതികരണം എന്നിവ പരസ്പരം ഇടകലരാതെ വ്യത്യസ്ത ബ്ലോക്കുകളിൽ സ്ഥിതിചെയ്യുന്നു, ഇത് ഡവലപ്പർക്ക് അവരുമായി എളുപ്പത്തിൽ പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നു. ഡാറ്റയും കോഡും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് എളുപ്പമാണ്, പിശകുകൾ കുറവായിരിക്കും, ഡീബഗ് ചെയ്യാനും പിന്തുണയ്ക്കാനും സ്കെയിൽ ചെയ്യാനും എളുപ്പമായിരിക്കും.
ഈ മൂന്ന് ഘടകങ്ങളും പരസ്പരം വേർതിരിക്കേണ്ടതില്ല. എംവിസിയുടെ നിരവധി വ്യതിയാനങ്ങളും ഈ മോഡലിൻ്റെ അപൂർണ്ണമായ നിർവ്വഹണങ്ങളും ഉണ്ട്. ഉദാഹരണത്തിന്, അജ്ഞാത കോൾബാക്ക് ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഡാറ്റ വേർതിരിക്കാനും പ്രവർത്തന കോഡ് നിയന്ത്രണങ്ങളുമായി സംയോജിപ്പിക്കാനും കഴിയും.
ഒരു ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കുമ്പോൾ, കോഡിൻ്റെയും ഡാറ്റയുടെയും വേർതിരിവ് തുടക്കത്തിൽ തന്നെ നിലവിലുണ്ട്: ഡാറ്റയും പ്രവർത്തനങ്ങളും ക്ലാസുകളായി തിരിച്ചിരിക്കുന്നു, ഒബ്ജക്റ്റുകൾ പരസ്പരം ഇടപഴകുന്നു തുറന്ന രീതികൾതുടങ്ങിയവ. കോഡും ഡാറ്റയും അവയുടെ കോർ ഫംഗ്‌ഷനുകളിലേക്ക് മികച്ചതും കൂടുതൽ വ്യക്തവുമായ വേർതിരിവ് MVC അനുവദിക്കുന്നു.
MVC മോഡൽ ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനങ്ങൾ നന്നായി മനസ്സിലാക്കാൻ, കോഡ് പ്രത്യേക ഫയലുകളായി വിഭജിക്കുന്നത് നോക്കാം.
MVC മോഡലിൻ്റെ ത്രീ-ഫയൽ നടപ്പിലാക്കൽ
കോഡ് ഡിവിഷൻ പ്രകാരം വ്യത്യസ്ത ഫയലുകൾകൂടുതലായി ഉപയോഗിക്കുന്നു സുഖപ്രദമായ ജോലിഅവനോടൊപ്പം. MVC പ്രോജക്‌റ്റുകളിൽ കാണാൻ കഴിയുന്ന വലിയ എണ്ണം ചെറിയ ഫയലുകൾ ഈ പ്രസ്താവനയെ ചോദ്യം ചെയ്‌തേക്കാം, എന്നാൽ ഫയലുകൾ കാണുന്നത് ഒരു കാര്യമാണ്, എന്നാൽ അവയ്‌ക്കൊപ്പം പ്രവർത്തിക്കുന്നത് മറ്റൊന്നാണ്. ഓരോ നിമിഷത്തിലും, ഡെവലപ്പർ ചില ചെറിയ സെറ്റിൽ നിന്ന് ഒരു ഫയലുമായി സംവദിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് പ്രോജക്റ്റ് ഓർഗനൈസേഷൻ ഘടനയെക്കുറിച്ച് നല്ല ധാരണ ഉണ്ടായിരിക്കുകയും നിരന്തരം നിരീക്ഷിക്കുകയും വേണം മൂന്ന് ഫയലുകൾ- മോഡൽ, വ്യൂ, കൺട്രോളർ, അങ്ങനെ ആകസ്മികമായി മൂന്നാം കക്ഷി കോഡ് എഡിറ്റ് ചെയ്യരുത്. DroidScript എഡിറ്ററിൻ്റെ പരിമിതികൾ കാരണം, റൂട്ട് ഡയറക്ടറിയിലെ ഫയൽ നാമങ്ങൾ വഴി മാത്രമേ അത്തരം ഗ്രൂപ്പിംഗ് സാധ്യമാകൂ, ഉദാഹരണത്തിന്:
myproject_model.js - മോഡൽ
myproject_view.js - കാണുക
myproject_control.js - കൺട്രോളർ
മുമ്പത്തെ ഉദാഹരണത്തിൻ്റെ കോഡ് ഫയലുകളായി വിഭജിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ചുവടെയുണ്ട്.
myproject_model.js - മോഡൽ(function())( var _obj = ; //+++ ഡാറ്റ var _version = "അപ്ലിക്കേഷൻ പതിപ്പ് 1.0"; //--- ഡാറ്റ //+++ സ്ട്രിംഗ് റിസോഴ്സ് var _titleShowVersion = "പതിപ്പ് കാണിക്കുക"; //++ + സ്ട്രിംഗ് റിസോഴ്സ് _obj.getVersion = ഫംഗ്ഷൻ ())( return _version; myproject_view.js - കാണുക(ഫംഗ്ഷൻ ()( var _lay = app.CreateLayout ("ലീനിയർ", "VCenter,FillXY"); var _btnShowVersion = app.CreateButton(window.model.btnGetTitle(), 0.3, 0.1); "Versionbtname_ . myproject_control.js - കൺട്രോളർ app.LoadScript("myproject_model.js"); app.LoadScript("myproject_view.js");(function(p_object)( var _obj = ; // ഒബ്ജക്റ്റ് തിരയൽ രീതി _obj.findObjectById = ഫംഗ്ഷൻ (p_name)( var _objectList = app.GetObjects(); (_objectList ലെ var _i)( if(_objectList =_i].name = p_name)( തിരികെ _objectList[ _i]; ) null തിരികെ നൽകുക; ) window.control = _obj; ))(); ഫംഗ്ഷൻ OnStart())( var _buttonShowVersion = window.control.findObjectById("_btnShowVersion"); //+++ പ്രവർത്തനം _buttonShowVersion.SetOnTouch(function())( this.SetText(window.model)ion().getVers); ; // --- പ്രവർത്തനം )കോഡിൻ്റെ ഈ ലളിതമായ വിഭജനം എളുപ്പമായിരുന്നില്ല. ഇത് ചെയ്യുന്നതിന്, മോഡൽ വഴി ഒരു കണക്ഷൻ മുൻകൂട്ടി സ്ഥാപിച്ചു പൊതു സ്വത്ത്ആഗോള മൂല വസ്തു - window.model, കൂടാതെ പ്രാതിനിധ്യവുമായുള്ള ബന്ധം വഴിയാണ് ആഗോള ശ്രേണി _മാപ്പ്രീതിയിലൂടെ app.GetObjects.
കോഡ് ഫയലുകളായി വിഭജിക്കുന്നതിൻ്റെ പ്രയോജനം, നിങ്ങൾക്ക് ഇപ്പോൾ കോഡ് ഒരു മൊത്തത്തിലുള്ള ബ്ലോക്കായി മാറ്റിസ്ഥാപിക്കാം, ഉദാഹരണത്തിന്, ദ്രുത സമാരംഭംപദ്ധതി നടപ്പിലാക്കുക ലളിതമായ മോഡൽ, തുടർന്ന് കൂടുതൽ പ്രവർത്തനക്ഷമമായ മറ്റൊന്ന് ഉപയോഗിച്ച് ഫയൽ മാറ്റിസ്ഥാപിക്കുക, എന്നാൽ അതേ പേരും ഇൻ്റർഫേസും. ഈ സമീപനം ഉപയോഗിക്കുന്നു, ഉദാഹരണത്തിന്, ഉപകരണങ്ങൾ നന്നാക്കുമ്പോൾ. മുമ്പത്തെ അറ്റകുറ്റപ്പണികൾ മന്ദഗതിയിലുള്ളതും കഠിനവുമായ തിരയലും പരാജയപ്പെട്ട റേഡിയോ ഘടകങ്ങൾ മാറ്റിസ്ഥാപിക്കലും ഉൾക്കൊള്ളുന്നുവെങ്കിൽ, ഇപ്പോൾ സാധാരണ യൂണിറ്റുകൾ മാറ്റിസ്ഥാപിക്കുന്നു. സങ്കീർണ്ണമായ ഒരു ബോർഡ് നന്നാക്കുന്നതിനുള്ള ചെലവ് അതിൻ്റെ പെട്ടെന്നുള്ള മാറ്റിസ്ഥാപിക്കുന്നതിനേക്കാൾ വളരെ കൂടുതലാണ്.
നന്നായി രൂപകൽപ്പന ചെയ്ത ഇൻ്റർഫേസിന് മൊഡ്യൂളുകളുടെ തുടർന്നുള്ള സംയോജനത്തെ ഗണ്യമായി ലഘൂകരിക്കാൻ കഴിയുമെന്ന് മുകളിൽ നിന്ന് പിന്തുടരുന്നു.
IN JavaScript വസ്തുക്കൾറഫറൻസ് മുഖേന കടന്നുപോകുന്നു. കൺട്രോളറിലെ വിജറ്റ് പ്രോപ്പർട്ടികൾ മാറ്റുന്നത് ഗുണങ്ങളെ മാറ്റും സ്വയംവിജറ്റ്. സൈദ്ധാന്തികമായി, ജാവയിൽ ചെയ്യുന്നത് പോലെ, കോഡ് ഒബ്‌ജക്റ്റുകളിൽ നിന്ന് വ്യൂ ഒബ്‌ജക്റ്റുകളെ വേർതിരിക്കുന്നത് സാധ്യമാണ്, ഇവിടെ xml ഘടനകൾ ആദ്യത്തേതായി ഉപയോഗിക്കുന്നു, എന്നാൽ രണ്ട് കാരണങ്ങളാൽ ഇതിൽ കാര്യമില്ല - DroidScript ലെ അഭാവം വിഷ്വൽ എഡിറ്റർഇൻ്റർഫേസും API ഒബ്ജക്റ്റുകളുടെ ലഭ്യമായ പ്രോപ്പർട്ടികളുടെ പരിമിതമായ സെറ്റും.
MVC മോഡലിൻ്റെ മൾട്ടി-ഫയൽ നടപ്പിലാക്കൽ
നിയുക്ത ചുമതലകളും പ്രോജക്റ്റിൻ്റെ സങ്കീർണ്ണതയും അനുസരിച്ച്, കോഡും ഡാറ്റയും വേർതിരിക്കുന്നതിൻ്റെ വിശദാംശങ്ങൾ, പൊതുവേ, വ്യത്യസ്തമായിരിക്കും. നിങ്ങൾക്ക് ഉറവിടങ്ങളിൽ നിന്ന് ഉപയോക്തൃ ഡാറ്റയെ കൂടുതൽ വേർതിരിക്കാനാകും, തരം, ഗ്രൂപ്പ് പ്രവർത്തനങ്ങൾ മുതലായവ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഉറവിടങ്ങളിലേക്ക് തുളച്ചുകയറാൻ കഴിയും. എന്നാൽ MVC ഉപയോഗിച്ച് പൂർണ്ണമായി പ്രവർത്തിക്കാൻ DroidScript എഡിറ്റർ നിങ്ങളെ അനുവദിക്കുന്നില്ല.
സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുമ്പോൾ മോഡൽ-വ്യൂ-കൺട്രോളർ (എംവിസി) പാറ്റേൺ വളരെ ഉപയോഗപ്രദമാണ് ഗ്രാഫിക്കൽ ഇൻ്റർഫേസ്അല്ലെങ്കിൽ പെരുമാറ്റം. എന്നാൽ കൂടുതൽ കാര്യങ്ങൾക്കും ലളിതമായ കേസുകൾഅതും ചേരും. ഈ പോസ്റ്റിൽ ഞങ്ങൾ ഈ പാറ്റേൺ അടിസ്ഥാനമാക്കി രൂപകൽപ്പന ചെയ്ത ഒരു മൈൻസ്വീപ്പർ ഗെയിം സൃഷ്ടിക്കും. വികസന ഭാഷയായി പൈത്തൺ തിരഞ്ഞെടുത്തു, പക്ഷേ ഇത് പ്രത്യേകിച്ച് പ്രധാനമല്ല. പാറ്റേണുകൾ ഒരു നിർദ്ദിഷ്ട പ്രോഗ്രാമിംഗ് ഭാഷയെ ആശ്രയിക്കുന്നില്ല, ഫലമായുണ്ടാകുന്ന നടപ്പിലാക്കൽ നിങ്ങൾക്ക് മറ്റേതെങ്കിലും പ്ലാറ്റ്‌ഫോമിലേക്ക് എളുപ്പത്തിൽ കൈമാറാൻ കഴിയും.
പരസ്യം ചെയ്യൽ
MVC പാറ്റേണിനെക്കുറിച്ച് ചുരുക്കത്തിൽ
പേര് സൂചിപ്പിക്കുന്നത് പോലെ, MVC പാറ്റേണിൽ 3 ഘടകങ്ങൾ ഉൾപ്പെടുന്നു: മോഡൽ, വ്യൂ, കൺട്രോളർ. ഓരോ ഘടകങ്ങളും അതിൻ്റെ പങ്ക് നിർവഹിക്കുകയും പരസ്പരം മാറ്റാവുന്നതുമാണ്. ഇതിനർത്ഥം ഘടകങ്ങൾ പരസ്പരം ബന്ധിപ്പിച്ചിരിക്കുന്നത് ചില വ്യക്തമായ ഇൻ്റർഫേസുകളാൽ മാത്രമാണ്, അതിന് പിന്നിൽ ഏത് നടപ്പാക്കലും കിടക്കും. ഈ സമീപനം മാറ്റിസ്ഥാപിക്കാനും സംയോജിപ്പിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു വിവിധ ഘടകങ്ങൾ, ആവശ്യമായ പ്രവർത്തന ലോജിക് നൽകൽ അല്ലെങ്കിൽ രൂപംഅപേക്ഷകൾ. ഓരോ ഘടകങ്ങളും നിർവഹിക്കുന്ന പ്രവർത്തനങ്ങൾ നോക്കാം.
മോഡൽ
പ്രോഗ്രാമിൻ്റെ ആന്തരിക യുക്തിയുടെ ഉത്തരവാദിത്തം. ഇവിടെ നമുക്ക് ഡാറ്റ സ്റ്റോറേജ് രീതികൾ മറയ്ക്കാം, അതുപോലെ തന്നെ വിവരങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള നിയമങ്ങളും അൽഗോരിതങ്ങളും.
ഉദാഹരണത്തിന്, ഒരു ആപ്ലിക്കേഷനായി നമുക്ക് നിരവധി മോഡലുകൾ സൃഷ്ടിക്കാൻ കഴിയും. ഒന്ന് ഡീബഗ് ചെയ്യും, മറ്റൊന്ന് പ്രവർത്തിക്കും. ആദ്യത്തേതിന് അതിൻ്റെ ഡാറ്റ മെമ്മറിയിലോ ഫയലിലോ സംഭരിക്കാൻ കഴിയും, രണ്ടാമത്തേത് ഇതിനകം ഡാറ്റാബേസ് ഉപയോഗിക്കുന്നു. സാരാംശത്തിൽ, ഇതൊരു സ്ട്രാറ്റജി പാറ്റേൺ മാത്രമാണ്.
പ്രകടനം
മോഡൽ ഡാറ്റ പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഉത്തരവാദിത്തം. ഈ തലത്തിൽ, മോഡലുമായുള്ള ഉപയോക്തൃ ഇടപെടലിനായി ഞങ്ങൾ ഒരു ഇൻ്റർഫേസ് മാത്രമാണ് നൽകുന്നത്. ഈ ഘടകം അവതരിപ്പിക്കുന്നതിൻ്റെ പോയിൻ്റ് നിരവധി മോഡലുകളെ അടിസ്ഥാനമാക്കി ഡാറ്റ സംഭരിക്കുന്നതിനുള്ള വ്യത്യസ്ത വഴികൾ നൽകുന്ന കാര്യത്തിന് സമാനമാണ്.
ഉദാഹരണത്തിന്, വികസനത്തിൻ്റെ പ്രാരംഭ ഘട്ടങ്ങളിൽ, ഞങ്ങളുടെ ആപ്ലിക്കേഷനായി ഒരു ലളിതമായ കൺസോൾ കാഴ്ച സൃഷ്ടിക്കാൻ കഴിയും, അതിനുശേഷം മാത്രമേ മനോഹരമായി രൂപകൽപ്പന ചെയ്ത ഒരു GUI ചേർക്കൂ. മാത്രമല്ല, രണ്ട് തരത്തിലുള്ള ഇൻ്റർഫേസുകളും സംരക്ഷിക്കുന്നത് സാധ്യമാണ്.
കൂടാതെ, കാഴ്ചയുടെ ഉത്തരവാദിത്തങ്ങളിൽ മോഡലിൻ്റെ അവസ്ഥയുടെ സമയോചിതമായ പ്രദർശനം മാത്രമേ ഉൾപ്പെടുന്നുള്ളൂ എന്നത് കണക്കിലെടുക്കേണ്ടതാണ്. ഉപയോക്തൃ പ്രവർത്തനങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് കൺട്രോളർ ഉത്തരവാദിയാണ്, അത് ഞങ്ങൾ ഇപ്പോൾ സംസാരിക്കും.
കണ്ട്രോളർ
കാഴ്ചയുമായുള്ള ഇടപെടലിൻ്റെ ഫലമായുണ്ടാകുന്ന മോഡലും ഉപയോക്തൃ പ്രവർത്തനങ്ങളും തമ്മിൽ ഒരു ലിങ്ക് നൽകുന്നു. മോഡലിൻ്റെയും കാഴ്ചയുടെയും അവസ്ഥകൾ അപ്ഡേറ്റ് ചെയ്യുന്ന നിമിഷങ്ങൾ ഏകോപിപ്പിക്കുന്നു. ഒരു സംസ്ഥാനത്ത് നിന്ന് മറ്റൊന്നിലേക്കുള്ള ആപ്ലിക്കേഷൻ ട്രാൻസിഷൻ സംബന്ധിച്ച് മിക്ക തീരുമാനങ്ങളും എടുക്കുന്നു.
വാസ്തവത്തിൽ, ഒരു കാഴ്ചയിൽ ഉപയോക്താവിന് എടുക്കാൻ കഴിയുന്ന ഓരോ പ്രവർത്തനത്തിനും, കൺട്രോളറിൽ ഒരു ഹാൻഡ്‌ലർ നിർവചിച്ചിരിക്കണം. ഈ ഹാൻഡ്‌ലർ മോഡലിൽ ഉചിതമായ കൃത്രിമങ്ങൾ നടത്തുകയും ആവശ്യമെങ്കിൽ മാറ്റങ്ങൾ വരുത്തിയതായി കാഴ്ചയെ അറിയിക്കുകയും ചെയ്യും.
പരസ്യം ചെയ്യൽ
മൈൻസ്വീപ്പർ ഗെയിം സവിശേഷതകൾ
മതി സിദ്ധാന്തം. ഇനി നമുക്ക് പരിശീലനത്തിലേക്ക് പോകാം. പ്രകടനത്തിന് MVC പാറ്റേൺഞങ്ങൾ ഒരു ലളിതമായ ഗെയിം എഴുതും: മൈൻസ്വീപ്പർ. കളിയുടെ നിയമങ്ങൾ വളരെ ലളിതമാണ്:
- കളങ്ങൾ അടങ്ങുന്ന ചതുരാകൃതിയിലുള്ള പ്രദേശമാണ് കളിക്കളം. ചില സെല്ലുകളിൽ ഖനികൾ ക്രമരഹിതമായി സ്ഥാപിച്ചിട്ടുണ്ട്, എന്നാൽ കളിക്കാരന് അവയെക്കുറിച്ച് അറിയില്ല;
- കളിക്കാരന് കളിക്കളത്തിലെ ഏത് സെല്ലിലും ഇടത് വശത്ത് ക്ലിക്ക് ചെയ്യാം വലത് ബട്ടണുകൾഎലികൾ;
- ഇടത് മൌസ് ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുന്നത് സെൽ തുറക്കുന്നതിന് കാരണമാകുന്നു. മാത്രമല്ല, സെല്ലിൽ ഒരു ഖനി ഉണ്ടെങ്കിൽ, ഗെയിം നഷ്ടത്തിൽ അവസാനിക്കുന്നു. തുറന്ന സെല്ലിന് തൊട്ടടുത്തുള്ള സെല്ലുകളിൽ ഖനികളുണ്ടെങ്കിൽ, ചുറ്റുമുള്ള മൈനുകളുടെ എണ്ണമുള്ള ഒരു കൗണ്ടർ തുറന്ന സെല്ലിൽ പ്രദർശിപ്പിക്കും. തുറന്ന സെല്ലിന് ചുറ്റും ഖനികളില്ലെങ്കിൽ, ഓരോ അയൽ സെല്ലും ഒരേ തത്വമനുസരിച്ച് തുറക്കും. അതായത്, കളങ്ങൾ ഒന്നുകിൽ കളിക്കളത്തിൻ്റെ അതിർത്തിയിൽ എത്തുന്നതുവരെ തുറക്കും, അല്ലെങ്കിൽ ഇതിനകം തുറന്ന സെല്ലുകളിൽ എത്തും, അല്ലെങ്കിൽ അവയ്‌ക്ക് അടുത്തായി ഖനി ഇല്ല;
- വലത് മൗസ് ബട്ടണിൽ ക്ലിക്കുചെയ്യുന്നത് സെല്ലുകളിൽ അടയാളങ്ങൾ ഉണ്ടാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു അടച്ച സെല്ലിൽ ക്ലിക്കുചെയ്യുന്നത് ഒരു ഫ്ലാഗ് കൊണ്ട് അടയാളപ്പെടുത്തുന്നു, അത് അതിൻ്റെ അവസ്ഥയെ പൂട്ടുകയും ആകസ്മികമായി തുറക്കുന്നത് തടയുകയും ചെയ്യുന്നു. ഒരു ഫ്ലാഗ് കൊണ്ട് അടയാളപ്പെടുത്തിയിരിക്കുന്ന ഒരു ബോക്സിൽ ക്ലിക്ക് ചെയ്യുമ്പോൾ അതിൻ്റെ അടയാളം ഒരു ചോദ്യചിഹ്നമായി മാറുന്നു. ഈ സാഹചര്യത്തിൽ, സെൽ ഇനി തടയില്ല, ഇടത് മൌസ് ബട്ടൺ ഉപയോഗിച്ച് തുറക്കാനാകും. കൂടെ സെല്ലിൽ ക്ലിക്ക് ചെയ്യുക ചോദ്യചിഹ്നംഅടയാളങ്ങളില്ലാതെ അടച്ച അവസ്ഥയിലേക്ക് അത് തിരികെ നൽകുന്നു;
- ഖനനം ചെയ്തവ ഒഴികെ, കളിക്കളത്തിലെ എല്ലാ സെല്ലുകളും തുറന്നിരിക്കുന്ന ഗെയിമിൻ്റെ അവസ്ഥയാണ് വിജയം നിർണ്ണയിക്കുന്നത്.
നമുക്ക് എന്ത് ലഭിക്കും എന്നതിൻ്റെ ഒരു ഉദാഹരണം ചുവടെ നൽകിയിരിക്കുന്നു:
മൈൻസ്വീപ്പർ ഗെയിമിൻ്റെ UML ഡയഗ്രമുകൾ
കോഡ് എഴുതുന്നതിലേക്ക് പോകുന്നതിന് മുമ്പ്, ആപ്ലിക്കേഷൻ്റെ ആർക്കിടെക്ചറിനെക്കുറിച്ച് മുൻകൂട്ടി ചിന്തിക്കുന്നത് നല്ലതാണ്. ഇത് നടപ്പിലാക്കുന്ന ഭാഷയെ ആശ്രയിക്കരുത്, അതിനാൽ ഞങ്ങളുടെ ആവശ്യങ്ങൾക്ക് UML ആണ് ഏറ്റവും നല്ലത്.
ഗെയിം സെൽ സ്റ്റേറ്റ് ഡയഗ്രം
കളിക്കളത്തിലെ ഏത് സെല്ലും 4 സംസ്ഥാനങ്ങളിൽ ഒന്നിലായിരിക്കാം:
- കൂട് അടച്ചിരിക്കുന്നു;
- കൂട് തുറന്നിരിക്കുന്നു;
- സെൽ ഒരു പതാക കൊണ്ട് അടയാളപ്പെടുത്തിയിരിക്കുന്നു;
- സെൽ ഒരു ചോദ്യചിഹ്നത്താൽ അടയാളപ്പെടുത്തിയിരിക്കുന്നു.
പ്രാതിനിധ്യത്തിന് പ്രാധാന്യമുള്ള സംസ്ഥാനങ്ങൾ മാത്രമാണ് ഞങ്ങൾ ഇവിടെ നിർവചിച്ചിരിക്കുന്നത്. ഗെയിം സമയത്ത് മൈനുകൾ പ്രദർശിപ്പിക്കാത്തതിനാൽ, പിന്നെ അടിസ്ഥാന സെറ്റ്അനുബന്ധ സംസ്ഥാനം നൽകിയിട്ടില്ല. ഉപയോഗിച്ച് ഒരു സെൽ അവസ്ഥയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് സാധ്യമായ പരിവർത്തനങ്ങൾ നമുക്ക് നിർണ്ണയിക്കാം UML ഡയഗ്രമുകൾവ്യവസ്ഥകൾ:
മൈൻസ്വീപ്പർ ഗെയിം ക്ലാസ് ഡയഗ്രം
MVC പാറ്റേൺ അടിസ്ഥാനമാക്കി ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ നിർമ്മിക്കാൻ തീരുമാനിച്ചതിനാൽ, ഞങ്ങൾക്ക് മൂന്ന് പ്രധാന ക്ലാസുകൾ ഉണ്ടായിരിക്കും: മൈൻസ്വീപ്പർ മോഡൽ, മൈൻസ്വീപ്പർവ്യൂ, മൈൻസ്വീപ്പർ കൺട്രോളർ, കൂടാതെ സെല്ലിൻ്റെ അവസ്ഥ സംഭരിക്കുന്നതിന് ഒരു ഹെൽപ്പർ ക്ലാസ് മൈൻസ്‌വീപ്പർസെല്ലും. അവരുടെ ക്ലാസ് ഡയഗ്രം നോക്കാം:
വാസ്തുവിദ്യയുടെ ഓർഗനൈസേഷൻ വളരെ ലളിതമാണ്. MVC പാറ്റേണിൻ്റെ തത്വങ്ങൾക്കനുസൃതമായി ഞങ്ങൾ ഇവിടെ ഓരോ ക്ലാസിലേക്കും ടാസ്‌ക്കുകൾ വിതരണം ചെയ്തു:
- ശ്രേണിയുടെ ഏറ്റവും താഴെയുള്ള ഗെയിം സെൽ ക്ലാസ് മൈൻസ്വീപ്പർസെൽ ആണ്. ഇത് കളത്തിൻ്റെ സ്ഥാനം സംഭരിക്കുന്നു, കളിക്കളത്തിൻ്റെ വരി വരിയും നിര നിരയും നിർണ്ണയിക്കുന്നു; മുമ്പത്തെ ഉപവിഭാഗത്തിൽ ഞങ്ങൾ വിവരിച്ച സംസ്ഥാന പ്രസ്‌താവനകളിലൊന്ന്; ഒരു സെല്ലിൽ (ഖനനം ചെയ്‌തത്) ഒരു ഖനിയുടെ സാന്നിധ്യത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ, അയൽ സെല്ലുകളുടെ കൗണ്ടറിലെ ഖനികളുടെ ഒരു കൗണ്ടർ. കൂടാതെ, ഇതിന് രണ്ട് രീതികളുണ്ട്: വലത്-ക്ലിക്കിൻ്റെ ഫലമായുണ്ടാകുന്ന മാർക്കുകളുമായി ബന്ധപ്പെട്ട സംസ്ഥാനങ്ങളിലൂടെ സൈക്കിൾ ചവിട്ടുന്നതിന് nextMark(), ഇടത്-ക്ലിക്ക് ഇവൻ്റ് കൈകാര്യം ചെയ്യുന്ന open();
- മൈൻസ്വീപ്പർ മോഡൽ മോഡൽ ക്ലാസ് തൊട്ട് മുകളിലാണ്. മൈൻസ്വീപ്പർസെൽ ഗെയിം സെല്ലുകളുടെ കണ്ടെയ്‌നറാണ് അദ്ദേഹം. അതിൻ്റെ ആദ്യ രീതി, startGame(), ഗെയിം ആരംഭിക്കുന്നതിന് കളിക്കളത്തെ ഒരുക്കുന്നു. isWin() രീതി ഗെയിം ഫീൽഡ് ഒരു വിൻ സ്റ്റേറ്റിനായി പരിശോധിക്കുകയും കളിക്കാരൻ വിജയിച്ചാൽ ശരിയാണെന്ന് തിരികെ നൽകുകയും ചെയ്യുന്നു, അല്ലാത്തപക്ഷം അത് തെറ്റായി നൽകുന്നു. നഷ്ടം പരിശോധിക്കാൻ സമാനമായ രീതിയാണ് isGameOver() ഉപയോഗിക്കുന്നത്. ഓപ്പൺസെൽ() നെക്സ്റ്റ് സെൽമാർക്ക്() രീതികൾ കളിക്കളത്തിലെ അനുബന്ധ സെല്ലുകളിലേക്ക് പ്രവർത്തനങ്ങൾ നിയോഗിക്കുന്നു, കൂടാതെ getCell() രീതി അഭ്യർത്ഥിച്ച പ്ലേയിംഗ് സെല്ലിനെ തിരികെ നൽകുന്നു;
- മൈൻസ്വീപ്പർവ്യൂ ക്ലാസിൽ ഉൾപ്പെടുന്നു ഇനിപ്പറയുന്ന രീതികൾ: syncWithModel() - മോഡലിലെ കളിക്കളത്തിൻ്റെ നിലവിലെ അവസ്ഥ പ്രദർശിപ്പിക്കുന്നതിന് കാഴ്ചയുടെ പുനർനിർമ്മാണം ഉറപ്പാക്കുന്നു; getGameSettings() - ഗെയിം ക്രമീകരണങ്ങൾ നൽകുന്നു, ഉപയോക്താവ് നിർവചിച്ചിരിക്കുന്നത്; createBoard() - മോഡൽ ഡാറ്റയെ അടിസ്ഥാനമാക്കി ഒരു കളിസ്ഥലം സൃഷ്ടിക്കുന്നു; showWinMessage(), showGameOverMessage() എന്നിവ യഥാക്രമം വിജയ, നഷ്ട സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കുന്നു;
- ഒടുവിൽ കൺട്രോളർ ക്ലാസ് മൈൻസ്വീപ്പർ കൺട്രോളർ. ഓരോന്നിനും മൂന്ന് രീതികൾ മാത്രമാണ് ഇത് നിർവചിക്കുന്നത് സാധ്യമായ പ്രവർത്തനംകളിക്കാരൻ: " ബട്ടൺ അമർത്തുന്നതിന് startNewGame() ഉത്തരവാദിയാണ് ഒരു പുതിയ ഗെയിം"വ്യൂ ഇൻ്റർഫേസിൽ; onLeftClick() and onRightClick() എന്നിവ യഥാക്രമം ഇടത്, വലത് മൗസ് ബട്ടണുകൾ ഉപയോഗിച്ച് ഗെയിം സെല്ലുകളിൽ ക്ലിക്കുകൾ കൈകാര്യം ചെയ്യുന്നു.
പൈത്തണിൽ മൈൻസ്വീപ്പർ ഗെയിം നടപ്പിലാക്കൽ
ഞങ്ങളുടെ പദ്ധതി നടപ്പിലാക്കാൻ തുടങ്ങേണ്ട സമയമാണിത്. വികസന ഭാഷയായി പൈത്തൺ തിരഞ്ഞെടുക്കാം. അപ്പോൾ നമ്മൾ tkinter മൊഡ്യൂളിനെ അടിസ്ഥാനമാക്കി വ്യൂ ക്ലാസ് എഴുതും.
എന്നാൽ നമുക്ക് മോഡലിൽ നിന്ന് ആരംഭിക്കാം.
മോഡൽ മിൻസ്വീപ്പർ മോഡൽ
മോഡൽ നടപ്പിലാക്കൽ പൈത്തൺ ഭാഷഇനിപ്പറയുന്ന രീതിയിൽ:
MIN_ROW_COUNT = 5 MAX_ROW_COUNT = 30 MIN_COLUMN_COUNT = 5 MAX_COLUMN_COUNT = 30 MIN_MINE_COUNT = 1 MAX_MINE_COUNT = 800 ക്ലാസ് മൈൻസ്വീപ്പർസെൽ: # സാധ്യമായ സംസ്ഥാനങ്ങൾഗെയിം സെൽ: # അടച്ചത് - അടച്ചത് # തുറന്നത് - തുറന്നത് # ഫ്ലാഗുചെയ്‌തു - ഒരു ഫ്ലാഗ് കൊണ്ട് അടയാളപ്പെടുത്തി # ചോദ്യം ചെയ്തു - ഒരു ചോദ്യചിഹ്നം കൊണ്ട് അടയാളപ്പെടുത്തി def __init__(സ്വയം, വരി, കോളം): self.row = വരി self.column = കോളം self.state = "അടച്ച" സ്വയം .മൈൻഡ് = തെറ്റായ self.counter = 0 markSequence = [ "closed", "flagged", "questioned" ] def nextMark(self): self.state in self.markSequence: stateIndex = self.markSequence.index (self.state ) self.state = self.markSequence[ (stateIndex + 1) % len(self.markSequence) ] def open(self): if self.state != "flagged": self.state = "തുറന്ന" ക്ലാസ് മൈൻസ്വീപ്പർ മോഡൽ: def __init__ (self): self.startGame() def startGame(self, rowCount = 15, columnCount = 15, mineCount = 15): rowCount പരിധിയിലാണെങ്കിൽ (MIN_ROW_COUNT, MAX_ROW_COUNT + 1 കോളം ആണെങ്കിൽ): selfrowCount പരിധിയിൽ (MIN_COLUMN_COUNT , MAX_COLUMN_COUNT + 1): self.columnCount = mineCount ആണെങ്കിൽ കോളംകൗണ്ട്< self.rowCount * self.columnCount: if mineCount in range(MIN_MINE_COUNT, MAX_MINE_COUNT + 1): self.mineCount = mineCount else: self.mineCount = self.rowCount * self.columnCount - 1 self.firstStep = True self.gameOver = False self.cellsTable = for row in range(self.rowCount): cellsRow = for column in range(self.columnCount): cellsRow.append(MinesweeperCell(row, column)) self.cellsTable.append(cellsRow) def getCell(self, row, column): if row < 0 or column < 0 or self.rowCount <= row or self.columnCount <= column: return None return self.cellsTable[ row ][ column ] def isWin(self): for row in range(self.rowCount): for column in range(self.columnCount): cell = self.cellsTable[ row ][ column ] if not cell.mined and (cell.state != "opened" and cell.state != "flagged"): return False return True def isGameOver(self): return self.gameOver def openCell(self, row, column): cell = self.getCell(row, column) if not cell: return cell.open() if cell.mined: self.gameOver = True return if self.firstStep: self.firstStep = False self.generateMines() cell.counter = self.countMinesAroundCell(row, column) if cell.counter == 0: neighbours = self.getCellNeighbours(row, column) for n in neighbours: if n.state == "closed": self.openCell(n.row, n.column) def nextCellMark(self, row, column): cell = self.getCell(row, column) if cell: cell.nextMark() def generateMines(self): for i in range(self.mineCount): while True: row = random.randint(0, self.rowCount - 1) column = random.randint(0, self.columnCount - 1) cell = self.getCell(row, column) if not cell.state == "opened" and not cell.mined: cell.mined = True break def countMinesAroundCell(self, row, column): neighbours = self.getCellNeighbours(row, column) return sum(1 for n in neighbours if n.mined) def getCellNeighbours(self, row, column): neighbours = for r in range(row - 1, row + 2): neighbours.append(self.getCell(r, column - 1)) if r != row: neighbours.append(self.getCell(r, column)) neighbours.append(self.getCell(r, column + 1)) return filter(lambda n: n is not None, neighbours)
മുകളിൽ ഞങ്ങൾ സ്വീകാര്യമായ ഗെയിം ക്രമീകരണങ്ങളുടെ ശ്രേണി നിർവ്വചിക്കുന്നു:
MIN_ROW_COUNT = 5 MAX_ROW_COUNT = 30 MIN_COLUMN_COUNT = 5 MAX_COLUMN_COUNT = 30 MIN_MINE_COUNT = 1 MAX_MINE_COUNT = 800
പൊതുവേ, ഈ ക്രമീകരണങ്ങളും മോഡലിൻ്റെ ഭാഗമാക്കാം. എന്നിരുന്നാലും, ഫീൽഡിൻ്റെ വലിപ്പവും ഖനികളുടെ എണ്ണവും തികച്ചും സ്ഥിരമായ വിവരങ്ങളാണ്, അവ ഇടയ്ക്കിടെ മാറാൻ സാധ്യതയില്ല.
അടുത്തതായി ഞങ്ങൾ ഗെയിം സെൽ ക്ലാസ് മൈൻസ്വീപ്പർസെൽ നിർവചിച്ചു. ഇത് വളരെ ലളിതമായി മാറി. ക്ലാസ് കൺസ്ട്രക്റ്ററിൽ, സെൽ ഫീൽഡുകൾ ഡിഫോൾട്ട് മൂല്യങ്ങളിലേക്ക് ആരംഭിക്കുന്നു. അടുത്തതായി, സൈക്ലിക് സ്റ്റേറ്റ് ട്രാൻസിഷനുകൾ നടപ്പിലാക്കുന്നത് ലളിതമാക്കാൻ, ഞങ്ങൾ markSequence ഓക്സിലറി ലിസ്റ്റ് ഉപയോഗിക്കുന്നു. സെൽ "തുറന്ന" അവസ്ഥയിലാണെങ്കിൽ, അത് ഈ ലിസ്റ്റിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല, അടുത്ത മാർക്ക്() രീതിയിൽ ഒന്നും സംഭവിക്കില്ല, അല്ലാത്തപക്ഷം സെൽ അടുത്ത അവസ്ഥയിലേക്ക് പോകുന്നു, അവസാനം "ചോദ്യം ചെയ്ത" അവസ്ഥയിൽ നിന്ന് അത് "ചാടി" " പ്രാരംഭ "അടഞ്ഞ" അവസ്ഥയിലേക്ക് ". ഓപ്പൺ () രീതിയിൽ, ഞങ്ങൾ സെല്ലിൻ്റെ അവസ്ഥ പരിശോധിക്കുന്നു, അത് "ഫ്ലാഗ്" ചെയ്തിട്ടില്ലെങ്കിൽ, സെൽ "തുറന്ന" എന്ന തുറന്ന അവസ്ഥയിലേക്ക് പോകുന്നു.
അടുത്തതായി മൈൻസ്വീപ്പർ മോഡൽ മോഡൽ ക്ലാസിൻ്റെ നിർവചനം വരുന്നു. StartGame() രീതി അതിലേക്ക് കൈമാറിയ rowCount, columnCount, mineCount പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് കളിക്കളത്തെ ലേഔട്ട് ചെയ്യുന്നു. ഓരോ പരാമീറ്ററും അത് സ്വീകാര്യമായ മൂല്യങ്ങളുടെ പരിധിക്കുള്ളിലാണോ എന്ന് പരിശോധിക്കുന്നു. പ്രക്ഷേപണം ചെയ്ത മൂല്യം പരിധിക്ക് പുറത്താണെങ്കിൽ, പ്ലേയിംഗ് ഫീൽഡ് പാരാമീറ്ററിൻ്റെ മൂല്യം സംരക്ഷിക്കപ്പെടും, അത് മാറില്ല. ഖനികളുടെ എണ്ണത്തിന് ഒരു അധിക പരിശോധന ഉണ്ടെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. കൈമാറ്റം ചെയ്യപ്പെട്ട മൈനുകളുടെ എണ്ണം ഫീൽഡ് വലുപ്പത്തേക്കാൾ കൂടുതലാണെങ്കിൽ, ഞങ്ങൾ അതിനെ ഒരു യൂണിറ്റ് ഇല്ലാത്ത സെല്ലുകളുടെ എണ്ണത്തിലേക്ക് പരിമിതപ്പെടുത്തുന്നു. തീർച്ചയായും, അത്തരമൊരു ഗെയിമിന് വലിയ അർത്ഥമില്ലെങ്കിലും ഒരു ഘട്ടത്തിൽ പൂർത്തിയാകും, അതിനാൽ അത്തരമൊരു കേസിനായി നിങ്ങൾക്ക് നിങ്ങളുടേതായ ചില നിയമങ്ങൾ കൊണ്ടുവരാൻ കഴിയും.
സെൽ ടേബിൾ വേരിയബിളിലെ സെല്ലുകളുടെ ലിസ്റ്റുകളുടെ ഒരു ലിസ്‌റ്റായി പ്ലേ ഫീൽഡ് സംഭരിച്ചിരിക്കുന്നു. മാത്രമല്ല, startGame() രീതിയിൽ, സെല്ലുകളുടെ സ്ഥാന മൂല്യം മാത്രമേ സജ്ജീകരിച്ചിട്ടുള്ളൂ, പക്ഷേ ഖനികൾ ഇതുവരെ സ്ഥാപിച്ചിട്ടില്ല. എന്നാൽ ട്രൂ എന്ന മൂല്യം ഉപയോഗിച്ചാണ് ഫസ്റ്റ് സ്റ്റെപ്പ് വേരിയബിൾ നിർവചിച്ചിരിക്കുന്നത്. ആദ്യ നീക്കത്തിൽ നിന്ന് അവസരത്തിൻ്റെ ഘടകം നീക്കം ചെയ്യുന്നതിനും തൽക്ഷണ നഷ്ടം തടയുന്നതിനും ഇത് ആവശ്യമാണ്. ശേഷിക്കുന്ന സെല്ലുകളിൽ ആദ്യ നീക്കത്തിന് ശേഷം മൈനുകൾ സ്ഥാപിക്കും.
getCell() രീതി കളിക്കളത്തിലെ കളത്തെ വരി വരിയും നിര നിരയും ഉപയോഗിച്ച് തിരികെ നൽകുന്നു. വരിയുടെയോ നിരയുടെയോ മൂല്യം അസാധുവാണെങ്കിൽ, ഒന്നും നൽകില്ല.
കളിക്കളത്തിലെ തുറന്നിട്ടില്ലാത്ത എല്ലാ സെല്ലുകളും ഖനനം ചെയ്താൽ isWin() രീതി True നൽകുന്നു, അതായത്, വിജയത്തിൻ്റെ കാര്യത്തിൽ, അല്ലാത്തപക്ഷം അത് തെറ്റായി നൽകും. isGameOver() രീതി ഗെയിംഓവർ ക്ലാസ് ആട്രിബ്യൂട്ടിൻ്റെ മൂല്യം നൽകുന്നു.
ഓപ്പൺസെൽ() രീതി ഗെയിം സെൽ ഒബ്‌ജക്‌റ്റിലേക്ക് ഓപ്പൺ() കോൾ ഡെലിഗേറ്റ് ചെയ്യുന്നു, അത് മെത്തേഡ് പാരാമീറ്ററുകളിൽ വ്യക്തമാക്കിയ സ്ഥാനത്ത് കളിക്കളത്തിൽ സ്ഥിതിചെയ്യുന്നു. തുറന്ന സെൽ ഖനനം ചെയ്തതായി മാറുകയാണെങ്കിൽ, ഞങ്ങൾ ഗെയിംഓവർ മൂല്യം ട്രൂ ആയി സജ്ജീകരിച്ച് രീതിയിൽ നിന്ന് പുറത്തുകടക്കുന്നു. ഗെയിം ഇതുവരെ അവസാനിച്ചിട്ടില്ലെങ്കിൽ, ഫസ്റ്റ് സ്റ്റെപ്പിൻ്റെ മൂല്യം പരിശോധിച്ച് ഇത് ആദ്യ നീക്കമാണോ എന്ന് ഞങ്ങൾ നോക്കുന്നു. ഇത് ശരിക്കും ആദ്യ നീക്കമാണെങ്കിൽ, ജനറേറ്റ്മൈൻസ് () സഹായ രീതി ഉപയോഗിച്ച് മൈനുകൾ കളിക്കളത്തിൽ സ്ഥാപിക്കും, അത് ഞങ്ങൾ കുറച്ച് കഴിഞ്ഞ് സംസാരിക്കും. അടുത്തതായി, ഞങ്ങൾ ഖനനം ചെയ്ത അയൽ സെല്ലുകളുടെ എണ്ണം കണക്കാക്കുകയും പ്രോസസ്സ് ചെയ്യുന്ന സെല്ലിനായി കൌണ്ടർ ആട്രിബ്യൂട്ടിൻ്റെ അനുബന്ധ മൂല്യം സജ്ജമാക്കുകയും ചെയ്യുന്നു. കൌണ്ടർ പൂജ്യമാണെങ്കിൽ, getCellNeighbours() രീതി ഉപയോഗിച്ച് ഞങ്ങൾ അയൽ സെല്ലുകളുടെ ഒരു ലിസ്റ്റ് അഭ്യർത്ഥിക്കുകയും എല്ലാ അടച്ച "അയൽക്കാർക്കും", അതായത് "അടച്ച" സ്റ്റാറ്റസുള്ള സെല്ലുകൾക്കായി ഓപ്പൺസെൽ() രീതി ആവർത്തിച്ച് വിളിക്കുകയും ചെയ്യുന്നു.
NextCellMark() രീതി, പാസ്സായ സ്ഥാനത്ത് സ്ഥിതി ചെയ്യുന്ന സെല്ലിനായുള്ള നെക്സ്റ്റ് മാർക്ക്() രീതിയിലേക്ക് കോൾ ഡെലിഗേറ്റ് ചെയ്യുന്നു.
GenerateMines() രീതിയിലാണ് ഖനികൾ സ്ഥാപിക്കുന്നത്. ഇവിടെ ഞങ്ങൾ കളിക്കളത്തിൽ ക്രമരഹിതമായി ഒരു സ്ഥാനം തിരഞ്ഞെടുത്ത് ഈ സ്ഥാനത്തുള്ള സെൽ തുറന്നിട്ടില്ലെന്നും ഇതിനകം ഖനനം ചെയ്തിട്ടില്ലെന്നും പരിശോധിക്കുക. രണ്ട് നിബന്ധനകളും പാലിക്കുകയാണെങ്കിൽ, ഞങ്ങൾ ഖനനം ചെയ്ത ആട്രിബ്യൂട്ടിൻ്റെ മൂല്യം True ആയി സജ്ജീകരിക്കും, അല്ലാത്തപക്ഷം ഞങ്ങൾ മറ്റൊരു സ്വതന്ത്ര സെല്ലിനായി തിരയുന്നത് തുടരും. പൈത്തണിൽ റാൻഡം മൊഡ്യൂൾ ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ അത് ഇറക്കുമതി റാൻഡം കമാൻഡ് ഉപയോഗിച്ച് വ്യക്തമായി ഇറക്കുമതി ചെയ്യേണ്ടതുണ്ട് എന്നത് മറക്കരുത്.
കളിക്കളത്തിലെ ഒരു നിശ്ചിത സെല്ലിന് ചുറ്റുമുള്ള മൈനുകളുടെ എണ്ണം കണക്കാക്കുന്നതിനുള്ള CountMinesAroundCell() രീതി പൂർണ്ണമായും getCellNeighbours() രീതിയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്. getCellNeighbours() രീതിയിൽ ഒരു സെല്ലിൻ്റെ "അയൽക്കാർ" അഭ്യർത്ഥിക്കുന്നതും വളരെ ലളിതമായി നടപ്പിലാക്കുന്നു. നിങ്ങൾക്ക് അതിൽ എന്തെങ്കിലും പ്രശ്‌നമുണ്ടാകുമെന്ന് ഞാൻ കരുതുന്നില്ല.
മൈൻസ്വീപ്പർ വ്യൂ
ഇനി നമുക്ക് ഷോയിലേക്ക് വരാം. മൈൻസ്വീപ്പർവ്യൂ ക്ലാസിനായുള്ള പൈത്തൺ കോഡ് ചുവടെയുണ്ട്:
ക്ലാസ് മൈൻസ്വീപ്പർവ്യൂ(ഫ്രെയിം): def __init__(സ്വയം, മോഡൽ, കൺട്രോളർ, പേരൻ്റ് = ഒന്നുമില്ല): ഫ്രെയിം.__init__(സ്വയം, രക്ഷകർത്താവ്) self.model = മോഡൽ self.controller = controller self.controller.setView(self) self.createBoard( ) പാനൽ = ഫ്രെയിം(സ്വയം) panel.pack(വശം = BOTTOM, fill = X) ബട്ടൺ(പാനൽ, ടെക്സ്റ്റ് = "പുതിയ ഗെയിം", കമാൻഡ് = self.controller.startNewGame).pack(side = RIGHT) self.mineCount = StringVar (പാനൽ) self.mineCount.set(self.model.mineCount) സ്പിൻബോക്സ്(പാനൽ, from_ = MIN_MINE_COUNT, to = MAX_MINE_COUNT, textvariable = self.mineCount, വീതി = 5).പാക്ക്(വശം = വലത്) ലേബൽ(പാനൽ, ടെക്സ്റ്റ് = " മിനിറ്റുകളുടെ എണ്ണം: ").pack(side = RIGHT) self.rowCount = StringVar(panel) self.rowCount.set(self.model.rowCount) Spinbox(panel, from_ = MIN_ROW_COUNT, to = MAX_ROW_COUNT, textvariable = self. വരിസംഖ്യ , വീതി = 5).പാക്ക്(വശം = വലത്) ലേബൽ(പാനൽ, ടെക്സ്റ്റ് = "x ").പാക്ക്(വശം = വലത്) self.columnCount = StringVar(panel) self.columnCount.set(self.model.columnCount) സ്പിൻബോക്സ് (പാനൽ, from_ = MIN_COLUMN_COUNT, to = MAX_COLUMN_COUNT, to = MAX_COLUMN_COUNT, textvariable = self.columnCount, width = 5).pack(side = RIGHT) Label(panel, text = "Field size: ").pack(side = RIGHT) def syncWithModel (self): ശ്രേണിയിലെ വരികൾക്കായി (self.model.rowCount): ശ്രേണിയിലെ നിരയ്ക്ക് (self.model.columnCount): സെൽ = self.model.getCell (വരി, കോളം) ആണെങ്കിൽ: btn = self.buttonsTable[ വരി ] [ കോളം ] self.model.isGameOver() ഉം cell.mined ഉം ആണെങ്കിൽ: btn.config(bg = "black", text = "") cell.state == "closed": btn.config(text = "" ) elif cell.state == "തുറന്നു": btn.config(ആശ്വാസം = മുങ്ങിപ്പോയി, ടെക്സ്റ്റ് = "") cell.counter > 0: btn.config(text = cell.counter) elif cell.mined: btn.config( bg = "red") elif cell.state == "ഫ്ലാഗഡ്": btn.config(ടെക്സ്റ്റ് = "P") elif cell.state == "ചോദ്യം ചെയ്തു": btn.config(text = "?") def blockCell(self , row, column, block = True): btn = self.buttonsTable[ row ][ column ] btn അല്ലെങ്കിൽ: block ആണെങ്കിൽ തിരികെ നൽകുക: btn.bind("
ഞങ്ങളുടെ കാഴ്ച tkinter മൊഡ്യൂളിൽ നിന്നുള്ള ഫ്രെയിം ക്ലാസിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, അതിനാൽ ഉചിതമായ ഇറക്കുമതി കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നത് ഉറപ്പാക്കുക: tkinter ഇറക്കുമതിയിൽ നിന്ന് * . ക്ലാസ് കൺസ്ട്രക്റ്റർ മോഡലും കൺട്രോളറും കടന്നുപോകുന്നു. സെല്ലുകളിൽ നിന്ന് കളിസ്ഥലം സ്ഥാപിക്കാൻ createBoard() രീതി ഉടനടി വിളിക്കുന്നു. ഈ ആവശ്യത്തിനായി ഞങ്ങൾ സാധാരണ ബട്ടൺ ബട്ടണുകൾ ഉപയോഗിക്കുമെന്ന് ഞാൻ മുൻകൂട്ടി പറയട്ടെ. തുടർന്ന് ഒരു ഫ്രെയിം സൃഷ്ടിക്കപ്പെടുന്നു, അത് ഗെയിം പാരാമീറ്ററുകൾ വ്യക്തമാക്കുന്നതിനുള്ള ഒരു താഴെ പാനലായി പ്രവർത്തിക്കും. ഈ പാനലിൽ ഞങ്ങൾ തുടർച്ചയായി “പുതിയ ഗെയിം” ബട്ടൺ സ്ഥാപിക്കുന്നു, അതിൻ്റെ ഹാൻഡ്‌ലർ അതിൻ്റെ startNewGame() രീതിയിലുള്ള ഞങ്ങളുടെ കൺട്രോളറാണ്, തുടർന്ന് മൂന്ന് Spinbox കൗണ്ടറുകൾ, അതുവഴി കളിക്കാരന് കളിക്കളത്തിൻ്റെ വലുപ്പവും മൈനുകളുടെ എണ്ണവും വ്യക്തമാക്കാൻ കഴിയും.
syncWithModel() രീതി ഓരോ ഗെയിം സെല്ലിലൂടെയും രണ്ടുതവണ ലൂപ്പ് ചെയ്യുകയും അതിനനുസരിച്ച് ഞങ്ങളുടെ GUI-ൽ അതിനെ പ്രതിനിധീകരിക്കുന്ന ബട്ടണിൻ്റെ രൂപം മാറ്റുകയും ചെയ്യുന്നു. ലാളിത്യത്തിനായി, നൊട്ടേഷൻ പ്രദർശിപ്പിക്കാൻ ഞാൻ ടെക്സ്റ്റ് ചിഹ്നങ്ങൾ ഉപയോഗിച്ചു, എന്നാൽ ബാഹ്യ ഗ്രാഫിക്സ് ഫയലുകളിൽ നിന്ന് ഗ്രാഫിക്സിലേക്ക് ടെക്സ്റ്റ് മാറ്റുന്നത് അത്ര ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല.
കൂടാതെ, ഒരു തുറന്ന സെല്ലിനെ പ്രതിനിധീകരിക്കാൻ ഞങ്ങൾ SUNKEN ബട്ടൺ ശൈലിയാണ് ഉപയോഗിക്കുന്നതെന്ന കാര്യം ശ്രദ്ധിക്കുക. നഷ്‌ടമുണ്ടായാൽ, കളിക്കളത്തിലെ എല്ലാ ഖനികളുടെയും സ്ഥാനം ഞങ്ങൾ തുറക്കുന്നു, അനുബന്ധ ബട്ടണുകൾ കറുപ്പിൽ കാണിക്കുന്നു, കൂടാതെ അവസാനത്തെ തുറന്ന സെല്ലുമായി ബന്ധപ്പെട്ട ബട്ടൺ ചുവപ്പ് നിറത്തിൽ ഹൈലൈറ്റ് ചെയ്യുന്നു:
ഇനിപ്പറയുന്ന ബ്ലോക്ക്‌സെൽ() രീതി ഒരു സപ്പോർട്ടിംഗ് റോൾ നൽകുന്നു കൂടാതെ ബട്ടണുകളുടെ തടയൽ നില സജ്ജമാക്കാൻ കൺട്രോളറെ അനുവദിക്കുന്നു. ഫ്ലാഗുചെയ്‌ത ഗെയിം സെല്ലുകൾ ആകസ്മികമായി തുറക്കുന്നത് തടയാനാണിത്, കൂടാതെ ഒരു ശൂന്യമായ ഇടത്-ക്ലിക്ക് ഹാൻഡ്‌ലർ സജ്ജീകരിച്ച് ഇത് നേടുന്നു.
getGameSettings() രീതി കളിക്കളത്തിൻ്റെ വലുപ്പവും മൈനുകളുടെ എണ്ണവും ഉപയോഗിച്ച് താഴെയുള്ള പാനലിൽ സ്ഥിതിചെയ്യുന്ന കൗണ്ടറുകളുടെ മൂല്യങ്ങൾ നൽകുന്നു.
കളിക്കളത്തിൻ്റെ ഒരു പ്രാതിനിധ്യം സൃഷ്ടിക്കുന്നത് createBoard() രീതിയിലാണ്. ഒന്നാമതായി, പഴയ കളിസ്ഥലം നിലവിലുണ്ടെങ്കിൽ അത് ഇല്ലാതാക്കാൻ ഞങ്ങൾ ശ്രമിക്കുന്നു, കൂടാതെ മോഡലിൻ്റെ നിലവിലെ കോൺഫിഗറേഷന് അനുസൃതമായി പാനലിൽ നിന്ന് കൌണ്ടർ മൂല്യങ്ങൾ സജ്ജമാക്കാനും ഞങ്ങൾ ശ്രമിക്കുന്നു. കളിക്കളത്തെ പ്രതിനിധീകരിക്കുന്നതിനായി ഒരു പുതിയ ഫ്രെയിം സൃഷ്ടിക്കപ്പെടുന്നു, അതിനെ ഞങ്ങൾ ബോർഡ് എന്ന് വിളിക്കും. ഇരട്ട ലൂപ്പ് ഉപയോഗിച്ച് മോഡലിലെ ഗെയിം സെല്ലുകളുടെ അതേ തത്വമനുസരിച്ച് ഞങ്ങൾ ബട്ടണുകളുടെ പട്ടിക രചിക്കുന്നു. ഓരോ ബട്ടണിൻ്റെയും ഹാൻഡ്‌ലറുകൾ യഥാക്രമം ഇടത്, വലത് മൗസ് ബട്ടണുകൾ ക്ലിക്കുചെയ്യുന്നതിനുള്ള കൺട്രോളറുടെ onLeftClick() and onRightClick() രീതികളുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.
അവസാനത്തെ രണ്ട് രീതികൾ ShowWinMessage() ഉം showGameOverMessage() എന്നിവയും showinfo() ഫംഗ്ഷൻ ഉപയോഗിച്ച് അനുബന്ധ സന്ദേശങ്ങളുള്ള ഡയലോഗ് ബോക്സുകൾ പ്രദർശിപ്പിക്കുക. ഇത് ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ ഒരു മൊഡ്യൂൾ കൂടി ഇറക്കുമതി ചെയ്യേണ്ടതുണ്ട്: tkinter.messagebox ഇറക്കുമതി * .
കൺട്രോളർ മൈൻസ്വീപ്പർ കൺട്രോളർ
ഇപ്പോൾ ഞങ്ങൾ കൺട്രോളർ നടപ്പിലാക്കുന്നതിലേക്ക് എത്തി:
ക്ലാസ് മൈൻസ്വീപ്പർ കൺട്രോളർ: def __init__(സ്വയം, മോഡൽ): self.model = മോഡൽ def setView(self, view): self.view = view def startNewGame(self): gameSettings = self.view.getGameSettings() try: self.model. startGame(*map(int, game Settings)) ഒഴികെ: self.model.startGame(self.model.rowCount, self.model.columnCount, self.model.mineCount) self.view.createBoard() def onLeftClick(self, row, കോളം): self.model.openCell(വരി, കോളം) self.view.syncWithModel() ആണെങ്കിൽ self.model.isWin(): self.view.showWinMessage() self.startNewGame() elif self.model.isGameOver(): self.view.showGameOverMessage() self.startNewGame() def onRightClick(self, row, column): self.model.nextCellMark(വരി, നിര) self.view.blockCell(വരി, നിര, self.model.getCell(വരി, കോളം).state == "ഫ്ലാഗുചെയ്‌തത്") self.view.syncWithModel()
കാഴ്ച കൺട്രോളറുമായി ബന്ധിപ്പിക്കുന്നതിന്, ഞങ്ങൾ setView() രീതി ചേർത്തു. കാരണം, കൺസ്‌ട്രക്‌ടർക്ക് ഒരു കാഴ്ച കൈമാറാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, കൺട്രോളർ സൃഷ്ടിക്കുന്നതിന് മുമ്പ് ഈ കാഴ്ച നിലവിലുണ്ടാകണം. ബൈൻഡിംഗിനുള്ള ഒരു അധിക രീതിയുള്ള സമാനമായ ഒരു പരിഹാരം കൺട്രോളറിൽ നിന്ന് കാഴ്ചയിലേക്ക് നീങ്ങും, അതിൽ setController() രീതി ദൃശ്യമാകും.
പുതിയ ഗെയിം ബട്ടൺ ക്ലിക്കുചെയ്യുന്നതിനുള്ള ഹാൻഡ്‌ലർ രീതി, startNewGame(), ആദ്യം കാഴ്ചയിൽ നൽകിയ ഗെയിം പാരാമീറ്ററുകൾ അഭ്യർത്ഥിക്കുന്നു. ഗെയിം പാരാമീറ്ററുകൾ മൂന്ന് ഘടകങ്ങളുടെ ഒരു ട്യൂപ്പിൾ ആയി നൽകുന്നു, അത് ഞങ്ങൾ int ആയി പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കുന്നു. എല്ലാം ശരിയായി നടക്കുന്നുണ്ടെങ്കിൽ, കളിസ്ഥലം നിർമ്മിക്കുന്നതിനുള്ള മോഡലിൻ്റെ സ്റ്റാർട്ട് ഗെയിം () രീതിയിലേക്ക് ഞങ്ങൾ ഈ മൂല്യങ്ങൾ കൈമാറുന്നു. എന്തെങ്കിലും തെറ്റ് സംഭവിച്ചാൽ, പഴയ പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ കളിക്കളത്തെ പുനർനിർമ്മിക്കും. അവസാനമായി, createBoard() രീതി വിളിച്ച് വ്യൂവിൽ ഗെയിം ബോർഡിൻ്റെ ഒരു പുതിയ ഡിസ്പ്ലേ സൃഷ്ടിക്കാൻ ഞങ്ങൾ ഒരു അഭ്യർത്ഥന നടത്തുന്നു.
കളിക്കാരൻ തിരഞ്ഞെടുത്ത സ്ഥാനത്ത് ഗെയിം സെൽ തുറക്കാൻ onLeftClick() ഹാൻഡ്‌ലർ ആദ്യം മോഡലിനോട് പറയുന്നു. മോഡലിൻ്റെ അവസ്ഥ മാറിയെന്ന് അത് കാഴ്ചയെ അറിയിക്കുകയും എല്ലാം വീണ്ടും വരയ്ക്കാൻ വാഗ്ദാനം ചെയ്യുകയും ചെയ്യുന്നു. അപ്പോൾ മോഡൽ വിജയമോ തോൽവിയോ പരിശോധിക്കുന്നു. ഇതിലേതെങ്കിലും സംഭവിക്കുകയാണെങ്കിൽ, ഉചിതമായ അറിയിപ്പ് പ്രദർശിപ്പിക്കുന്നതിന് ആദ്യം കാഴ്ചയിലേക്ക് ഒരു അഭ്യർത്ഥന അയയ്‌ക്കും, തുടർന്ന് ഒരു പുതിയ ഗെയിം ആരംഭിക്കാൻ startNewGame() ഹാൻഡ്‌ലറെ വിളിക്കും.
onRightClick() രീതിയിലാണ് റൈറ്റ് ക്ലിക്ക് കൈകാര്യം ചെയ്യുന്നത്. തിരഞ്ഞെടുത്ത ഗെയിം സെല്ലിൻ്റെ അടയാളം ചാക്രികമായി മാറ്റുന്നതിനുള്ള മോഡലിൻ്റെ നെക്സ്റ്റ് സെൽമാർക്ക്() രീതിയെ ആദ്യ വരി വിളിക്കുന്നു. സെല്ലിൻ്റെ പുതിയ അവസ്ഥയെ ആശ്രയിച്ച്, അനുബന്ധ ബട്ടണിലെ ലോക്ക് സജ്ജീകരിക്കുന്നതിനോ നീക്കംചെയ്യുന്നതിനോ ഒരു അഭ്യർത്ഥന കാഴ്ചയിലേക്ക് അയയ്ക്കുന്നു. അവസാനം, മോഡലിൻ്റെ നിലവിലെ അവസ്ഥ പ്രദർശിപ്പിക്കുന്നതിന് കാഴ്ച വീണ്ടും അപ്ഡേറ്റ് ചെയ്യുന്നു.
മോഡൽ, വ്യൂ, കൺട്രോളർ എന്നിവ സംയോജിപ്പിക്കുന്നു
MVC പാറ്റേൺ അടിസ്ഥാനമാക്കി മൈൻസ്വീപ്പർ നടപ്പിലാക്കുന്നതിലെ എല്ലാ ഘടകങ്ങളും ബന്ധിപ്പിച്ച് ഗെയിം സമാരംഭിക്കുക എന്നതാണ് ഇപ്പോൾ അവശേഷിക്കുന്നത്:
മോഡൽ = മൈൻസ്വീപ്പർ മോഡൽ () കൺട്രോളർ = മൈൻസ്വീപ്പർ കൺട്രോളർ (മോഡൽ); കാഴ്ച = MinesweeperView(മോഡൽ, കൺട്രോളർ) view.pack() view.mainloop()
ഉപസംഹാരം
അതിനാൽ ഞങ്ങൾ MVC പാറ്റേൺ നോക്കി. നമുക്ക് സിദ്ധാന്തത്തിലൂടെ ഹ്രസ്വമായി പോകാം. പ്രശ്‌ന പ്രസ്താവനയിൽ നിന്നും ആർക്കിടെക്ചർ ഡിസൈനിൽ നിന്നും tkinter ഗ്രാഫിക്കൽ മൊഡ്യൂൾ ഉപയോഗിച്ച് പൈത്തൺ പ്രോഗ്രാമിംഗ് ഭാഷയിൽ നടപ്പിലാക്കുന്നത് വരെ ഞങ്ങൾ ഘട്ടം ഘട്ടമായി ഒരു സമ്പൂർണ്ണ ഗെയിമിംഗ് ആപ്ലിക്കേഷൻ സൃഷ്ടിച്ചു.
ശരി, ഒന്നാമതായി, തീർച്ചയായും, ഇത് ഒരു മാതൃകയാണ് അല്ലെങ്കിൽ മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഇൻ്റർനെറ്റിൽ വെബ്‌സൈറ്റുകളും ആപ്ലിക്കേഷനുകളും വികസിപ്പിക്കുന്നതിനുള്ള ഒരു സമീപനമാണ്, രണ്ടാമതായി, വികസിപ്പിക്കുന്ന സിസ്റ്റങ്ങളുടെ കാര്യക്ഷമത മെച്ചപ്പെടുത്തുന്നതിനും സുരക്ഷ ഉറപ്പാക്കുന്നതിനും MVC ഉപയോഗിക്കുന്നു. ഹാക്കിംഗിനെതിരായ പ്രതിരോധവും.
എംവിസി എന്നതിൻ്റെ അർത്ഥം മോഡൽ-കാണുക-കണ്ട്രോളർഎന്ന് അക്ഷരാർത്ഥത്തിൽ വിവർത്തനം ചെയ്യാം മോഡൽ-വ്യൂ-കൺട്രോളർ.
വികസന മോഡൽ പുതിയതായി തോന്നുന്നുണ്ടെങ്കിലും, ഇത് വളരെക്കാലമായി സ്വയം തെളിയിക്കപ്പെട്ടിട്ടുണ്ട് കൂടാതെ വെബ്‌സൈറ്റുകളുടെ വികസനത്തിൽ വ്യാപകമായി ഉപയോഗിക്കപ്പെടുന്നു. MVC ആശയം ആദ്യമായി വിവരിച്ചത് 1979-ൽ ട്രിഗ്വ് റീൻസ്‌കാഗ് ആണ്.
MVC ആശയം അല്ലെങ്കിൽ അതിൽ എന്താണ് അടങ്ങിയിരിക്കുന്നത്
MVC മോഡൽമൂന്ന് ഘടകങ്ങൾ ഉൾപ്പെടുന്നു: മോഡൽ, വ്യൂ, കൺട്രോളർ.
ഇവിടെ ഏറ്റവും പ്രധാനപ്പെട്ട കാര്യം, തീർച്ചയായും, മോഡൽ ആണ്. ഡാറ്റ പ്രോസസ്സിംഗിനുള്ള നടപടിക്രമങ്ങളുടെയും അൽഗോരിതങ്ങളുടെയും ഒരു കൂട്ടമാണ് മോഡൽ. മോഡലിൽ തന്നെ ഡാറ്റ അടങ്ങിയിട്ടില്ല, പക്ഷേ ഒരു ചട്ടം പോലെ, അത് ഡാറ്റാബേസിൽ നിന്ന് എടുത്ത് മുൻകൂട്ടി നിർവചിച്ച അൽഗോരിതം അനുസരിച്ച് പ്രോസസ്സ് ചെയ്യുന്നു. നമ്മൾ വെബ് വികസനത്തെക്കുറിച്ച് സംസാരിക്കുകയാണെങ്കിൽ, മോഡലിൽ ഒരു കൂട്ടം ക്ലാസുകളും ഫംഗ്ഷനുകളും അടങ്ങിയിരിക്കും, ഉദാഹരണത്തിന് PHP-യിൽ.
രണ്ടാമത്തെ ഘടകം കാഴ്ചയാണ്. വിവരങ്ങൾ പ്രദർശിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇതൊരു വെബ്‌സൈറ്റാണെങ്കിൽ, വിവരങ്ങൾ ബ്രൗസറിൽ പ്രദർശിപ്പിക്കും. വെബ്‌സൈറ്റുകൾ വികസിപ്പിക്കുമ്പോൾ, ഒരു കാഴ്ചയിൽ HTML കോഡ് അടങ്ങിയിരിക്കുന്നു, അതിൽ വേരിയബിളുകൾ മാറ്റിസ്ഥാപിക്കുന്നു, അവ മോഡലിൽ നിന്നല്ല, കൺട്രോളറിൽ നിന്നാണ് എടുത്തത്.
അതിനാൽ, മൂന്നാമത്തെ ഘടകം കൺട്രോളർ ആണ്. ഉപയോക്താവും മോഡലും തമ്മിലുള്ള ആശയവിനിമയം നൽകുക എന്നതാണ് ഇതിൻ്റെ പ്രധാന പ്രവർത്തനം. PHP കോഡും അടങ്ങിയിരിക്കാം.
പല തുടക്കക്കാരായ ഡെവലപ്പർമാരും മോഡൽ ഉപയോഗിക്കുന്നില്ല അല്ലെങ്കിൽ ഡാറ്റാബേസ് ആക്സസ് ചെയ്യാൻ മാത്രം ഉപയോഗിക്കുന്നില്ല, ഇത് MVC മോഡലിൻ്റെ യുക്തിക്ക് വിരുദ്ധവും തെറ്റായതും ഒരു പ്രധാന തെറ്റുമാണ്. കൂടാതെ എല്ലാ പ്രധാന കോഡുകളും കൺട്രോളറിൽ സ്ഥാപിച്ചിരിക്കുന്നു. ഇതിൻ്റെ അനന്തരഫലങ്ങൾ, ഒന്നാമതായി, ഒരു വലിയ കോഡ്, രണ്ടാമതായി, കുറഞ്ഞ ആപ്ലിക്കേഷൻ വേഗത. ശരി, അത്തരം ആപ്ലിക്കേഷനുകളുടെ കോഡിൽ മാറ്റങ്ങൾ വരുത്തുന്നത് കൂടുതൽ ബുദ്ധിമുട്ടാണ്.
ഉദാഹരണത്തിന്, ഒരു വാർത്താ സൈറ്റിനായുള്ള MVC മോഡൽ പരിഗണിക്കുക
ഉപയോക്താവ് ഒരു വെബ്സൈറ്റ് പേജിൽ ഇറങ്ങുന്നു. വാർത്തകളുടെ ഒരു നിർദ്ദിഷ്ട ലിസ്റ്റുള്ള ഒരു സ്ഥിരസ്ഥിതി പേജ് അവനെ കാണിക്കുന്നു. വാർത്തകൾ സൃഷ്ടിക്കുന്നതിനുള്ള വിവരങ്ങൾ ഡാറ്റാബേസിൽ നിന്ന് എടുത്തതാണ്.
ബ്രൗസറിൻ്റെ വിലാസ ബാറിൽ ഉപയോക്താവ് ഒരു നിർദ്ദിഷ്ട പേജ് ടൈപ്പ് ചെയ്യുമ്പോൾ, അഭ്യർത്ഥന കൺട്രോളറിലേക്ക് കൈമാറുകയും അത് പ്രോസസ്സ് ചെയ്യുകയും മോഡൽ ലോഡുചെയ്യുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ സമാരംഭിക്കും.
മോഡൽ, ആവശ്യമായ ഡാറ്റ സ്വീകരിച്ച്, ഇതിനകം പ്രോസസ്സ് ചെയ്ത് ഒരു ഒബ്ജക്റ്റ് അല്ലെങ്കിൽ അറേ ആയി ഗ്രൂപ്പുചെയ്‌തു, ഡാറ്റാബേസിലേക്ക് ഒരു ചോദ്യം സൃഷ്ടിക്കും. ഡാറ്റ ലഭിച്ച ശേഷം, മോഡൽ അതിനെ ഒരു പ്രത്യേക രൂപത്തിലേക്ക് രൂപപ്പെടുത്തുകയും കൺട്രോളറിലേക്ക് മാറ്റുകയും തുടർന്ന് അത് കാഴ്ചയിലേക്ക് മാറ്റുകയും ചെയ്യുന്നു. ഡാറ്റ നേരിട്ട് കാഴ്ചയിലേക്ക് കൈമാറുകയാണെങ്കിൽ അത് ഒരു പിശക് ആകില്ല. എന്നാൽ വീണ്ടും, അനാവശ്യ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നു, ഇത് ആത്യന്തികമായി സൈറ്റിനും ആപ്ലിക്കേഷനുകൾക്കുമായി കൂടുതൽ ലോഡിംഗ് സമയങ്ങളിലേക്ക് നയിക്കുന്നു.
വാർത്തകളുള്ള ഒരു അറേയോ ഒബ്‌ജക്‌റ്റോ ലഭിച്ച കാഴ്ച, ആവശ്യമെങ്കിൽ ചില HTML കോഡ്, CSS എന്നിവ ലോഡ് ചെയ്യുന്നു, കൂടാതെ ജാവാസ്ക്രിപ്റ്റ് ഇതെല്ലാം ഉപയോക്താവിന് പ്രദർശിപ്പിക്കുന്നു.
ഈ മോഡൽ നിരവധി നിയന്ത്രണ സംവിധാനങ്ങളിലും ചട്ടക്കൂടുകളിലും ഉപയോഗിക്കുന്നു, അതിലൊന്നാണ് കോഡ് ഇഗ്നിറ്റർ, ഇത് അടുത്തിടെ ഒരു പുതിയ ജീവിതം നേടിയിട്ടുണ്ട്.
അതിനാൽ, MVC മോഡൽ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ഒരു വെബ്‌സൈറ്റിനോ ഇൻ്റർനെറ്റ് ആപ്ലിക്കേഷനോ വേണ്ടി ഒരു അഡ്മിനിസ്ട്രേഷൻ സിസ്റ്റം എളുപ്പത്തിൽ സൃഷ്ടിക്കാൻ കഴിയും. അതിനാൽ CodeIgniter ചട്ടക്കൂട് കൃത്യമായി ഈ മോഡൽ ഉപയോഗിക്കുന്നു.
ഗുഡ് ആഫ്റ്റർനൂൺ, പ്രിയ സഹപ്രവർത്തകർ. ഈ ലേഖനത്തിൽ MVC, MVP, MVVM പാറ്റേണുകൾ തമ്മിലുള്ള വ്യത്യാസങ്ങളെക്കുറിച്ചുള്ള എൻ്റെ വിശകലന ധാരണയെക്കുറിച്ച് സംസാരിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. വലിയ സോഫ്റ്റ്വെയർ വികസിപ്പിക്കുന്നതിനുള്ള ആധുനിക സമീപനങ്ങളും അനുബന്ധ വാസ്തുവിദ്യാ സവിശേഷതകളും മനസ്സിലാക്കാനുള്ള ആഗ്രഹമാണ് ഈ ലേഖനം എഴുതാൻ എന്നെ പ്രേരിപ്പിച്ചത്. എൻ്റെ കരിയർ ഗോവണിയുടെ നിലവിലെ ഘട്ടത്തിൽ, ഞാൻ ഒരു നേരിട്ടുള്ള ഡെവലപ്പർ അല്ല, അതിനാൽ ലേഖനത്തിൽ പിശകുകളും തെറ്റിദ്ധാരണകളും തെറ്റിദ്ധാരണകളും അടങ്ങിയിരിക്കാം. പ്രോഗ്രാമർമാരും ആർക്കിടെക്റ്റുകളും എന്താണ് ചെയ്യുന്നതെന്ന് വിശകലന വിദഗ്ധർ എങ്ങനെ കാണുന്നു എന്നതിൽ കൗതുകമുണ്ടോ? അപ്പോൾ പൂച്ചയിലേക്ക് സ്വാഗതം.
ലിങ്കുകൾ
ഈ ലേഖനം എഴുതുന്ന പ്രക്രിയയിൽ എന്നെ നയിച്ച ബാഹ്യ മെറ്റീരിയലുകളിലേക്കുള്ള ലിങ്കുകളാണ് ഞാൻ ആദ്യം ആരംഭിക്കാൻ ആഗ്രഹിക്കുന്നത്:ആമുഖം
സൂര്യൻ കൂടുതൽ പ്രകാശിക്കുകയും പുല്ല് പച്ചപിടിക്കുകയും ചെയ്ത ഒരു കാലത്ത്, ഈ ലേഖനത്തിൻ്റെ രചയിതാവിനെപ്പോലുള്ള ഒരു സംഘം വിദ്യാർത്ഥികൾ ഉൽപ്പന്ന ഇൻ്റർഫേസിലേക്ക് നേരിട്ട് നൂറുകണക്കിന് കോഡുകൾ എഴുതി സോഫ്റ്റ്വെയർ വികസിപ്പിച്ചെടുത്തു. ചിലപ്പോൾ സേവനങ്ങളും മാനേജർമാരും ഡാറ്റയുമായി പ്രവർത്തിക്കാൻ ഉപയോഗിച്ചു, തുടർന്ന് ഡോക്യുമെൻ്റ്-വ്യൂ പാറ്റേൺ ഉപയോഗിച്ച് പരിഹാരം ലഭിച്ചു. അത്തരം കോഡിനെ പിന്തുണയ്ക്കുന്നതിന് ഭീമമായ ചിലവുകൾ ആവശ്യമാണ്, കാരണം ഒരു പുതിയ ഡെവലപ്പർക്ക് ഉൽപ്പന്നത്തിൽ എന്ത് കോഡാണ് ഉത്തരവാദിയെന്ന് പരിശീലിപ്പിക്കണം (പറയണം). ഒരു മുറിയിൽ ഇരിക്കുന്ന 4 പേരാണ് വികസന സംഘം.സമയം കടന്നുപോയി, ജോലി മാറി. വികസിപ്പിച്ചുകൊണ്ടിരിക്കുന്ന ആപ്ലിക്കേഷനുകൾ വലുതും കൂടുതൽ സങ്കീർണ്ണവുമായിത്തീർന്നു, ഡവലപ്പർമാരുടെ ഒരു ഏകീകൃത ടീമിൽ നിന്ന് ഡെവലപ്പർമാർ, ആർക്കിടെക്റ്റുകൾ, ഉപയോഗക്ഷമത വിദഗ്ധർ, ഡിസൈനർമാർ, പിഎംമാർ എന്നിവരുടെ വിവിധ ടീമുകളായി മാറി. ഇപ്പോൾ ഓരോരുത്തരും അവരവരുടെ മേഖലയ്ക്ക് ഉത്തരവാദികളാണ്: GUI, ബിസിനസ് ലോജിക്, ഘടകങ്ങൾ. വിശകലനം, പരിശോധന, വാസ്തുവിദ്യ എന്നിവയുടെ ഒരു വകുപ്പ് പ്രത്യക്ഷപ്പെട്ടു. സോഫ്റ്റ്വെയർ വികസനത്തിൻ്റെ ചിലവ് നൂറുകണക്കിന് ആയിരക്കണക്കിന് മടങ്ങ് വർദ്ധിച്ചു. വികസനത്തിലേക്കുള്ള ഈ സമീപനത്തിന് ഉൽപ്പന്നത്തിൻ്റെ വിവിധ പ്രവർത്തന മേഖലകൾ പരസ്പരം സമന്വയിപ്പിക്കുന്ന ഒരു സ്ഥിരതയുള്ള വാസ്തുവിദ്യ ആവശ്യമാണ്.
പാറ്റേണുകൾ
സങ്കീർണ്ണമായ സോഫ്റ്റ്വെയർ വികസിപ്പിക്കുന്നതിനുള്ള തൊഴിൽ ചെലവ് കുറയ്ക്കുക എന്ന ലക്ഷ്യം കണക്കിലെടുക്കുമ്പോൾ, റെഡിമെയ്ഡ് ഏകീകൃത പരിഹാരങ്ങൾ ഉപയോഗിക്കേണ്ടത് ആവശ്യമാണെന്ന് ഞങ്ങൾ അനുമാനിക്കുന്നു. എല്ലാത്തിനുമുപരി, ടെംപ്ലേറ്റ് ചെയ്ത പ്രവർത്തനങ്ങൾ ഡവലപ്പർമാർ തമ്മിലുള്ള ആശയവിനിമയം സുഗമമാക്കുന്നു, അറിയപ്പെടുന്ന ഡിസൈനുകൾ റഫർ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു, പിശകുകളുടെ എണ്ണം കുറയ്ക്കുക.വിക്കിപീഡിയ അനുസരിച്ച്, ഡിസൈൻ പാറ്റേൺ എന്നത് ആവർത്തിക്കാവുന്ന വാസ്തുവിദ്യാ രൂപകല്പനയാണ്, അത് പതിവായി സംഭവിക്കുന്ന ചില സന്ദർഭങ്ങളിൽ ഡിസൈൻ പ്രശ്നത്തിനുള്ള പരിഹാരത്തെ പ്രതിനിധീകരിക്കുന്നു.
നമുക്ക് ആദ്യത്തെ പ്രധാന കാര്യം ആരംഭിക്കാം - മോഡൽ-വ്യൂ-കൺട്രോളർ. MVC എന്നത് ഒരു അടിസ്ഥാന പാറ്റേണാണ്, അത് നിരവധി സാങ്കേതിക വിദ്യകളിലേക്ക് കടന്നുവരുകയും പുതിയ സാങ്കേതികവിദ്യകൾക്ക് കാരണമാവുകയും ഡെവലപ്പർമാർക്ക് ജീവിതം എളുപ്പമാക്കുകയും ചെയ്യുന്നു.
MVC പാറ്റേൺ ആദ്യം പ്രത്യക്ഷപ്പെട്ടത് സ്മോൾ ടോക്ക് ഭാഷയിലാണ്. ബിസിനസ്സ് ലോജിക്കിൽ നിന്ന് ഗ്രാഫിക്കൽ ഇൻ്റർഫേസിനെയും ഡാറ്റയിൽ നിന്ന് ബിസിനസ്സ് ലോജിക്കിനെയും വേർതിരിക്കുന്ന ഒരു വാസ്തുവിദ്യാ പരിഹാരം ഡവലപ്പർമാർക്ക് കൊണ്ടുവരേണ്ടതുണ്ട്. അങ്ങനെ, അതിൻ്റെ ക്ലാസിക് പതിപ്പിൽ, MVC മൂന്ന് ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു, അത് അതിൻ്റെ പേര് നൽകുന്നു. നമുക്ക് അവ നോക്കാം:
മോഡൽ
ഒരു ആപ്ലിക്കേഷൻ്റെ പ്രവർത്തനപരമായ ബിസിനസ്സ് ലോജിക് ഉൾക്കൊള്ളുന്ന ഒരു ഭാഗമായാണ് ഒരു മോഡൽ സാധാരണയായി മനസ്സിലാക്കുന്നത്. ബാക്കിയുള്ള ഉൽപ്പന്നങ്ങളിൽ നിന്ന് മോഡൽ പൂർണ്ണമായും സ്വതന്ത്രമായിരിക്കണം. മോഡൽ ലെയറിന് ഡിസൈൻ ഘടകങ്ങളെക്കുറിച്ചോ അത് എങ്ങനെ റെൻഡർ ചെയ്യുമെന്നതിനെക്കുറിച്ചോ ഒന്നും അറിയേണ്ടതില്ല. മോഡലിൽ തന്നെ സ്പർശിക്കാതെ തന്നെ ഡാറ്റയുടെ അവതരണം, അവ എങ്ങനെ പ്രദർശിപ്പിക്കണം എന്നിവ മാറ്റാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ഫലം കൈവരിക്കുന്നു.മോഡലിന് ഇനിപ്പറയുന്ന സവിശേഷതകൾ ഉണ്ട്:
- ആപ്ലിക്കേഷൻ്റെ ബിസിനസ്സ് ലോജിക്കാണ് മോഡൽ;
- മോഡലിന് സ്വയം പരിജ്ഞാനമുണ്ട്, കൺട്രോളറുകളെയും കാഴ്ചകളെയും കുറിച്ച് അറിയില്ല;
- ചില പ്രോജക്റ്റുകൾക്ക്, മോഡൽ ഒരു ഡാറ്റ ലെയർ ആണ് (DAO, ഡാറ്റാബേസ്, XML ഫയൽ);
- മറ്റ് പ്രോജക്റ്റുകൾക്ക്, മോഡൽ ഒരു ഡാറ്റാബേസ് മാനേജർ, ഒബ്ജക്റ്റുകളുടെ ഒരു കൂട്ടം അല്ലെങ്കിൽ ലളിതമായി ആപ്ലിക്കേഷൻ ലോജിക് ആണ്;
കാണുക
കാഴ്ചയുടെ ഉത്തരവാദിത്തങ്ങളിൽ മോഡലിൽ നിന്ന് ലഭിച്ച ഡാറ്റ പ്രദർശിപ്പിക്കുന്നത് ഉൾപ്പെടുന്നു. എന്നിരുന്നാലും, കാഴ്ചയ്ക്ക് മോഡലിനെ നേരിട്ട് സ്വാധീനിക്കാൻ കഴിയില്ല. ഒരു കാഴ്ചയ്ക്ക് ഡാറ്റയിലേക്ക് റീഡ്-ഒൺലി ആക്സസ് ഉണ്ടെന്ന് നമുക്ക് പറയാം.പ്രാതിനിധ്യത്തിന് ഇനിപ്പറയുന്ന സവിശേഷതകൾ ഉണ്ട്:
- കാഴ്ച ഏതെങ്കിലും വിധത്തിൽ മോഡലിൽ നിന്ന് ലഭിക്കുന്ന ഡാറ്റയുടെ പ്രദർശനം നടപ്പിലാക്കുന്നു;
- ചില സാഹചര്യങ്ങളിൽ, കാഴ്ചയിൽ ചില ബിസിനസ്സ് യുക്തികൾ നടപ്പിലാക്കുന്ന കോഡ് ഉണ്ടായിരിക്കാം.
MVP, MVVM, MVP എന്നിവ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ
MVC പാറ്റേണിൻ്റെ ഏറ്റവും സാധാരണമായ തരങ്ങൾ ഇവയാണ്:- മോഡൽ-വ്യൂ-കൺട്രോളർ
- മോഡൽ-വ്യൂ-അവതാരകൻ
- മോഡൽ-വ്യൂ-വ്യൂ മോഡൽ
അവ ഓരോന്നും പരിഗണിക്കുകയും താരതമ്യം ചെയ്യുകയും ചെയ്യാം.
മോഡൽ-വ്യൂ-അവതാരകൻ
ഈ സമീപനം ഒരു പ്രാതിനിധ്യ അമൂർത്തീകരണം സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഒരു പ്രത്യേക സെറ്റ് പ്രോപ്പർട്ടികളും രീതികളും ഉള്ള ഒരു വ്യൂ ഇൻ്റർഫേസ് തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്. അവതാരകന്, ഇൻ്റർഫേസ് നടപ്പിലാക്കുന്നതിനുള്ള ഒരു റഫറൻസ് ലഭിക്കുന്നു, അവതരണ പരിപാടികൾ സബ്‌സ്‌ക്രൈബുചെയ്യുന്നു, കൂടാതെ അഭ്യർത്ഥന പ്രകാരം മോഡൽ പരിഷ്‌ക്കരിക്കുന്നു.
ഒരു അവതാരകൻ്റെ അടയാളങ്ങൾ:
- അവതാരകൻ്റെ സന്ദർഭത്തിൽ ഉചിതമായ ഫംഗ്ഷനുകളോ ഇവൻ്റുകളോ വിളിച്ച് കാഴ്ച അവതാരകനുമായി നേരിട്ട് സംവദിക്കുന്നു;
- കാഴ്ച നടപ്പിലാക്കിയ ഒരു പ്രത്യേക ഇൻ്റർഫേസ് ഉപയോഗിച്ച് അവതാരകൻ കാഴ്ചയുമായി സംവദിക്കുന്നു;
- ഒരു അവതാരക ഉദാഹരണം ഒരു ഡിസ്‌പ്ലേയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.
നടപ്പിലാക്കൽ:
ഓരോ കാഴ്ചയും അനുബന്ധ ഇൻ്റർഫേസ് നടപ്പിലാക്കണം. അവതരണ ഇൻ്റർഫേസ് ഉപയോക്താവുമായി സംവദിക്കാൻ ആവശ്യമായ ഫംഗ്ഷനുകളുടെയും ഇവൻ്റുകളുടെയും സെറ്റ് നിർവ്വചിക്കുന്നു (ഉദാഹരണത്തിന്, ഐവ്യൂ.ShowErrorMessage(string msg)). കൺസ്ട്രക്റ്ററിൽ സാധാരണയായി കടന്നുപോകുന്ന അനുബന്ധ ഇൻ്റർഫേസ് നടപ്പിലാക്കുന്നതിന് അവതാരകന് ഒരു റഫറൻസ് ഉണ്ടായിരിക്കണം.
അവതരണ ലോജിക്കിൽ അവതാരകൻ്റെ സന്ദർഭത്തിന് ഒരു റഫറൻസ് ഉണ്ടായിരിക്കണം. എല്ലാ വ്യൂ ഇവൻ്റുകളും പ്രോസസ്സിംഗിനായി അവതാരകന് കൈമാറുന്നു, അവ അവതരണ ലോജിക് (മറ്റ് കാഴ്ചകൾ സൃഷ്ടിക്കുന്നത് ഉൾപ്പെടെ) ഒരിക്കലും പ്രോസസ്സ് ചെയ്യപ്പെടുന്നില്ല.
ഉപയോഗ ഉദാഹരണം: വിൻഡോസ് ഫോമുകൾ.
മോഡൽ-വ്യൂ-വ്യൂ മോഡൽ
വ്യൂ മോഡലിൻ്റെ പ്രോപ്പർട്ടികൾ, ഇവൻ്റുകൾ എന്നിവയുമായി വ്യൂ ഘടകങ്ങളെ ബന്ധപ്പെടുത്താൻ ഈ സമീപനം നിങ്ങളെ അനുവദിക്കുന്നു. ഈ പാറ്റേണിൻ്റെ ഓരോ പാളിയും മറ്റൊരു പാളിയുടെ നിലനിൽപ്പിനെക്കുറിച്ച് അറിയില്ലെന്ന് വാദിക്കാം.
വ്യൂ മോഡലിൻ്റെ സവിശേഷതകൾ:
- അവതരണവുമായി രണ്ട്-വഴി ആശയവിനിമയം;
- ഒരു കാഴ്ച മോഡൽ ഒരു കാഴ്ചയുടെ അമൂർത്തീകരണമാണ്. സാധാരണയായി അർത്ഥമാക്കുന്നത് കാഴ്ചയുടെ ഗുണങ്ങളും കാഴ്ച/മോഡലിൻ്റെ ഗുണങ്ങളും ഒന്നുതന്നെയാണെന്നാണ്
- വ്യൂ മോഡലിന് വ്യൂ ഇൻ്റർഫേസിനെക്കുറിച്ച് (IView) ഒരു റഫറൻസ് ഇല്ല. ഡാറ്റ ബൈൻഡിംഗ് സംവിധാനം ഉപയോഗിക്കുന്നതിനാൽ വ്യൂ മോഡലിൻ്റെ അവസ്ഥ മാറ്റുന്നത് കാഴ്ചയെ സ്വയമേവ മാറ്റുകയും തിരിച്ചും മാറ്റുകയും ചെയ്യുന്നു (ബൈൻഡിംഗുകൾ)
- ഒരു വ്യൂ മോഡലിൻ്റെ ഒരു ഉദാഹരണം ഒരു കാഴ്ചയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.
നടപ്പിലാക്കൽ:
ഈ പാറ്റേൺ ഉപയോഗിക്കുമ്പോൾ, കാഴ്ച അനുബന്ധ ഇൻ്റർഫേസ് (IView) നടപ്പിലാക്കുന്നില്ല.
കാഴ്ചയ്ക്ക് ഡാറ്റ ഉറവിടത്തിലേക്ക് (DataContex) ഒരു ലിങ്ക് ഉണ്ടായിരിക്കണം ഈ സാഹചര്യത്തിൽകാഴ്ച മോഡൽ ആണ്. വ്യൂ എലമെൻ്റുകൾ വ്യൂ മോഡലിൻ്റെ അനുബന്ധ പ്രോപ്പർട്ടികൾ, ഇവൻ്റുകൾ എന്നിവയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.
അതാകട്ടെ, വ്യൂ മോഡൽ ഒരു പ്രത്യേക ഇൻ്റർഫേസ് നടപ്പിലാക്കുന്നു, അത് കാഴ്ച ഘടകങ്ങൾ സ്വയമേവ അപ്ഡേറ്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. WPF-ലെ അത്തരമൊരു ഇൻ്റർഫേസിൻ്റെ ഒരു ഉദാഹരണം INotifyPropertyChanged ആയിരിക്കും.
ഉപയോഗ ഉദാഹരണം: WPF
മോഡൽ-വ്യൂ-കൺട്രോളർ
കൺട്രോളറും കാഴ്ചയും മോഡലിനെ ആശ്രയിച്ചിരിക്കുന്നു എന്നതാണ് ഈ പാറ്റേണിൻ്റെ പ്രധാന ആശയം, എന്നാൽ മോഡൽ ഈ രണ്ട് ഘടകങ്ങളെ ആശ്രയിക്കുന്നില്ല.
കൺട്രോളർ സവിശേഷതകൾ
- ഏത് കാഴ്ചയാണ് ഇപ്പോൾ പ്രദർശിപ്പിക്കേണ്ടതെന്ന് കൺട്രോളർ നിർണ്ണയിക്കുന്നു;
- ഇവൻ്റുകൾ കാണുക കൺട്രോളറെ മാത്രമേ ബാധിക്കുകയുള്ളൂ. കൺട്രോളറിന് മോഡലിനെ ബാധിക്കാനും മറ്റൊരു കാഴ്ച നിർവചിക്കാനും കഴിയും.
- ഒരു കൺട്രോളറിന് ഒന്നിലധികം കാഴ്ചകൾ സാധ്യമാണ്;
നടപ്പിലാക്കൽ:
കൺട്രോളർ ഇവൻ്റിനെ പുറത്ത് നിന്ന് തടയുകയും അതിൽ ഉൾച്ചേർത്ത യുക്തിക്ക് അനുസൃതമായി, ഉചിതമായ രീതി വിളിച്ച് മോഡൽ മാറ്റിക്കൊണ്ട് ഈ ഇവൻ്റിനോട് പ്രതികരിക്കുകയും ചെയ്യുന്നു. ഒരു മാറ്റത്തിന് ശേഷം, മോഡൽ അത് മാറിയ ഇവൻ്റ് ഉപയോഗിക്കുന്നു, കൂടാതെ ഇത് സബ്‌സ്‌ക്രൈബുചെയ്‌ത എല്ലാ വ്യൂ ഇവൻ്റുകളും അത് സ്വീകരിച്ച ശേഷം, അപ്ഡേറ്റ് ചെയ്ത ഡാറ്റയ്‌ക്കായി മോഡലിലേക്ക് തിരിയുക, അതിനുശേഷം അവ പ്രദർശിപ്പിക്കും.
ഉപയോഗ ഉദാഹരണം: MVC ASP.NET
സംഗ്രഹം
MVVM, MVP പാറ്റേണുകൾ നടപ്പിലാക്കുന്നത്, ഒറ്റനോട്ടത്തിൽ, വളരെ ലളിതവും സമാനവുമാണ്. എന്നിരുന്നാലും, എംവിവിഎമ്മിനായി വ്യൂ-മോഡലിലേക്ക് വ്യൂ ബൈൻഡിംഗ് സ്വപ്രേരിതമായി നടക്കുന്നു, പക്ഷേ എംവിപിക്ക് പ്രോഗ്രാം ചെയ്യേണ്ടത് ആവശ്യമാണ്കാഴ്ചയിൽ എംവിസിക്ക് കൂടുതൽ നിയന്ത്രണം ഉണ്ടെന്ന് തോന്നുന്നു.
ഒരു പാറ്റേൺ തിരഞ്ഞെടുക്കുന്നതിനുള്ള പൊതു നിയമങ്ങൾ
എം.വി.വി.എം
- പ്രത്യേക വ്യൂ ഇൻ്റർഫേസുകൾ അവതരിപ്പിക്കേണ്ട ആവശ്യമില്ലാതെ ഡാറ്റ ബൈൻഡിംഗ് സാധ്യമാകുന്ന സാഹചര്യത്തിൽ ഉപയോഗിക്കുന്നു (അതായത് IView നടപ്പിലാക്കേണ്ട ആവശ്യമില്ല);
- ഒരു സാധാരണ ഉദാഹരണം WPF സാങ്കേതികവിദ്യയാണ്.
എം.വി.പി
- ഡാറ്റ ബൈൻഡിംഗ് സാധ്യമല്ലാത്ത സാഹചര്യത്തിൽ ഉപയോഗിക്കുന്നു (ബൈൻഡിംഗ് ഉപയോഗിക്കാൻ കഴിയില്ല);
- വിൻഡോസ് ഫോമുകൾ ഉപയോഗിക്കുന്നതാണ് ഒരു സാധാരണ ഉദാഹരണം.
എം.വി.സി
- കാഴ്ചയും ആപ്ലിക്കേഷൻ്റെ മറ്റ് ഭാഗങ്ങളും തമ്മിലുള്ള ആശയവിനിമയം സാധ്യമല്ലാത്ത സാഹചര്യത്തിൽ ഉപയോഗിക്കുന്നു (നിങ്ങൾക്ക് MVVM അല്ലെങ്കിൽ MVP ഉപയോഗിക്കാൻ കഴിയില്ല);
- ഒരു സാധാരണ ഉപയോഗ കേസ് ASP.NET MVC ആണ്.
ഉപസംഹാരം
ഉപസംഹാരമായി, ഈ ലേഖനത്തിൻ്റെ രചയിതാവ് ഒരു പാറ്റേണിൽ കർശനമായി പറ്റിനിൽക്കുന്നത് എല്ലായ്പ്പോഴും മികച്ച തിരഞ്ഞെടുപ്പല്ലെന്ന് ചൂണ്ടിക്കാണിക്കാൻ ആഗ്രഹിക്കുന്നു. ഉദാഹരണത്തിന്, നിയന്ത്രണങ്ങളുടെ ബൈൻഡിംഗ് പ്രോപ്പർട്ടി വഴി വിൻഡോസ് ഫോമുകൾ ഉപയോഗിച്ച് ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നതിന് MVVM ഉപയോഗിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന് സങ്കൽപ്പിക്കുക. അവതരണത്തെ ബിസിനസ്സ് ലോജിക്കിൽ നിന്നും അവയെ ബന്ധിപ്പിക്കുന്ന യുക്തിയിൽ നിന്നും വേർതിരിക്കുക എന്നതാണ് നിങ്ങളുടെ ലക്ഷ്യം. ആപ്ലിക്കേഷൻ പരിശോധിക്കാനും പിന്തുണയ്ക്കാനും എളുപ്പമുള്ളതും വിശകലന വിദഗ്ധർക്ക് മനസ്സിലാക്കാവുന്നതുമായിരിക്കണം (എല്ലാത്തിനുമുപരി, "ഒരു ഹാർഡ് ഡ്രൈവിൻ്റെ പ്രകടനം എങ്ങനെ അളക്കുന്നു" എന്ന ചോദ്യത്തിന് ശരിയായ ഒരു ഉത്തരം മാത്രമേയുള്ളൂ - ജൂൾസിൽ (അമൂർത്ത ഉദാഹരണം മോഡൽ -> കാഴ്ചകൾ)) .നിങ്ങളുടെ സമയത്തിന് വളരെ നന്ദി, വായന ആസ്വദിക്കൂ!
MVC (മോഡൽ-വ്യൂ-കൺട്രോളർ) എന്ന ആശയം വെബ് പ്രോഗ്രാമിംഗ് ലോകത്ത് പലപ്പോഴും പരാമർശിക്കപ്പെടുന്നു. കഴിഞ്ഞ വർഷങ്ങൾ. വെബ് ആപ്ലിക്കേഷൻ ഡെവലപ്‌മെൻ്റുമായി ഏതെങ്കിലും വിധത്തിൽ ബന്ധപ്പെട്ടിരിക്കുന്ന എല്ലാവരും ഒരു തരത്തിൽ അല്ലെങ്കിൽ മറ്റൊരു വിധത്തിൽ ഈ ചുരുക്കെഴുത്ത് കണ്ടിട്ടുണ്ട്. MVC ആശയം എന്താണെന്നും അത് ജനപ്രിയമായത് എന്തുകൊണ്ടാണെന്നും ഇന്ന് നമുക്ക് മനസ്സിലാകും.
പുരാതനമായ ചരിത്രം
MVC ഒരു പ്രോജക്റ്റ് പാറ്റേണല്ല, ഇത് ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ ഘടന എങ്ങനെ നിർമ്മിക്കാം, ഈ ഘടനയിലെ ഓരോ ഭാഗങ്ങളുടെയും ഉത്തരവാദിത്തങ്ങൾ, ഇടപെടൽ എന്നിവ വിവരിക്കുന്ന ഒരു ഡിസൈൻ പാറ്റേണാണ്.
ഇത് ആദ്യമായി വിവരിച്ചത് 1979 ലാണ്, തീർച്ചയായും, വ്യത്യസ്തമായ ഒരു പരിതസ്ഥിതിക്ക് വേണ്ടി. ഒരു വെബ് ആപ്ലിക്കേഷൻ എന്ന ആശയം അന്ന് ഉണ്ടായിരുന്നില്ല. ടിം ബെർണേഴ്സ് ലീ വിത്ത് പാകി വേൾഡ് വൈഡ്തൊണ്ണൂറുകളുടെ തുടക്കത്തിൽ വെബ് (WWW) പ്രത്യക്ഷപ്പെട്ടു, ലോകത്തെ എന്നെന്നേക്കുമായി മാറ്റി. ഞങ്ങൾ ഇന്ന് ഉപയോഗിക്കുന്ന ടെംപ്ലേറ്റ് വെബ് ഡെവലപ്‌മെൻ്റിനായുള്ള യഥാർത്ഥ ടെംപ്ലേറ്റിൻ്റെ ഒരു അഡാപ്റ്റേഷനാണ്.
വെബ് ആപ്ലിക്കേഷനുകളിൽ ഈ ഘടനയുടെ വന്യമായ ജനപ്രീതിക്ക് കാരണം രണ്ട് വികസന പരിതസ്ഥിതികളിൽ ഉൾപ്പെടുത്തിയതാണ്: അത് വളരെ ജനപ്രിയമായി: സ്ട്രട്ട്സ് ആൻഡ് റൂബി ഓൺ റെയിൽസ്. ഈ രണ്ട് വികസന പരിതസ്ഥിതികളും പിന്നീട് സൃഷ്ടിക്കപ്പെട്ട നൂറുകണക്കിന് വികസന പരിതസ്ഥിതികൾക്ക് വഴിയൊരുക്കി.
വെബ് ആപ്ലിക്കേഷനുകൾക്കുള്ള എംവിസി
MVC ഡിസൈൻ പാറ്റേണിൻ്റെ പിന്നിലെ ആശയം വളരെ ലളിതമാണ്: ഞങ്ങളുടെ ആപ്ലിക്കേഷനുകളിലെ വിവിധ പ്രവർത്തനങ്ങളുടെ ഉത്തരവാദിത്തങ്ങൾ ഞങ്ങൾ വ്യക്തമായി വേർതിരിക്കേണ്ടതുണ്ട്:
ആപ്ലിക്കേഷൻ മൂന്ന് പ്രധാന ഘടകങ്ങളായി തിരിച്ചിരിക്കുന്നു, അവയിൽ ഓരോന്നിനും ഉത്തരവാദിത്തമുണ്ട് വിവിധ ജോലികൾ. ഒരു ഉദാഹരണം ഉപയോഗിച്ച് ഘടകങ്ങൾ വിശദമായി നോക്കാം.
കണ്ട്രോളർ
കണ്ട്രോളർഉപയോക്തൃ അഭ്യർത്ഥനകൾ നിയന്ത്രിക്കുന്നു (ഇൻ്റർഫേസ് ഘടകങ്ങളിൽ ഉപയോക്താവ് ക്ലിക്കുചെയ്യുമ്പോൾ HTTP GET അല്ലെങ്കിൽ POST അഭ്യർത്ഥനകളായി ലഭിക്കുന്നു വിവിധ പ്രവർത്തനങ്ങൾ). ഉപയോക്താവ് വ്യക്തമാക്കിയ പ്രവർത്തനങ്ങൾ നടത്താൻ ആവശ്യമായ വിഭവങ്ങളുടെയും വസ്തുക്കളുടെയും പ്രവർത്തനത്തെ വിളിക്കുകയും ഏകോപിപ്പിക്കുകയും ചെയ്യുക എന്നതാണ് ഇതിൻ്റെ പ്രധാന പ്രവർത്തനം. സാധാരണഗതിയിൽ കൺട്രോളർ ടാസ്‌ക്കിന് അനുയോജ്യമായ മാതൃകയെ വിളിക്കുകയും തിരഞ്ഞെടുക്കുകയും ചെയ്യുന്നു അനുയോജ്യമായ രൂപം.
മോഡൽ
മോഡൽ- ആപ്ലിക്കേഷൻ മാനേജിംഗ് എന്ന ആശയത്തെ പ്രതിനിധീകരിക്കുന്ന ഡാറ്റയുമായി പ്രവർത്തിക്കാൻ ഉപയോഗിക്കുന്ന ഡാറ്റയും നിയമങ്ങളുമാണ് ഇവ. ഏതൊരു ആപ്ലിക്കേഷനിലും, മുഴുവൻ ഘടനയും ഒരു പ്രത്യേക രീതിയിൽ പ്രോസസ്സ് ചെയ്യുന്ന ഡാറ്റയായി രൂപപ്പെടുത്തിയിരിക്കുന്നു. ഒരു ആപ്ലിക്കേഷൻ്റെ ഉപയോക്താവ് എന്താണ് - ഒരു സന്ദേശമോ പുസ്തകമോ? നിയമങ്ങൾക്കനുസൃതമായി പ്രോസസ്സ് ചെയ്യേണ്ട ഡാറ്റ മാത്രം (തീയതി ഭാവിയിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ കഴിയില്ല, ഇമെയിൽ ഒരു നിശ്ചിത ഫോർമാറ്റിലായിരിക്കണം, പേര് X പ്രതീകങ്ങളേക്കാൾ ദൈർഘ്യമേറിയതായിരിക്കരുത്, മുതലായവ).
ഉപയോക്താവ് അഭ്യർത്ഥിച്ച ഡാറ്റയുടെ (സന്ദേശം, പുസ്തക പേജ്, ഫോട്ടോ ആൽബം മുതലായവ) ഒരു പ്രാതിനിധ്യം മോഡൽ കൺട്രോളറിന് നൽകുന്നു. ഡാറ്റ മോഡൽ ഉപയോക്താവിന് എങ്ങനെ അവതരിപ്പിക്കാൻ താൽപ്പര്യപ്പെട്ടാലും സമാനമായിരിക്കും. അതിനാൽ ഞങ്ങൾ ഏതെങ്കിലും തിരഞ്ഞെടുക്കുന്നു ആക്സസ് ചെയ്യാവുന്ന കാഴ്ചഡാറ്റ പ്രദർശിപ്പിക്കാൻ.
ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ യുക്തിയുടെ ഏറ്റവും പ്രധാനപ്പെട്ട ഭാഗം, ഞങ്ങൾ കൈകാര്യം ചെയ്യുന്ന പ്രശ്നം പരിഹരിക്കുന്ന യുക്തി (ഫോറം, സ്റ്റോർ, ബാങ്ക് മുതലായവ) മോഡലിൽ അടങ്ങിയിരിക്കുന്നു. കൺട്രോളറിൽ അടിസ്ഥാനപരമായി ആപ്ലിക്കേഷൻ്റെ ഓർഗനൈസേഷണൽ ലോജിക് അടങ്ങിയിരിക്കുന്നു (ഹൗസ് കീപ്പിംഗ് പോലെ).
കാണുക
കാണുകനൽകുന്നു വിവിധ വഴികൾമോഡലിൽ നിന്ന് ലഭിച്ച ഡാറ്റയുടെ പ്രാതിനിധ്യം. ഡാറ്റ നിറച്ച ഒരു ടെംപ്ലേറ്റ് ആകാം. വ്യത്യസ്ത തരങ്ങൾ ഉണ്ടാകാം, കൺട്രോളർ ഏതാണ് അനുയോജ്യമെന്ന് തിരഞ്ഞെടുക്കുന്നു ഏറ്റവും മികച്ച മാർഗ്ഗംനിലവിലെ സാഹചര്യത്തിന്.
ഒരു വെബ് ആപ്ലിക്കേഷനിൽ സാധാരണയായി ഒരു കൂട്ടം കൺട്രോളറുകൾ, മോഡലുകൾ, കാഴ്ചകൾ എന്നിവ അടങ്ങിയിരിക്കുന്നു. എല്ലാ അഭ്യർത്ഥനകളും സ്വീകരിക്കുകയും സാഹചര്യത്തിനനുസരിച്ച് പ്രവർത്തനങ്ങൾ നടത്താൻ മറ്റ് കൺട്രോളറുകളെ വിളിക്കുകയും ചെയ്യുന്ന ഒരു പ്രധാന കൺട്രോളറായി കൺട്രോളറിനെ രൂപകൽപ്പന ചെയ്യാൻ കഴിയും.
നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം
നമുക്ക് ഒരു ഓൺലൈൻ ബുക്ക് സ്റ്റോർ വികസിപ്പിക്കേണ്ടതുണ്ടെന്ന് പറയാം. ഉപയോക്താവിന് നിർവഹിക്കാൻ കഴിയും ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ: പുസ്തകങ്ങൾ കാണുക, രജിസ്റ്റർ ചെയ്യുക, വാങ്ങുക, നിലവിലെ ഓർഡറിലേക്ക് ഇനങ്ങൾ ചേർക്കുക, പുസ്തകങ്ങൾ സൃഷ്ടിക്കുക അല്ലെങ്കിൽ ഇല്ലാതാക്കുക (അദ്ദേഹം ഒരു അഡ്മിനിസ്ട്രേറ്ററാണെങ്കിൽ). ഒരു ഉപയോക്താവ് ഒരു വിഭാഗത്തിൽ ക്ലിക്ക് ചെയ്യുമ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് നോക്കാം ഫാൻ്റസിഞങ്ങളുടെ സ്റ്റോറിൽ ലഭ്യമായ പുസ്തകങ്ങളുടെ തലക്കെട്ടുകൾ കാണുന്നതിന്.
പുസ്‌തകങ്ങളുമായി ബന്ധപ്പെട്ട എല്ലാ പ്രവർത്തനങ്ങളും കൈകാര്യം ചെയ്യാൻ ഞങ്ങൾക്ക് ഒരു പ്രത്യേക കൺട്രോളർ ഉണ്ട് (കാണുക, എഡിറ്റ് ചെയ്യുക, സൃഷ്ടിക്കുക മുതലായവ). വിളിക്കാം books_controller.phpഞങ്ങളുടെ ഉദാഹരണത്തിൽ. അതുപോലെ ഒരു മാതൃകയും വേണം book_model.php, ഇത് ഒരു സ്റ്റോർ ഇനവുമായി ബന്ധപ്പെട്ട ഡാറ്റയും ലോജിക്കും പ്രോസസ്സ് ചെയ്യുന്നു. ഉപസംഹാരമായി, ഒരു പുസ്തക ലിസ്റ്റ്, എഡിറ്റ് പേജ് മുതലായവ പോലുള്ള ഡാറ്റയെ പ്രതിനിധീകരിക്കുന്നതിന് ഞങ്ങൾക്ക് നിരവധി കാഴ്ചകൾ ആവശ്യമാണ്.
ഒരു വിഷയത്തെക്കുറിച്ചുള്ള പുസ്തകങ്ങളുടെ ലിസ്റ്റ് കാണാനുള്ള ഒരു ഉപയോക്താവിൻ്റെ അഭ്യർത്ഥന എങ്ങനെ പ്രോസസ്സ് ചെയ്യപ്പെടുന്നുവെന്ന് ഇനിപ്പറയുന്ന ചിത്രം കാണിക്കുന്നു ഫാൻ്റസി:
കൺട്രോളർ (books_controller.php) ഉപയോക്തൃ അഭ്യർത്ഥന സ്വീകരിക്കുന്നു ( HTTP അഭ്യർത്ഥനനേടുക അല്ലെങ്കിൽ പോസ്റ്റ് ചെയ്യുക). നമുക്ക് ഒരു സെൻട്രൽ കൺട്രോളർ സൃഷ്ടിക്കാൻ കഴിയും, ഉദാഹരണത്തിന് index.php, അത് അഭ്യർത്ഥന സ്വീകരിക്കുകയും book_controller.php എന്ന് വിളിക്കുകയും ചെയ്യുന്നു.
കൺട്രോളർ അഭ്യർത്ഥനയും പാരാമീറ്ററുകളും പരിശോധിച്ച ശേഷം മോഡലിനെ വിളിക്കുന്നു(book_model.php), ചോദിക്കുന്നുവിഷയത്തിൽ ലഭ്യമായ പുസ്തകങ്ങളുടെ ഒരു ലിസ്റ്റ് അവളുടെ പക്കലുണ്ട് ഫാൻ്റസി .
മോഡൽ ഡാറ്റാബേസിൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കുന്നു (അല്ലെങ്കിൽ വിവരങ്ങൾ സംഭരിക്കുന്ന മറ്റൊരു ഉറവിടം), ഫിൽട്ടറുകളും ആവശ്യമായ ലോജിക്കും പ്രയോഗിക്കുന്നു, തുടർന്ന് പുസ്തകങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രതിനിധീകരിക്കുന്ന ഡാറ്റ നൽകുന്നു.
ഉപയോക്താവിന് ഡാറ്റ അവതരിപ്പിക്കുന്നതിന് കൺട്രോളർ ഉചിതമായ കാഴ്ച ഉപയോഗിക്കുന്നു. അഭ്യർത്ഥന വന്നാൽ മൊബൈൽ ഫോൺ, മൊബൈൽ ഫോൺ കാഴ്ച ഉപയോഗിക്കുന്നു; ഉപയോക്താവ് ഒരു പ്രത്യേക ഇൻ്റർഫേസ് ഡിസൈൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, അതിനനുസരിച്ചുള്ള കാഴ്ച തിരഞ്ഞെടുത്തു, തുടങ്ങിയവ.
എന്താണ് ഗുണങ്ങൾ?
MVC ആശയം ഉപയോഗിക്കുന്നതിലൂടെ നമുക്ക് ലഭിക്കുന്ന ഏറ്റവും വ്യക്തമായ പ്രയോജനം അവതരണ ലോജിക്കും (ഉപയോക്തൃ ഇൻ്റർഫേസ്) ആപ്ലിക്കേഷൻ ലോജിക്കും വ്യക്തമായി വേർതിരിക്കുന്നതാണ്.
ഉപയോഗിക്കുന്ന വിവിധ തരം ഉപയോക്താക്കളെ പിന്തുണയ്ക്കുന്നു വിവിധ തരംഉപകരണങ്ങൾ ആണ് സാധാരണ പ്രശ്നംനമ്മുടെ ദിവസങ്ങൾ. അഭ്യർത്ഥന വന്നാൽ നൽകിയിരിക്കുന്ന ഇൻ്റർഫേസ് വ്യത്യസ്തമായിരിക്കണം പെഴ്സണൽ കമ്പ്യൂട്ടർഅല്ലെങ്കിൽ ഒരു മൊബൈൽ ഫോണിൽ നിന്ന്. മോഡൽ അതേ ഡാറ്റ നൽകുന്നു, കൺട്രോളർ തിരഞ്ഞെടുക്കുന്നു എന്നതാണ് വ്യത്യാസം പല തരംഡാറ്റ ഔട്ട്പുട്ട് ചെയ്യാൻ.
ആപ്ലിക്കേഷൻ ലോജിക്കിൽ നിന്ന് കാഴ്‌ചകളെ വേർതിരിക്കുന്നതിന് പുറമേ, എംവിസി ആശയം സങ്കീർണ്ണതയെ ഗണ്യമായി കുറയ്ക്കുന്നു വലിയ ആപ്ലിക്കേഷനുകൾ. കോഡ് കൂടുതൽ ഘടനാപരമായതായി മാറുന്നു, അതിനാൽ പിന്തുണയ്ക്കുന്നതും പരിശോധിക്കുന്നതും എളുപ്പമാക്കുന്നു പുനരുപയോഗംതീരുമാനങ്ങൾ.
എന്തുകൊണ്ടാണ് തൊഴിൽ അന്തരീക്ഷം ഉപയോഗിക്കുന്നത്?
നിങ്ങൾ വർക്ക് ബെഞ്ച് ഉപയോഗിക്കുമ്പോൾ, അടിസ്ഥാന ഘടന MVC ഇതിനകം തയ്യാറാക്കിയിട്ടുണ്ട്, MVC പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നതിന് ഉചിതമായ ഡയറക്ടറികളിൽ നിങ്ങളുടെ ഫയലുകൾ സ്ഥാപിച്ച് ഘടന വികസിപ്പിക്കുക മാത്രമാണ് നിങ്ങൾ ചെയ്യേണ്ടത്. കൂടാതെ, ഇതിനകം എഴുതിയതും നന്നായി പരീക്ഷിച്ചതുമായ ഒരു കൂട്ടം ഫീച്ചറുകൾ നിങ്ങൾക്കുണ്ടാകും.
നമുക്ക് കേക്ക് പിഎച്ച്പി ഉദാഹരണമായി എടുക്കാം ജോലി സ്ഥലംഎം.വി.സി. ഇൻസ്റ്റാളേഷന് ശേഷം നിങ്ങൾക്ക് മൂന്ന് പ്രധാന ഡയറക്ടറികൾ ഉണ്ടാകും:
- കേക്ക്/
- വെണ്ടർമാർ/
ഫോൾഡർ അപ്ലിക്കേഷൻനിങ്ങളുടെ ഫയലുകൾ എവിടെയാണ് സ്ഥിതി ചെയ്യുന്നത്. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ ഭാഗം വികസിപ്പിക്കാനുള്ള സ്ഥലമാണിത്.
ഫോൾഡറിൽ കേക്ക് cakePHP ഫയലുകൾ (വർക്ക് ബെഞ്ച് പ്രവർത്തനം) ഹോസ്റ്റ് ചെയ്തിരിക്കുന്നു.
ഫോൾഡർ കച്ചവടക്കാർലൈബ്രറികൾ സൂക്ഷിക്കാൻ ഉപയോഗിച്ചു PHP മൂന്നാം കക്ഷിഡെവലപ്പർമാർ.
താങ്കളുടെ ജോലി സ്ഥലം(ആപ്പ് ഡയറക്‌ടറി) ഇനിപ്പറയുന്ന ഘടനയുണ്ട്:
- ആപ്പ്/
- കോൺഫിഗറേഷൻ/
- കൺട്രോളറുകൾ/
- പ്രാദേശികം/
- മോഡലുകൾ/
- പ്ലഗിനുകൾ/
- പരിശോധനകൾ/
- വെണ്ടർമാർ/
- കാഴ്ചകൾ/
- വെബ്‌റൂട്ട്/
നിങ്ങളുടെ കൺട്രോളറുകൾ ഒരു ഡയറക്ടറിയിൽ സ്ഥാപിക്കേണ്ടതുണ്ട് കൺട്രോളറുകൾ, ഡയറക്ടറിയിലെ മോഡലുകൾ മോഡലുകൾഡയറക്ടറിയിലെ തരങ്ങളും കാഴ്ചകൾ!
നിങ്ങൾ വർക്ക് ബെഞ്ച് ഉപയോഗിക്കാൻ തുടങ്ങിക്കഴിഞ്ഞാൽ, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ സൃഷ്‌ടിക്കേണ്ടതോ പരിഷ്‌ക്കരിക്കേണ്ടതോ ആയ എല്ലാ ഭാഗങ്ങളും എവിടെയാണെന്ന് ഉടനടി വ്യക്തമാകും. ഈ ഓർഗനൈസേഷൻ തന്നെ ഒരു ആപ്ലിക്കേഷൻ വികസിപ്പിക്കുന്നതിനും പരിപാലിക്കുന്നതിനുമുള്ള പ്രക്രിയയെ വളരെ ലളിതമാക്കുന്നു.
ഞങ്ങളുടെ ഉദാഹരണത്തിനായി വർക്ക് ബെഞ്ച് ഉപയോഗിക്കുന്നു
കാരണം ഈ പാഠംകേക്ക് പിഎച്ച്പി ഉപയോഗിച്ച് ഒരു ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കുന്ന പ്രക്രിയ കാണിക്കാൻ ഉദ്ദേശിച്ചുള്ളതല്ല, എംവിസി വർക്ക് ബെഞ്ച് ഉപയോഗിക്കുന്നതിൻ്റെ നേട്ടങ്ങളെക്കുറിച്ചുള്ള അഭിപ്രായങ്ങൾക്കൊപ്പം മോഡൽ, കൺട്രോളർ, കാഴ്ച എന്നിവയുടെ കോഡ് മാത്രമേ ഞങ്ങൾ കാണിക്കൂ. കോഡ് മനഃപൂർവ്വം ലളിതമാക്കിയതും യഥാർത്ഥ ആപ്ലിക്കേഷനിൽ ഉപയോഗിക്കുന്നതിന് അനുയോജ്യമല്ലാത്തതുമാണ്.
ഓർക്കുക, ഞങ്ങൾ ഒരു പുസ്തകശാലയും കാണാൻ ആഗ്രഹിക്കുന്ന ഒരു കൗതുകമുള്ള ഉപയോക്താവും നോക്കുകയായിരുന്നു മുഴുവൻ പട്ടികവിഷയത്തെക്കുറിച്ചുള്ള പുസ്തകങ്ങൾ ഫാൻ്റസി. കൺട്രോളർ ഉപയോക്താവിൻ്റെ അഭ്യർത്ഥന സ്വീകരിക്കുകയും ആവശ്യമായ പ്രവർത്തനങ്ങൾ ഏകോപിപ്പിക്കുകയും ചെയ്തു.
അതിനാൽ, ഉപയോക്താവ് ബട്ടണിൽ ക്ലിക്കുചെയ്യുമ്പോൾ, ബ്രൗസർ നൽകിയിരിക്കുന്ന url അഭ്യർത്ഥിക്കുന്നു:
www.ourstore.com/books/list/fantasy
ഒരു പാറ്റേൺ ഉപയോഗിച്ച് CakePHP URL ഫോർമാറ്റ് ചെയ്യുന്നു /കൺട്രോളർ/ആക്ഷൻ/പാരം1/പാരം2, എവിടെ നടപടികൺട്രോളർ വിളിക്കുന്ന ഒരു ഫംഗ്ഷനാണ്. പഴയതിൽ ക്ലാസിക് രൂപം url ഇതുപോലെ കാണപ്പെടും:
www.ourstore.com/books_controller.php?action=list&category=fantasy
കണ്ട്രോളർ
കേക്ക് പിഎച്ച്പി പ്രവർത്തന അന്തരീക്ഷത്തിൽ, ഞങ്ങളുടെ കൺട്രോളർ ഇതുപോലെ കാണപ്പെടും:
ക്ലാസ് ബുക്ക്സ് കൺട്രോളർ ആപ്പ് കൺട്രോളർ വിപുലീകരിക്കുന്നു (
ഫംഗ്ഷൻ ലിസ്റ്റ്($വിഭാഗം) (
$this->set("പുസ്തകങ്ങൾ", $this->Book->findAllByCategory($category));
ഫംഗ്ഷൻ ആഡ്() (... ...)
ഫംഗ്ഷൻ ഇല്ലാതാക്കുക() (... ...)
... ... } ?>
ലളിതം, അല്ലേ? ഈ കൺട്രോളർആയി സംരക്ഷിക്കപ്പെടും books_controller.phpഎന്നിവയിൽ പോസ്റ്റ് ചെയ്തു /ആപ്പ്/കൺട്രോളറുകൾ. ഞങ്ങളുടെ ഉദാഹരണത്തിനായി പ്രവർത്തനങ്ങൾ നടത്തുന്ന പ്രവർത്തനങ്ങളുടെ ഒരു ലിസ്റ്റ് ഇതിൽ അടങ്ങിയിരിക്കുന്നു, അതുപോലെ തന്നെ പുസ്തകവുമായി ബന്ധപ്പെട്ട പ്രവർത്തനങ്ങൾ നടത്തുന്നതിനുള്ള മറ്റ് ഫംഗ്ഷനുകളും (ചേർക്കുക പുതിയ പുസ്തകം, ഒരു പുസ്തകം ഇല്ലാതാക്കുക തുടങ്ങിയവ).
തൊഴിൽ അന്തരീക്ഷം നമുക്ക് പലതും നൽകുന്നു റെഡിമെയ്ഡ് പരിഹാരങ്ങൾകൂടാതെ നിങ്ങൾ പുസ്തകങ്ങളുടെ ഒരു ലിസ്റ്റ് സൃഷ്ടിക്കേണ്ടതുണ്ട്. കൺട്രോളറിൻ്റെ അടിസ്ഥാന പ്രവർത്തനം ഇതിനകം നിർവചിക്കുന്ന ഒരു അടിസ്ഥാന ക്ലാസ് ഉണ്ട്, അതിനാൽ ഈ ക്ലാസിൻ്റെ ഗുണങ്ങളും പ്രവർത്തനങ്ങളും നിങ്ങൾക്ക് അവകാശമാക്കേണ്ടതുണ്ട് ( AppControllerഅവകാശിയാണ് കണ്ട്രോളർ).
പ്രവർത്തന ലിസ്റ്റിൽ നിങ്ങൾ ചെയ്യേണ്ടത്, ഡാറ്റ ലഭിക്കാൻ മോഡലിനെ വിളിക്കുക, തുടർന്ന് അത് ഉപയോക്താവിന് അവതരിപ്പിക്കാൻ ഒരു കാഴ്ച തിരഞ്ഞെടുക്കുക. ഇത് എങ്ങനെ ചെയ്യുന്നുവെന്ന് ഇതാ.
ഈ->പുസ്തകം- ഇതാണ് ഞങ്ങളുടെ മോഡലും കോഡിൻ്റെ ഭാഗവും:
$this->Book->findAllByCategory($category)
തിരഞ്ഞെടുത്ത വിഷയത്തെക്കുറിച്ചുള്ള പുസ്തകങ്ങളുടെ ഒരു ലിസ്റ്റ് തിരികെ നൽകാൻ മോഡലിനോട് പറയുന്നു (മോഡൽ പിന്നീട് നോക്കാം).
രീതി സെറ്റ്ഇൻ ലൈൻ:
$this->set("പുസ്തകങ്ങൾ", $this->Book->findAllByCategory($category));
കൺട്രോളർ കാഴ്ചയിലേക്ക് ഡാറ്റ കൈമാറുന്നു. വേരിയബിൾ പുസ്തകങ്ങൾമോഡൽ നൽകിയ ഡാറ്റ സ്വീകരിക്കുകയും കാഴ്ചയ്ക്ക് അത് ലഭ്യമാക്കുകയും ചെയ്യുന്നു.
ഇപ്പോൾ അവശേഷിക്കുന്നത് കാഴ്ച പ്രദർശിപ്പിക്കുക മാത്രമാണ്, എന്നാൽ ഞങ്ങൾ സ്ഥിരസ്ഥിതി കാഴ്ച ഉപയോഗിക്കുകയാണെങ്കിൽ ഈ പ്രവർത്തനം കേക്ക് പിഎച്ച്പിയിൽ സ്വയമേവ ചെയ്യപ്പെടും. ഞങ്ങൾക്ക് മറ്റൊരു തരം ഉപയോഗിക്കണമെങ്കിൽ, ഞങ്ങൾ രീതിയെ വ്യക്തമായി വിളിക്കണം റെൻഡർ ചെയ്യുക.
മോഡൽ
മോഡൽ ഇതിലും ലളിതമാണ്:
ക്ലാസ് ബുക്ക് ആപ്പ് മോഡൽ വിപുലീകരിക്കുന്നു (
എന്തുകൊണ്ടാണ് ഇത് ശൂന്യമായിരിക്കുന്നത്? കാരണം അവളാണ് അനന്തരാവകാശി അടിസ്ഥാന ക്ലാസ്, അത് ആവശ്യമായ പ്രവർത്തനം നൽകുന്നു, വർക്ക് ബെഞ്ച് മറ്റെല്ലാ ജോലികളും സ്വയമേവ കൈകാര്യം ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഞങ്ങൾ കേക്ക്പിഎച്ച്പിയുടെ നാമകരണ കൺവെൻഷൻ ഉപയോഗിക്കേണ്ടതുണ്ട്. ഉദാഹരണത്തിന്, കേക്ക്PHP ആ പേരിനെ അടിസ്ഥാനമാക്കി അറിയാം ഈ മാതൃകഉപയോഗിച്ചത് ബുക്ക്സ് കൺട്രോളർ, കൂടാതെ അതിന് പുസ്തകങ്ങൾ എന്ന് പേരുള്ള ഒരു ഡാറ്റാബേസ് പട്ടികയിലേക്ക് ആക്സസ് ഉണ്ടെന്നും.
ഈ നിർവ്വചനം ഉപയോഗിച്ച്, ഡാറ്റാബേസിൽ മാത്രം ഡാറ്റ വായിക്കാനോ ഇല്ലാതാക്കാനോ സംഭരിക്കാനോ കഴിയുന്ന ഒരു മോഡൽ ഞങ്ങൾക്കുണ്ടാകും.
കോഡ് ഇതായി സേവ് ചെയ്യുക book.phpഫോൾഡറിൽ /ആപ്പ്/മോഡലുകൾ.
കാണുക
നമ്മൾ ഇപ്പോൾ ചെയ്യേണ്ടത് ഒരു കാഴ്ച സൃഷ്ടിക്കുക എന്നതാണ് (ബൈ ഇത്രയെങ്കിലും, ഒന്ന്) പ്രവർത്തനങ്ങളുടെ ഒരു ലിസ്റ്റിനായി. കാഴ്ചയിൽ HTML കോഡും മോഡൽ നൽകുന്ന പുസ്തകങ്ങളുടെ നിരയിലൂടെ ലൂപ്പ് ചെയ്യാൻ PHP കോഡിൻ്റെ കുറച്ച് (കഴിയുന്നത്ര) വരികളും ഉണ്ടായിരിക്കും.
| പേര് | രചയിതാവ് | വില |
|---|---|---|
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, കാഴ്ച ഒരു പൂർണ്ണ പേജ് സൃഷ്‌ടിക്കുന്നില്ല, പക്ഷേ HTML ൻ്റെ ഒരു ഭാഗം മാത്രമാണ് (ഈ കേസിൽ ഒരു പട്ടിക). കാരണം ഒരു പേജ് ടെംപ്ലേറ്റ് നിർവചിക്കുന്നതിനുള്ള മറ്റൊരു മാർഗം CakePHP നൽകുന്നു, കൂടാതെ കാഴ്ച ആ ടെംപ്ലേറ്റിലേക്ക് തിരുകുകയും ചെയ്യുന്നു. വർക്ക് ബെഞ്ച് നമുക്ക് നിർവഹിക്കാൻ ചില സഹായ വസ്തുക്കളും നൽകുന്നു പൊതുവായ ജോലികൾഭാഗങ്ങൾ സൃഷ്ടിക്കുന്ന സമയത്ത് HTML പേജുകൾ(ഫോമുകൾ, ലിങ്കുകൾ, അജാക്സ് അല്ലെങ്കിൽ ജാവാസ്ക്രിപ്റ്റ് ചേർക്കുന്നു).
കാഴ്ച ഇതായി സംരക്ഷിക്കുക list.ctp(ലിസ്റ്റ് എന്നത് പ്രവർത്തന നാമമാണ്, ctp എന്നാൽ CakePHP ടെംപ്ലേറ്റ്) ഫോൾഡറിൽ /ആപ്പ്/കാഴ്ചകൾ/പുസ്തകങ്ങൾ(കാരണം ഇത് ഒരു കൺട്രോളർ പ്രവർത്തനത്തിനുള്ള കാഴ്ചയാണ്).
കേക്ക് പിഎച്ച്പി വർക്ക് ബെഞ്ച് ഉപയോഗിച്ച് മൂന്ന് ഘടകങ്ങളും എക്സിക്യൂട്ട് ചെയ്യുന്നത് ഇങ്ങനെയാണ്!
