ಟೆಂಪ್ಲೇಟ್ ಪ್ರಕಾರ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು MVC ವಿನ್ಯಾಸ(ಮಾದರಿ-ವೀಕ್ಷಣೆ-ನಿಯಂತ್ರಕ) ಜಾವಾಗೆ ವಿಶಿಷ್ಟವಾಗಿದೆ ಮತ್ತು ಡ್ರಾಯಿಡ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಅನ್ವಯಿಸಿದಾಗ, ಗ್ರಹಿಸಲಾಗದ ಮತ್ತು ಅನಗತ್ಯವಾಗಿ ತೋರುತ್ತದೆ. ಎಲ್ಲವನ್ನೂ ಏಕೆ ಸಂಕೀರ್ಣಗೊಳಿಸಬೇಕು? MVC ಸುಂದರವಾದ ಆದರೆ ಗ್ರಹಿಸಲಾಗದ ಪದಗಳ (ಪರಿಕಲ್ಪನೆ, ಮಾದರಿ, ವ್ಯವಹಾರ ತರ್ಕ, ಮಾದರಿ) ಮತ್ತು ಅದನ್ನು ಪರಿಗಣಿಸುವಾಗ ಜಾವಾದ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಕೀರ್ಣವಾದ ಪ್ರದರ್ಶನಗಳ ಬಳಕೆಯಿಂದಾಗಿ ಸಂಕೀರ್ಣತೆ ಮತ್ತು "ಮ್ಯಾಜಿಕ್" ನ ಸೆಳವು ಪಡೆದುಕೊಂಡಿದೆ. ಎಲ್ಲವೂ ಹೆಚ್ಚು ಸರಳವಾಗಿದೆ: MVC ಉತ್ಪಾದಿಸುವ ವಿನ್ಯಾಸ ಮಾದರಿಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಹೆಚ್ಚುವರಿಕೋಡ್ ಹಂಚಿಕೆವಸ್ತು-ಆಧಾರಿತದಲ್ಲಿ ಪರಿಸರ.

MVC ಮಾದರಿಯ ಕೇಂದ್ರ ಅಂಶವು ನಿಯಂತ್ರಕವಾಗಿದೆ - ಸಾಮಾನ್ಯ ಅಪ್ಲಿಕೇಶನ್ಡ್ರಾಯಿಡ್‌ಸ್ಕ್ರಿಪ್ಟ್, ಇದರಿಂದ ದೃಶ್ಯ ಮಾರ್ಕ್‌ಅಪ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಕೋಡ್ ಮತ್ತು ಬಾಹ್ಯ ವಿನ್ಯಾಸವಿಜೆಟ್‌ಗಳು, ಹಾಗೆಯೇ ಡೇಟಾ ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ರವೇಶಿಸುವ ವಿಧಾನಗಳು. ಡೇಟಾದ ಮೂಲಕ ನಾವು ಅರೇಗಳು, ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೇಟಾಬೇಸ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಮಾಹಿತಿಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಒಗ್ಗಿಕೊಂಡಿರುತ್ತೇವೆ. ಆದರೆ MVC ಪರಿಕಲ್ಪನೆಯಲ್ಲಿ, ಡೇಟಾವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲಾಗುತ್ತದೆ ವಿಶಾಲ ಅರ್ಥದಲ್ಲಿಪದಗಳು ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅಲ್ಲದ ಎಲ್ಲವೂ:

• ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೇಟಾಬೇಸ್‌ಗಳಿಂದ ಬಾಹ್ಯ ಡೇಟಾ - ಮೆಟಾಡೇಟಾ, ಪಠ್ಯ, ಗ್ರಾಫಿಕ್ಸ್, ಧ್ವನಿಗಳು, ಸಂಗೀತ, ಇತ್ಯಾದಿ.
• ಆಂತರಿಕ ಅಪ್ಲಿಕೇಶನ್ ಡೇಟಾ - ಬಟನ್‌ಗಳು ಮತ್ತು ಇತರ ನಿಯಂತ್ರಣಗಳ ಮೇಲೆ ಲೇಬಲ್‌ಗಳೊಂದಿಗೆ ಸಾಲುಗಳು, ಪಠ್ಯದಲ್ಲಿ ಸಂವಾದ ಪೆಟ್ಟಿಗೆಗಳು, ಶೈಲಿಗಳ ವಿವರಣೆ, ಸ್ಥಿರಾಂಕಗಳು, ಸಾಫ್ಟ್‌ವೇರ್ ರಚಿಸಿದ ಗ್ರಾಫಿಕ್ಸ್, ಇತ್ಯಾದಿ.

ಬಳಕೆದಾರರ ದೃಷ್ಟಿಕೋನದಿಂದ, MVC ಅನ್ನು ಬಳಸುವಾಗ ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗಿನ ಅವನ ಅನುಭವವು ಬದಲಾಗುವುದಿಲ್ಲ: ಅವನು ಬಟನ್‌ಗಳ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡುತ್ತಾನೆ, ಡೇಟಾವನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತಾನೆ ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಬದಲಾವಣೆಗಳು ಚಿಂತಿಸಬಹುದು ಸೌಲಭ್ಯಗಳುಈ ಕೆಲಸ. ಮತ್ತು ಅಭಿವೃದ್ಧಿಯ ಭಾಗದಲ್ಲಿ, ಬದಲಾವಣೆಗಳು ಗಮನಾರ್ಹವಾಗಿವೆ: MVC ಪರಿಕಲ್ಪನೆಯಲ್ಲಿ ಡೇಟಾ ಮತ್ತು ಅದರ ಪ್ರದರ್ಶನದ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯು ಸಂಭವಿಸುತ್ತದೆ. ನಿಯಂತ್ರಕದ ಮೂಲಕ ಮತ್ತು ಅದರ ನಿಯಂತ್ರಣದಲ್ಲಿ.

ಸಿಂಗಲ್-ಫೈಲ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ MVC ಅನ್ನು ಬಳಸುವ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ಮೊದಲು ನೋಡೋಣ.

MVC ಮಾದರಿಯ ಏಕ-ಕಡತದ ಅನುಷ್ಠಾನ

ಸರಳವಾದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ.

ಕಾರ್ಯ OnStart())( var _lay = app.CreateLayout("linear", "VCenter,FillXY"); var _btnShowVersion = app.CreateButton("ಆವೃತ್ತಿಯನ್ನು ತೋರಿಸು", 0.3, 0.1); _btnShowVersion.SetBackColor7(9"7666) _btnShowVersion.SetMargins(0, 0.05, 0, 0); _btnShowVersion.SetOnTouch())

ಮೊದಲ ನೋಟದಲ್ಲಿ, ಎಲ್ಲವೂ ಚೆನ್ನಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ, ಆದರೆ ನೀವು ಬದಲಾಯಿಸಬೇಕಾಗಿದೆ ಎಂದು ಭಾವಿಸೋಣ ಬಣ್ಣದ ಯೋಜನೆಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಹಲವಾರು ಭಾಷೆಗಳಲ್ಲಿ ಪಠ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಿ. ಇದು ತೊಡಕುಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ತೋರಿಸಿರುವ ಉದಾಹರಣೆಯಲ್ಲಿನ ಎಲ್ಲಾ ಡೇಟಾವು ಸ್ಥಿರ ಮೌಲ್ಯಗಳು (ಅಕ್ಷರಶಃ). ಇದು ಕೋಡ್‌ನ ನಮ್ಯತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದರ ಡೀಬಗ್ ಮಾಡುವಿಕೆ ಮತ್ತು ಬೆಂಬಲವನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸುತ್ತದೆ.

ಮತ್ತೊಂದು ನ್ಯೂನತೆಯೆಂದರೆ ಡೇಟಾ - ಬಟನ್‌ನಲ್ಲಿನ ಲೇಬಲ್‌ಗಳು, ಮಾರ್ಕ್‌ಅಪ್ - ವಿಜೆಟ್‌ಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವ ವಿಧಾನಗಳು ಮತ್ತು ಕ್ರಿಯೆ - ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ಬಟನ್‌ನಲ್ಲಿ ಲೇಬಲ್ ಅನ್ನು ಬದಲಾಯಿಸುವ ಕೋಡ್‌ನ ಬ್ಲಾಕ್ ಒಂದು ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಮತ್ತು ಒಂದು ಫೈಲ್‌ನಲ್ಲಿದೆ. ಅಂದರೆ, ಲೇಬಲ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ನೀವು ಈ ಫೈಲ್ ಅನ್ನು ತೆರೆಯಬೇಕು ಮತ್ತು ಸಂಪೂರ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ಪಡೆಯಬೇಕು. ಇದು ಕಾರಿನ ಟೈರ್ ಅನ್ನು ಬದಲಾಯಿಸುವಂತೆಯೇ ಎಲ್ಲಾ ವಿಷಯಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಪಡೆಯಲು ಕಾರಿನ ದೇಹವನ್ನು ಡಿಸ್ಅಸೆಂಬಲ್ ಮಾಡುವ ಅಗತ್ಯವಿದೆ. ಯಾವುದಕ್ಕಾಗಿ? ಕಾರ್ ದೇಹವನ್ನು ಡಿಸ್ಅಸೆಂಬಲ್ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ನೀವು ಆಕಸ್ಮಿಕವಾಗಿ ಏನನ್ನಾದರೂ ಹಿಡಿಯಬಹುದು ಮತ್ತು ಅದನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬಹುದು. ಇದು ಕೋಡ್‌ನಲ್ಲಿ ಸಹ ಸಾಧ್ಯವಿದೆ: ನಾನು ಸಾಲಿನ ಹೆಸರನ್ನು ಒಂದೇ ಸ್ಥಳದಲ್ಲಿ ಬದಲಾಯಿಸಲು ಬಯಸುತ್ತೇನೆ, ಆದರೆ ಬದಲಿ ಸಂಪೂರ್ಣ ಫೈಲ್‌ನಾದ್ಯಂತ ಸಂಭವಿಸಿದೆ, ಇದು ದೋಷಗಳ ಚದುರುವಿಕೆಗೆ ಕಾರಣವಾಯಿತು. ಅಥವಾ ನೀವು ಬಟನ್‌ನ ಬಣ್ಣವನ್ನು ಬದಲಾಯಿಸಲು ಬಯಸಿದ್ದೀರಿ, ಆದರೆ ಆಕಸ್ಮಿಕವಾಗಿ ಹತ್ತಿರದ ಕೋಡ್ ಅನ್ನು ಸೆಳೆಯಿತು ಮತ್ತು ಸಂಪೂರ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ನಿಲ್ಲಿಸಿತು.

MVC ಮಾದರಿಯ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದಾದ ಪ್ರವೇಶವನ್ನು ನಿಖರವಾಗಿ ಪ್ರತ್ಯೇಕಿಸುವುದು: ಮೊದಲನೆಯದಾಗಿ, ದೋಷದ ಮೂಲವಾಗಿರುವ ಮಾಡ್ಯೂಲ್ (ಅಥವಾ ಕೋಡ್‌ನ ಬ್ಲಾಕ್) ಅನ್ನು ಗುರುತಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಅದಕ್ಕೆ ಮಾತ್ರ ಪ್ರವೇಶವನ್ನು ನೀಡಲಾಗುತ್ತದೆ. ನೀವು ಟೈರ್ ಅನ್ನು ಬದಲಾಯಿಸಬೇಕಾದರೆ ಕಾರಿನ ಎಲೆಕ್ಟ್ರಾನಿಕ್ಸ್ ಮತ್ತು ಎಂಜಿನ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ಏಕೆ ನೀಡಬೇಕು?

ಒಂದು ಫೈಲ್‌ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿಯನ್ನು ನಡೆಸಿದರೆ, ಇದು ಆಗಾಗ್ಗೆ ಈ ರೀತಿ ಸಂಭವಿಸುತ್ತದೆ: ಹೊಸ ಕಾರ್ಯಗಳನ್ನು ಕೋಡ್‌ನ ಪ್ರಾರಂಭದಲ್ಲಿ ಅಥವಾ ಕೊನೆಯಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಇದು ಕಾಲಾನಂತರದಲ್ಲಿ ಅವುಗಳ ಮಿಶ್ರಣಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. ಕಾರ್ಯಗಳಲ್ಲಿ ಕೋಡ್‌ನ ಮಿಶ್ರಣವನ್ನು ಇಲ್ಲಿ ಸೇರಿಸೋಣ, ಮತ್ತು ಒಂದು ತಿಂಗಳಲ್ಲಿ ಕಾಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಸಹ ಇದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕಷ್ಟವಾಗುತ್ತದೆ.

MVC ಯ ಸಂದರ್ಭದಲ್ಲಿ ಮೇಲೆ ತೋರಿಸಿರುವ ಉದಾಹರಣೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸೋಣ. ಇದನ್ನು ಮಾಡಲು, ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ವಿಭಜಿಸಿ ಸೂಕ್ತ ಬ್ಲಾಕ್ಗಳಲ್ಲಿ ಗುಂಪು ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಕೋಡ್‌ನಲ್ಲಿನ ಬ್ಲಾಕ್‌ಗಳ ಕ್ರಮವು ಮುಖ್ಯವಲ್ಲ, ಆದರೆ ತರ್ಕಕ್ಕೆ ಬದ್ಧವಾಗಿರುವುದು ಉತ್ತಮ: ನಿಯಂತ್ರಕವು ಕೆಲಸ ಮಾಡಲು, ಅವುಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಡೇಟಾ ಮತ್ತು ಅಂಶಗಳು ಎರಡೂ ಅವಶ್ಯಕವಾಗಿದೆ, ಆದ್ದರಿಂದ ಅದನ್ನು ಕೊನೆಯದಾಗಿ ಇರಿಸಲಾಗುತ್ತದೆ. ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸಿದಾಗ, ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿರಬೇಕು. ಇದರರ್ಥ ಮಾದರಿ ಬ್ಲಾಕ್ ಮೊದಲು ಬರುತ್ತದೆ:

1. ಮಾದರಿ
2. ಪ್ರದರ್ಶನ
3. ನಿಯಂತ್ರಕ

//+++ ಮಾದರಿ (ಫಂಕ್ಷನ್())( var _obj = ; //+++ ಡೇಟಾ var _version = "ಅಪ್ಲಿಕೇಶನ್ ಆವೃತ್ತಿ 1.0"; var _titleShowVersion = "ಆವೃತ್ತಿಯನ್ನು ತೋರಿಸು"; // --- ಡೇಟಾ
//+++ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾರ್ವಜನಿಕ ವಿಧಾನಗಳು _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, 0.1); "_btnShowVersion";

))(); //--- ಪ್ರಸ್ತುತಿ //+++ ನಿಯಂತ್ರಕ (ಫಂಕ್ಷನ್(p_object)( var _obj = ; // ಸಾರ್ವಜನಿಕ ವಸ್ತು ಹುಡುಕಾಟ ವಿಧಾನ _obj.findObjectById = ಕಾರ್ಯ (p_name)( var _objectList = app.GetObjects(); (var _i) ಗಾಗಿ _objectList ನಲ್ಲಿ)( if(_objectList[_i].name == p_name)( return _objectList[_i]; ) null ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.control = _obj))(); ಕಾರ್ಯ OnStart())( var _buttonShowVersion = window.control.findObjectById("_btnShowVersion"); //+++ ಕ್ರಿಯೆ _buttonShowVersion.SetOnTouch(ಫಂಕ್ಷನ್())( this.SetText(window.model)ion()Vers); ; // --- ಕ್ರಿಯೆ ) //--- ನಿಯಂತ್ರಕ

ಕಾರ್ಯಗಳ ಪ್ರತ್ಯೇಕತೆಯ ಕಾರಣ, ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಹಲವಾರು ಬಾರಿ ಹೆಚ್ಚಾಗಿದೆ.

ಆರಂಭದಲ್ಲಿ, ಎಲ್ಲಾ ಅಸ್ಥಿರಗಳನ್ನು ಖಾಸಗಿಯಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಮಾತ್ರ, ಅಗತ್ಯವಿದ್ದರೆ, ಜಾಗತಿಕ ಮೂಲಕ ಪ್ರವೇಶವನ್ನು ತೆರೆಯಲಾಗುತ್ತದೆ ವಿಂಡೋ ವಸ್ತು, ಇದು ಜಾಗತಿಕ ಅಸ್ಥಿರಗಳಿಲ್ಲದೆ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಯು ಜಾವಾದಲ್ಲಿ ವಿಜೆಟ್ ಹುಡುಕಾಟವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಆದರೆ ನೀವು ಅದನ್ನು ಸರಳವಾಗಿ ಮಾಡಬಹುದು ಮತ್ತು ಜಾಗತಿಕ ಮೂಲಕ ವಸ್ತುವಿಗೆ ಪ್ರವೇಶವನ್ನು ತೆರೆಯುವ ಮೂಲಕ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡಬಹುದು ಸಹಾಯಕ ಶ್ರೇಣಿ:

Window.controls = ;
window.controls.buttonShowVersion = _btnShowVersion;

ಡೇಟಾ, ಅದರ ಪ್ರದರ್ಶನ ಮತ್ತು ಕ್ರಿಯೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯು ವಿಭಿನ್ನ ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿದೆ, ಪರಸ್ಪರ ಮಿಶ್ರಣವಿಲ್ಲದೆ, ಡೆವಲಪರ್ ಅವರೊಂದಿಗೆ ಸುಲಭವಾಗಿ ಕೆಲಸ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಡೇಟಾ ಮತ್ತು ಕೋಡ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಸುಲಭ, ಕಡಿಮೆ ದೋಷಗಳು ಇರುತ್ತವೆ, ಡೀಬಗ್ ಮಾಡುವುದು, ಬೆಂಬಲ ಮತ್ತು ಅಳತೆ ಮಾಡುವುದು ಸುಲಭವಾಗುತ್ತದೆ.

ಈ ಎಲ್ಲಾ ಮೂರು ಘಟಕಗಳನ್ನು ಪರಸ್ಪರ ಬೇರ್ಪಡಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. MVC ಯ ಹಲವಾರು ಮಾರ್ಪಾಡುಗಳಿವೆ, ಹಾಗೆಯೇ ಈ ಮಾದರಿಯ ಅಪೂರ್ಣ ಅನುಷ್ಠಾನಗಳಿವೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಡೇಟಾವನ್ನು ಪ್ರತ್ಯೇಕಿಸಬಹುದು ಮತ್ತು ಅನಾಮಧೇಯ ಕಾಲ್‌ಬ್ಯಾಕ್ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿಯಂತ್ರಣಗಳೊಂದಿಗೆ ಕ್ರಿಯೆಯ ಕೋಡ್ ಅನ್ನು ಸಂಯೋಜಿಸಬಹುದು.

ಆಬ್ಜೆಕ್ಟ್-ಆಧಾರಿತ ಪರಿಸರದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ, ಕೋಡ್ ಮತ್ತು ಡೇಟಾದ ಬೇರ್ಪಡಿಕೆಯು ಆರಂಭದಲ್ಲಿ ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ: ಡೇಟಾ ಮತ್ತು ಕ್ರಿಯೆಗಳನ್ನು ವರ್ಗಗಳಾಗಿ ವರ್ಗೀಕರಿಸಲಾಗಿದೆ, ವಸ್ತುಗಳು ಪರಸ್ಪರ ಸಂವಹನ ನಡೆಸುತ್ತವೆ ತೆರೆದ ವಿಧಾನಗಳುಇತ್ಯಾದಿ MVC ಕೋಡ್ ಮತ್ತು ಡೇಟಾದ ಸೂಕ್ಷ್ಮವಾದ, ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾದ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಅವುಗಳ ಪ್ರಮುಖ ಕಾರ್ಯಗಳಲ್ಲಿ ಅನುಮತಿಸುತ್ತದೆ.

MVC ಮಾದರಿಯನ್ನು ಬಳಸುವ ಪ್ರಯೋಜನಗಳನ್ನು ಚೆನ್ನಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಕೋಡ್ ಅನ್ನು ಪ್ರತ್ಯೇಕ ಫೈಲ್‌ಗಳಾಗಿ ವಿಭಜಿಸುವುದನ್ನು ನೋಡೋಣ.

MVC ಮಾದರಿಯ ಮೂರು-ಫೈಲ್ ಅನುಷ್ಠಾನ

ಮೂಲಕ ಕೋಡ್ ವಿಭಾಗ ವಿವಿಧ ಫೈಲ್ಗಳುಹೆಚ್ಚು ಬಳಸಲಾಗುತ್ತದೆ ಆರಾಮದಾಯಕ ಕೆಲಸಅವನೊಂದಿಗೆ. MVC ಯೋಜನೆಗಳಲ್ಲಿ ಕಂಡುಬರುವ ದೊಡ್ಡ ಸಂಖ್ಯೆಯ ಸಣ್ಣ ಫೈಲ್‌ಗಳು ಈ ಹೇಳಿಕೆಯನ್ನು ಪ್ರಶ್ನಿಸಬಹುದು, ಆದರೆ ಫೈಲ್‌ಗಳನ್ನು ನೋಡುವುದು ಒಂದು ವಿಷಯ, ಅವರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಇನ್ನೊಂದು. ಸಮಯದ ಪ್ರತಿ ಕ್ಷಣದಲ್ಲಿ, ಡೆವಲಪರ್ ಕೆಲವು ಸಣ್ಣ ಸೆಟ್‌ಗಳಿಂದ ಒಂದು ಫೈಲ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತಾರೆ. ಇದನ್ನು ಮಾಡಲು, ನೀವು ಯೋಜನಾ ಸಂಸ್ಥೆಯ ರಚನೆಯ ಬಗ್ಗೆ ಉತ್ತಮ ತಿಳುವಳಿಕೆಯನ್ನು ಹೊಂದಿರಬೇಕು ಮತ್ತು ನಿರಂತರವಾಗಿ ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಬೇಕು ಮೂರು ಕಡತಗಳು- ಮಾದರಿ, ವೀಕ್ಷಣೆ ಮತ್ತು ನಿಯಂತ್ರಕ, ಆದ್ದರಿಂದ ಆಕಸ್ಮಿಕವಾಗಿ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಕೋಡ್ ಅನ್ನು ಸಂಪಾದಿಸಬಾರದು. ಡ್ರಾಯಿಡ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಎಡಿಟರ್‌ನ ಮಿತಿಗಳ ಕಾರಣದಿಂದಾಗಿ, ಅಂತಹ ಗುಂಪು ಮಾಡುವಿಕೆಯು ರೂಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿರುವ ಫೈಲ್ ಹೆಸರುಗಳಿಂದ ಮಾತ್ರ ಸಾಧ್ಯ, ಉದಾಹರಣೆಗೆ:

myproject_model.js - ಮಾದರಿ
myproject_view.js - ವೀಕ್ಷಿಸಿ
myproject_control.js - ನಿಯಂತ್ರಕ

ಹಿಂದಿನ ಉದಾಹರಣೆಯ ಕೋಡ್ ಅನ್ನು ಫೈಲ್‌ಗಳಾಗಿ ವಿಭಜಿಸುವ ಉದಾಹರಣೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

myproject_model.js - ಮಾದರಿ(ಫಂಕ್ಷನ್())( var _obj = ; //+++ ಡೇಟಾ var _version = "ಅಪ್ಲಿಕೇಶನ್ ಆವೃತ್ತಿ 1.0"; //--- ಡೇಟಾ //+++ ಸ್ಟ್ರಿಂಗ್ ಸಂಪನ್ಮೂಲ var _titleShowVersion = "ಆವೃತ್ತಿಯನ್ನು ತೋರಿಸು"; //++ + ಸ್ಟ್ರಿಂಗ್ ಸಂಪನ್ಮೂಲ _obj.getVersion = ಕಾರ್ಯ () ( return _version; ) _obj.btnGetTitle = ಕಾರ್ಯ () ( ಹಿಂತಿರುಗಿ _titleShowVersion; ) window.model = _obj ))(); myproject_view.js - ವೀಕ್ಷಿಸಿ(ಫಂಕ್ಷನ್ ()( var _lay = app.CreateLayout ("ಲೀನಿಯರ್", "VCenter,FillXY"); var _btnShowVersion = app.CreateButton(window.model.btnGetTitle(), 0.3, 0.1); "Versiontname_ _btnShowVersion.SetBackColor(_btnShowVersion.SetMargins(0, 0.05, 0, 0)); myproject_control.js - ನಿಯಂತ್ರಕ app.LoadScript("myproject_model.js"); app.LoadScript("myproject_view.js");(ಫಂಕ್ಷನ್(p_object)( var _obj = ; // ಆಬ್ಜೆಕ್ಟ್ ಹುಡುಕಾಟ ವಿಧಾನ _obj.findObjectById = ಕಾರ್ಯ(p_name)(var _objectList = app.GetObjects(); (_objectList ನಲ್ಲಿ var _i)( if(_objectList =_i) = p_name)(return _objectList[_i]; ) null ಹಿಂತಿರುಗಿ.control = _obj; ಕಾರ್ಯ OnStart())( var _buttonShowVersion = window.control.findObjectById("_btnShowVersion"); //+++ ಕ್ರಿಯೆ _buttonShowVersion.SetOnTouch(ಫಂಕ್ಷನ್())( this.SetText(window.model)ion()Vers); ; // --- ಕ್ರಿಯೆ )

ಈ ಸರಳವಾದ ಕೋಡ್ ಅನ್ನು ಫೈಲ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸುವುದು ಸುಲಭವಲ್ಲ. ಇದನ್ನು ಮಾಡಲು, ಮೂಲಕ ಮಾದರಿಯೊಂದಿಗೆ ಮುಂಚಿತವಾಗಿ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಸಾರ್ವಜನಿಕ ಆಸ್ತಿಜಾಗತಿಕ ಮೂಲ ವಸ್ತು - ವಿಂಡೋ.ಮಾದರಿ, ಮತ್ತು ಪ್ರಾತಿನಿಧ್ಯದೊಂದಿಗಿನ ಸಂಪರ್ಕವು ಮೂಲಕ ಜಾಗತಿಕ ಶ್ರೇಣಿ _ನಕ್ಷೆವಿಧಾನದ ಮೂಲಕ app.GetObjects.

ಕೋಡ್ ಅನ್ನು ಫೈಲ್‌ಗಳಾಗಿ ವಿಭಜಿಸುವ ಪ್ರಯೋಜನವೆಂದರೆ ನೀವು ಈಗ ಕೋಡ್ ಅನ್ನು ಸಂಪೂರ್ಣ ಬ್ಲಾಕ್ ಆಗಿ ಬದಲಾಯಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ತ್ವರಿತ ಉಡಾವಣೆಯೋಜನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ ಸರಳ ಮಾದರಿ, ತದನಂತರ ಫೈಲ್ ಅನ್ನು ಮತ್ತೊಂದು ಹೆಚ್ಚು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಬದಲಾಯಿಸಿ, ಆದರೆ ಅದೇ ಹೆಸರು ಮತ್ತು ಇಂಟರ್ಫೇಸ್ನೊಂದಿಗೆ. ಈ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ಉಪಕರಣಗಳನ್ನು ದುರಸ್ತಿ ಮಾಡುವಾಗ. ಹಿಂದಿನ ರಿಪೇರಿಗಳು ನಿಧಾನ ಮತ್ತು ಶ್ರಮದಾಯಕ ಹುಡುಕಾಟ ಮತ್ತು ವಿಫಲವಾದ ರೇಡಿಯೊ ಘಟಕಗಳ ಬದಲಿಯನ್ನು ಒಳಗೊಂಡಿದ್ದರೆ, ಈಗ ಪ್ರಮಾಣಿತ ಘಟಕಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗುತ್ತಿದೆ. ಸಂಕೀರ್ಣ ಬೋರ್ಡ್ ಅನ್ನು ದುರಸ್ತಿ ಮಾಡುವ ವೆಚ್ಚವು ಅದರ ತ್ವರಿತ ಬದಲಿಗಿಂತ ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚಾಗಿದೆ.

ಉತ್ತಮವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಇಂಟರ್ಫೇಸ್ ಮಾಡ್ಯೂಲ್‌ಗಳ ನಂತರದ ಏಕೀಕರಣವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸರಳಗೊಳಿಸುತ್ತದೆ ಎಂದು ಮೇಲಿನಿಂದ ಇದು ಅನುಸರಿಸುತ್ತದೆ.

IN ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಸ್ತುಗಳುಉಲ್ಲೇಖದ ಮೂಲಕ ರವಾನಿಸಲಾಗಿದೆ. ನಿಯಂತ್ರಕದಲ್ಲಿ ವಿಜೆಟ್ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬದಲಾಯಿಸುವುದು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ ಸ್ವತಃವಿಜೆಟ್. ಸೈದ್ಧಾಂತಿಕವಾಗಿ, ಜಾವಾದಲ್ಲಿ ಮಾಡಿದಂತೆ ಕೋಡ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಂದ ವೀಕ್ಷಣೆ ವಸ್ತುಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಸಾಧ್ಯವಿದೆ, ಅಲ್ಲಿ xml ರಚನೆಗಳನ್ನು ಮೊದಲನೆಯದಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಆದರೆ ಎರಡು ಕಾರಣಗಳಿಗಾಗಿ ಇದರಲ್ಲಿ ಸ್ವಲ್ಪ ಅಂಶವಿದೆ - ಡ್ರಾಯಿಡ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಇಲ್ಲದಿರುವುದು ದೃಶ್ಯ ಸಂಪಾದಕಇಂಟರ್ಫೇಸ್ ಮತ್ತು API ವಸ್ತುಗಳ ಲಭ್ಯವಿರುವ ಗುಣಲಕ್ಷಣಗಳ ಸೀಮಿತ ಸೆಟ್.

MVC ಮಾದರಿಯ ಬಹು-ಫೈಲ್ ಅನುಷ್ಠಾನ

ನಿಯೋಜಿಸಲಾದ ಕಾರ್ಯಗಳು ಮತ್ತು ಯೋಜನೆಯ ಸಂಕೀರ್ಣತೆಯನ್ನು ಅವಲಂಬಿಸಿ, ಕೋಡ್ ಮತ್ತು ಡೇಟಾದ ಪ್ರತ್ಯೇಕತೆಯ ವಿವರಗಳು ಸಾಮಾನ್ಯವಾಗಿ ವಿಭಿನ್ನವಾಗಿರಬಹುದು. ನೀವು ಸಂಪನ್ಮೂಲಗಳಿಂದ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಮತ್ತಷ್ಟು ಪ್ರತ್ಯೇಕಿಸಬಹುದು, ನೀವು ಪ್ರಕಾರ, ಗುಂಪು ಕ್ರಿಯೆಗಳು, ಇತ್ಯಾದಿಗಳ ಮೂಲಕ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಕೊರೆಯಬಹುದು. ಆದರೆ DroidScript ಸಂಪಾದಕವು MVC ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಪೂರ್ಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವುದಿಲ್ಲ.

ಸಂಕೀರ್ಣದೊಂದಿಗೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸುವಾಗ ಮಾದರಿ-ವೀಕ್ಷಣೆ-ನಿಯಂತ್ರಕ (MVC) ಮಾದರಿಯು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ ಚಿತ್ರಾತ್ಮಕ ಇಂಟರ್ಫೇಸ್ಅಥವಾ ನಡವಳಿಕೆ. ಆದರೆ ಹೆಚ್ಚಿನದಕ್ಕಾಗಿ ಸರಳ ಪ್ರಕರಣಗಳುಇದು ಕೂಡ ಸರಿಹೊಂದುತ್ತದೆ. ಈ ಪೋಸ್ಟ್‌ನಲ್ಲಿ ನಾವು ಈ ಮಾದರಿಯ ಆಧಾರದ ಮೇಲೆ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಮೈನ್‌ಸ್ವೀಪರ್ ಆಟವನ್ನು ರಚಿಸುತ್ತೇವೆ. ಪೈಥಾನ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿ ಭಾಷೆಯಾಗಿ ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ, ಆದರೆ ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಲ್ಲ. ಮಾದರಿಗಳು ನಿರ್ದಿಷ್ಟ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿಲ್ಲ ಮತ್ತು ನೀವು ಯಾವುದೇ ಇತರ ವೇದಿಕೆಗೆ ಪರಿಣಾಮವಾಗಿ ಅನುಷ್ಠಾನವನ್ನು ಸುಲಭವಾಗಿ ವರ್ಗಾಯಿಸಬಹುದು.

ಜಾಹೀರಾತು

MVC ಮಾದರಿಯ ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ

ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, MVC ಮಾದರಿಯು 3 ಘಟಕಗಳನ್ನು ಒಳಗೊಂಡಿದೆ: ಮಾದರಿ, ವೀಕ್ಷಣೆ ಮತ್ತು ನಿಯಂತ್ರಕ. ಪ್ರತಿಯೊಂದು ಘಟಕಗಳು ಅದರ ಪಾತ್ರವನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ ಮತ್ತು ಪರಸ್ಪರ ಬದಲಾಯಿಸಲ್ಪಡುತ್ತವೆ. ಇದರರ್ಥ ಘಟಕಗಳು ಕೆಲವು ಸ್ಪಷ್ಟ ಇಂಟರ್ಫೇಸ್‌ಗಳಿಂದ ಮಾತ್ರ ಪರಸ್ಪರ ಸಂಪರ್ಕ ಹೊಂದಿವೆ, ಅದರ ಹಿಂದೆ ಯಾವುದೇ ಅನುಷ್ಠಾನವು ಇರುತ್ತದೆ. ಈ ವಿಧಾನವು ಬದಲಿಸಲು ಮತ್ತು ಸಂಯೋಜಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ ವಿವಿಧ ಘಟಕಗಳು, ಅಗತ್ಯ ಕಾರ್ಯಾಚರಣೆಯ ತರ್ಕವನ್ನು ಒದಗಿಸುವುದು ಅಥವಾ ಕಾಣಿಸಿಕೊಂಡಅಪ್ಲಿಕೇಶನ್ಗಳು. ಪ್ರತಿಯೊಂದು ಘಟಕವು ನಿರ್ವಹಿಸುವ ಕಾರ್ಯಗಳನ್ನು ನೋಡೋಣ.

ಮಾದರಿ

ಕಾರ್ಯಕ್ರಮದ ಆಂತರಿಕ ತರ್ಕಕ್ಕೆ ಜವಾಬ್ದಾರರು. ಇಲ್ಲಿ ನಾವು ಡೇಟಾ ಸಂಗ್ರಹಣೆಯ ವಿಧಾನಗಳನ್ನು ಮರೆಮಾಡಬಹುದು, ಹಾಗೆಯೇ ಮಾಹಿತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಿಯಮಗಳು ಮತ್ತು ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಮರೆಮಾಡಬಹುದು.

ಉದಾಹರಣೆಗೆ, ಒಂದು ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ನಾವು ಹಲವಾರು ಮಾದರಿಗಳನ್ನು ರಚಿಸಬಹುದು. ಒಂದು ಡೀಬಗ್ ಆಗಿರುತ್ತದೆ ಮತ್ತು ಇನ್ನೊಂದು ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಮೊದಲನೆಯದು ಅದರ ಡೇಟಾವನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಅಥವಾ ಫೈಲ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ಎರಡನೆಯದು ಈಗಾಗಲೇ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಮೂಲಭೂತವಾಗಿ, ಇದು ಕೇವಲ ಒಂದು ತಂತ್ರದ ಮಾದರಿಯಾಗಿದೆ.

ಪ್ರದರ್ಶನ

ಮಾದರಿ ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸುವ ಜವಾಬ್ದಾರಿ. ಈ ಹಂತದಲ್ಲಿ, ನಾವು ಮಾದರಿಯೊಂದಿಗೆ ಬಳಕೆದಾರರ ಸಂವಹನಕ್ಕಾಗಿ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಮಾತ್ರ ಒದಗಿಸುತ್ತೇವೆ. ಈ ಘಟಕವನ್ನು ಪರಿಚಯಿಸುವ ಅಂಶವು ಹಲವಾರು ಮಾದರಿಗಳ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಒದಗಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದೇ ಆಗಿರುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ಅಭಿವೃದ್ಧಿಯ ಆರಂಭಿಕ ಹಂತಗಳಲ್ಲಿ, ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ನಾವು ಸರಳ ಕನ್ಸೋಲ್ ವೀಕ್ಷಣೆಯನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ನಂತರ ಮಾತ್ರ ಸುಂದರವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ GUI ಅನ್ನು ಸೇರಿಸಬಹುದು. ಇದಲ್ಲದೆ, ಎರಡೂ ರೀತಿಯ ಇಂಟರ್ಫೇಸ್ಗಳನ್ನು ಉಳಿಸಲು ಸಾಧ್ಯವಿದೆ.

ಹೆಚ್ಚುವರಿಯಾಗಿ, ವೀಕ್ಷಣೆಯ ಜವಾಬ್ದಾರಿಗಳು ಮಾದರಿಯ ಸ್ಥಿತಿಯ ಸಮಯೋಚಿತ ಪ್ರದರ್ಶನವನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುತ್ತವೆ ಎಂದು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕು. ಬಳಕೆದಾರರ ಕ್ರಿಯೆಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಿಯಂತ್ರಕ ಜವಾಬ್ದಾರನಾಗಿರುತ್ತಾನೆ, ಅದನ್ನು ನಾವು ಈಗ ಮಾತನಾಡುತ್ತೇವೆ.

ನಿಯಂತ್ರಕ

ವೀಕ್ಷಣೆಯೊಂದಿಗಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯ ಪರಿಣಾಮವಾಗಿ ಮಾದರಿ ಮತ್ತು ಬಳಕೆದಾರರ ಕ್ರಿಯೆಗಳ ನಡುವೆ ಲಿಂಕ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಮಾದರಿ ಮತ್ತು ವೀಕ್ಷಣೆಯ ಸ್ಥಿತಿಗಳನ್ನು ನವೀಕರಿಸುವ ಕ್ಷಣಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ. ಒಂದು ರಾಜ್ಯದಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಅಪ್ಲಿಕೇಶನ್ ಪರಿವರ್ತನೆಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ವಾಸ್ತವವಾಗಿ, ವೀಕ್ಷಣೆಯಲ್ಲಿ ಬಳಕೆದಾರರು ತೆಗೆದುಕೊಳ್ಳಬಹುದಾದ ಪ್ರತಿಯೊಂದು ಕ್ರಿಯೆಗೆ, ನಿಯಂತ್ರಕದಲ್ಲಿ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು. ಈ ಹ್ಯಾಂಡ್ಲರ್ ಮಾದರಿಯಲ್ಲಿ ಸೂಕ್ತವಾದ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಅಗತ್ಯವಿದ್ದರೆ, ಬದಲಾವಣೆಗಳಿವೆ ಎಂದು ವೀಕ್ಷಣೆಗೆ ತಿಳಿಸುತ್ತದೆ.

ಜಾಹೀರಾತು

ಮೈನ್‌ಸ್ವೀಪರ್ ಆಟದ ವಿಶೇಷಣಗಳು

ಸಾಕಷ್ಟು ಸಿದ್ಧಾಂತ. ಈಗ ಅಭ್ಯಾಸಕ್ಕೆ ಹೋಗೋಣ. ಪ್ರದರ್ಶನಕ್ಕಾಗಿ MVC ಮಾದರಿನಾವು ಸರಳವಾದ ಆಟವನ್ನು ಬರೆಯುತ್ತೇವೆ: ಮೈನ್‌ಸ್ವೀಪರ್. ಆಟದ ನಿಯಮಗಳು ತುಂಬಾ ಸರಳವಾಗಿದೆ:

1. ಆಟದ ಮೈದಾನವು ಜೀವಕೋಶಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಆಯತಾಕಾರದ ಪ್ರದೇಶವಾಗಿದೆ. ಕೆಲವು ಕೋಶಗಳು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಗಣಿಗಳಲ್ಲಿ ಇರಿಸಲ್ಪಟ್ಟಿವೆ, ಆದರೆ ಆಟಗಾರನಿಗೆ ಅವುಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದಿಲ್ಲ;
2. ಆಟಗಾರನು ಎಡದಿಂದ ಅಥವಾ ಮೈದಾನದ ಯಾವುದೇ ಕೋಶದ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಬಹುದು ಬಲ ಗುಂಡಿಗಳುಇಲಿಗಳು;
3. ಎಡ ಮೌಸ್ ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡುವುದರಿಂದ ಕೋಶವನ್ನು ತೆರೆಯಲಾಗುತ್ತದೆ. ಇದಲ್ಲದೆ, ಕೋಶದಲ್ಲಿ ಗಣಿ ಇದ್ದರೆ, ಆಟವು ನಷ್ಟದಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ತೆರೆದ ಒಂದರ ಪಕ್ಕದಲ್ಲಿ ಪಕ್ಕದ ಕೋಶಗಳಲ್ಲಿ ಗಣಿಗಳಿದ್ದರೆ, ತೆರೆದ ಕೋಶದಲ್ಲಿ ಸುತ್ತಲಿನ ಗಣಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿರುವ ಕೌಂಟರ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ತೆರೆದ ಕೋಶದ ಸುತ್ತಲೂ ಯಾವುದೇ ಗಣಿಗಳಿಲ್ಲದಿದ್ದರೆ, ಪ್ರತಿ ನೆರೆಯ ಕೋಶವು ಒಂದೇ ತತ್ತ್ವದ ಪ್ರಕಾರ ತೆರೆದಿರುತ್ತದೆ. ಅಂದರೆ, ಕೋಶಗಳು ಆಟದ ಮೈದಾನದ ಗಡಿಯನ್ನು ಹೊಡೆಯುವವರೆಗೆ ಅಥವಾ ಈಗಾಗಲೇ ತೆರೆದ ಕೋಶಗಳನ್ನು ತಲುಪುವವರೆಗೆ ತೆರೆದುಕೊಳ್ಳುತ್ತವೆ ಅಥವಾ ಅವುಗಳ ಪಕ್ಕದಲ್ಲಿ ಯಾವುದೇ ಗಣಿ ಇರುವುದಿಲ್ಲ;
4. ಬಲ ಮೌಸ್ ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್ ಮಾಡುವುದರಿಂದ ಕೋಶಗಳ ಮೇಲೆ ಗುರುತುಗಳನ್ನು ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಮುಚ್ಚಿದ ಕೋಶದ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡುವುದರಿಂದ ಅದನ್ನು ಧ್ವಜದಿಂದ ಗುರುತಿಸಲಾಗುತ್ತದೆ, ಅದು ಅದರ ಸ್ಥಿತಿಯನ್ನು ಲಾಕ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಆಕಸ್ಮಿಕವಾಗಿ ತೆರೆಯುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಚೆಕ್‌ಮಾರ್ಕ್‌ನಿಂದ ಗುರುತಿಸಲಾದ ಪೆಟ್ಟಿಗೆಯ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡುವುದರಿಂದ ಅದರ ಗುರುತು ಪ್ರಶ್ನಾರ್ಥಕ ಚಿಹ್ನೆಗೆ ಬದಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸೆಲ್ ಅನ್ನು ಇನ್ನು ಮುಂದೆ ನಿರ್ಬಂಧಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಎಡ ಮೌಸ್ ಬಟನ್ನೊಂದಿಗೆ ತೆರೆಯಬಹುದು. ಇದರೊಂದಿಗೆ ಕೋಶದ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ ಪ್ರಶ್ನಾರ್ಥಕ ಚಿಹ್ನೆಗುರುತುಗಳಿಲ್ಲದೆ ಅದನ್ನು ಮುಚ್ಚಿದ ಸ್ಥಿತಿಗೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ;
5. ಗಣಿಗಾರಿಕೆ ಮಾಡಿದವುಗಳನ್ನು ಹೊರತುಪಡಿಸಿ, ಆಟದ ಮೈದಾನದಲ್ಲಿನ ಎಲ್ಲಾ ಕೋಶಗಳು ತೆರೆದಿರುವ ಆಟದ ಸ್ಥಿತಿಯಿಂದ ವಿಜಯವನ್ನು ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ.

ನಾವು ಏನನ್ನು ಪಡೆಯುತ್ತೇವೆ ಎಂಬುದರ ಉದಾಹರಣೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ:

ಮೈನ್‌ಸ್ವೀಪರ್ ಆಟದ UML ರೇಖಾಚಿತ್ರಗಳು

ಬರೆಯುವ ಕೋಡ್‌ಗೆ ಹೋಗುವ ಮೊದಲು, ಅಪ್ಲಿಕೇಶನ್‌ನ ವಾಸ್ತುಶಿಲ್ಪದ ಮೂಲಕ ಮುಂಚಿತವಾಗಿ ಯೋಚಿಸುವುದು ಒಳ್ಳೆಯದು. ಇದು ಅನುಷ್ಠಾನದ ಭಾಷೆಯನ್ನು ಅವಲಂಬಿಸಿರಬಾರದು, ಆದ್ದರಿಂದ ನಮ್ಮ ಉದ್ದೇಶಗಳಿಗಾಗಿ UML ಉತ್ತಮವಾಗಿದೆ.

ಗೇಮ್ ಸೆಲ್ ಸ್ಟೇಟ್ ರೇಖಾಚಿತ್ರ

ಆಟದ ಮೈದಾನದಲ್ಲಿರುವ ಯಾವುದೇ ಕೋಶವು 4 ರಾಜ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿರಬಹುದು:

1. ಪಂಜರವನ್ನು ಮುಚ್ಚಲಾಗಿದೆ;
2. ಪಂಜರ ತೆರೆದಿದೆ;
3. ಕೋಶವನ್ನು ಧ್ವಜದಿಂದ ಗುರುತಿಸಲಾಗಿದೆ;
4. ಕೋಶವನ್ನು ಪ್ರಶ್ನಾರ್ಥಕ ಚಿಹ್ನೆಯಿಂದ ಗುರುತಿಸಲಾಗಿದೆ.

ಇಲ್ಲಿ ನಾವು ಪ್ರಾತಿನಿಧ್ಯಕ್ಕೆ ಗಮನಾರ್ಹವಾದ ರಾಜ್ಯಗಳನ್ನು ಮಾತ್ರ ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ. ಆಟದ ಸಮಯದಲ್ಲಿ ಗಣಿಗಳನ್ನು ಪ್ರದರ್ಶಿಸದ ಕಾರಣ, ನಂತರ ಮೂಲ ಸೆಟ್ಅನುಗುಣವಾದ ಸ್ಥಿತಿಯನ್ನು ಒದಗಿಸಲಾಗಿಲ್ಲ. ಬಳಸಿಕೊಂಡು ಒಂದು ಕೋಶ ಸ್ಥಿತಿಯಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಸಂಭವನೀಯ ಪರಿವರ್ತನೆಗಳನ್ನು ನಾವು ನಿರ್ಧರಿಸೋಣ UML ರೇಖಾಚಿತ್ರಗಳುಷರತ್ತುಗಳು:

ಮೈನ್‌ಸ್ವೀಪರ್ ಗೇಮ್ ವರ್ಗ ರೇಖಾಚಿತ್ರ

MVC ಮಾದರಿಯನ್ನು ಆಧರಿಸಿ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ನಿರ್ಧರಿಸಿರುವುದರಿಂದ, ನಾವು ಮೂರು ಮುಖ್ಯ ವರ್ಗಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ: ಮೈನ್ಸ್‌ವೀಪರ್ ಮಾಡೆಲ್, ಮೈನ್ಸ್‌ವೀಪರ್ ವ್ಯೂ ಮತ್ತು ಮೈನ್ಸ್‌ವೀಪರ್ ಕಂಟ್ರೋಲರ್, ಹಾಗೆಯೇ ಸೆಲ್ ಸ್ಥಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಸಹಾಯಕ ವರ್ಗ ಮೈನ್ಸ್‌ವೀಪರ್‌ಸೆಲ್. ಅವರ ವರ್ಗ ರೇಖಾಚಿತ್ರವನ್ನು ನೋಡೋಣ:

ವಾಸ್ತುಶಿಲ್ಪದ ಸಂಘಟನೆಯು ತುಂಬಾ ಸರಳವಾಗಿದೆ. ಇಲ್ಲಿ ನಾವು MVC ಮಾದರಿಯ ತತ್ವಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಪ್ರತಿ ವರ್ಗಕ್ಕೆ ಕಾರ್ಯಗಳನ್ನು ಸರಳವಾಗಿ ವಿತರಿಸಿದ್ದೇವೆ:

1. ಕ್ರಮಾನುಗತದ ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿ ಆಟದ ಕೋಶ ವರ್ಗ ಮೈನ್ಸ್ವೀಪರ್ಸೆಲ್ ಆಗಿದೆ. ಇದು ಕೋಶದ ಸ್ಥಾನವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಆಟದ ಮೈದಾನದ ಸಾಲು ಸಾಲು ಮತ್ತು ಕಾಲಮ್ ಕಾಲಮ್ ನಿರ್ಧರಿಸುತ್ತದೆ; ಹಿಂದಿನ ಉಪವಿಭಾಗದಲ್ಲಿ ನಾವು ವಿವರಿಸಿದ ರಾಜ್ಯದ ಒಂದು ರಾಜ್ಯವು; ಕೋಶದಲ್ಲಿ ಗಣಿ (ಗಣಿಗಾರಿಕೆ) ಮತ್ತು ನೆರೆಯ ಕೋಶಗಳ ಕೌಂಟರ್‌ನಲ್ಲಿ ಗಣಿಗಳ ಕೌಂಟರ್ ಇರುವ ಬಗ್ಗೆ ಮಾಹಿತಿ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಇದು ಎರಡು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿದೆ: ಬಲ-ಕ್ಲಿಕ್‌ನಿಂದ ಉಂಟಾಗುವ ಅಂಕಗಳೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ರಾಜ್ಯಗಳ ಮೂಲಕ ಸೈಕ್ಲಿಂಗ್ ಮಾಡಲು nextMark() ಮತ್ತು ಎಡ-ಕ್ಲಿಕ್ ಈವೆಂಟ್ ಅನ್ನು ನಿರ್ವಹಿಸುವ ಓಪನ್();
2. ಮೈನ್‌ಸ್ವೀಪರ್ ಮಾಡೆಲ್ ಮಾದರಿ ವರ್ಗವು ಸ್ವಲ್ಪ ಮೇಲಿದೆ. ಅವರು ಮೈನ್‌ಸ್ವೀಪರ್‌ಸೆಲ್ ಆಟದ ಕೋಶಗಳಿಗೆ ಕಂಟೇನರ್ ಆಗಿದ್ದಾರೆ. ಇದರ ಮೊದಲ ವಿಧಾನ, startGame(), ಆಟವನ್ನು ಪ್ರಾರಂಭಿಸಲು ಆಟದ ಮೈದಾನವನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತದೆ. isWin() ವಿಧಾನವು ಗೆಲುವಿನ ಸ್ಥಿತಿಗಾಗಿ ಆಟದ ಕ್ಷೇತ್ರವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಆಟಗಾರನು ಗೆದ್ದರೆ ನಿಜವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಅದು ತಪ್ಪಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ನಷ್ಟವನ್ನು ಪರಿಶೀಲಿಸಲು ಇದೇ ರೀತಿಯ ವಿಧಾನವನ್ನು isGameOver() ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. openCell() ಮತ್ತು nextCellMark() ವಿಧಾನಗಳು ಆಟದ ಮೈದಾನದಲ್ಲಿನ ಅನುಗುಣವಾದ ಕೋಶಗಳಿಗೆ ಕ್ರಿಯೆಗಳನ್ನು ಸರಳವಾಗಿ ನಿಯೋಜಿಸುತ್ತವೆ ಮತ್ತು getCell() ವಿಧಾನವು ವಿನಂತಿಸಿದ ಪ್ಲೇಯಿಂಗ್ ಸೆಲ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ;
3. MinesweeperView ವರ್ಗ ಒಳಗೊಂಡಿದೆ ಕೆಳಗಿನ ವಿಧಾನಗಳು: syncWithModel() - ಮಾದರಿಯಲ್ಲಿ ಆಟದ ಮೈದಾನದ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ವೀಕ್ಷಣೆಯ ಮರುಹಂಚಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ; getGameSettings() - ಆಟದ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ; createBoard () - ಮಾದರಿ ಡೇಟಾವನ್ನು ಆಧರಿಸಿ ಆಟದ ಮೈದಾನವನ್ನು ರಚಿಸುತ್ತದೆ; showWinMessage() ಮತ್ತು showGameOverMessage() ಕ್ರಮವಾಗಿ ಗೆಲುವು ಮತ್ತು ನಷ್ಟ ಸಂದೇಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ;
4. ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಿಯಂತ್ರಕ ವರ್ಗ ಮೈನ್ಸ್ವೀಪರ್ ಕಂಟ್ರೋಲರ್. ಇದು ಪ್ರತಿಯೊಂದಕ್ಕೂ ಮೂರು ವಿಧಾನಗಳನ್ನು ಮಾತ್ರ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ ಸಂಭವನೀಯ ಕ್ರಮಆಟಗಾರ: startNewGame() " ಗುಂಡಿಯನ್ನು ಒತ್ತಲು ಕಾರಣವಾಗಿದೆ ಹೊಸ ಆಟ"ವೀಕ್ಷಣೆ ಇಂಟರ್‌ಫೇಸ್‌ನಲ್ಲಿ; onLeftClick() ಮತ್ತು 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 = column self.state = "ಮುಚ್ಚಿದ" ಸ್ವಯಂ .mined = ತಪ್ಪು 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 != "ಫ್ಲ್ಯಾಗ್ಡ್": self.state = "ತೆರೆದ" ವರ್ಗ MinesweeperModel: def __init__ (self): self.startGame() def startGame(self, rowCount = 15, columnCount = 15, mineCount = 15): ಶ್ರೇಣಿಯಲ್ಲಿ rowCount ಆಗಿದ್ದರೆ (MIN_ROW_COUNT, MAX_ROW_COUNT + 1 ಕಾಲಮ್ = 1): selfrowCount ವ್ಯಾಪ್ತಿಯಲ್ಲಿ(MIN_COLUMN_COUNT , MAX_COLUMN_COUNT + 1): self.columnCount = minecount ಆಗಿದ್ದರೆ columnCount< 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 ಸಹಾಯಕ ಪಟ್ಟಿಯನ್ನು ಬಳಸುತ್ತೇವೆ. ಕೋಶವು "ತೆರೆದ" ಸ್ಥಿತಿಯಲ್ಲಿದ್ದರೆ, ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಸೇರಿಸಲಾಗಿಲ್ಲ, ನಂತರ ಮುಂದಿನ ಮಾರ್ಕ್ () ವಿಧಾನದಲ್ಲಿ ಏನೂ ಆಗುವುದಿಲ್ಲ, ಇಲ್ಲದಿದ್ದರೆ ಕೋಶವು ಮುಂದಿನ ಸ್ಥಿತಿಗೆ ಹೋಗುತ್ತದೆ ಮತ್ತು ಕೊನೆಯ "ಪ್ರಶ್ನಿತ" ಸ್ಥಿತಿಯಿಂದ ಅದು "ಜಿಗಿಯುತ್ತದೆ" "ಆರಂಭಿಕ "ಮುಚ್ಚಿದ" ಸ್ಥಿತಿಗೆ ". ತೆರೆದ () ವಿಧಾನದಲ್ಲಿ, ನಾವು ಕೋಶದ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಮತ್ತು ಅದು "ಫ್ಲ್ಯಾಗ್" ಮಾಡದಿದ್ದರೆ, ಕೋಶವು "ತೆರೆದ" ಮುಕ್ತ ಸ್ಥಿತಿಗೆ ಹೋಗುತ್ತದೆ.

ಮುಂದೆ ಮೈನ್ಸ್ವೀಪರ್ ಮಾಡೆಲ್ ಮಾದರಿ ವರ್ಗದ ವ್ಯಾಖ್ಯಾನ ಬರುತ್ತದೆ. ಸ್ಟಾರ್ಟ್‌ಗೇಮ್() ವಿಧಾನವು ರೋಕೌಂಟ್, ಕಾಲಮ್‌ಕೌಂಟ್ ಮತ್ತು ಮೈನ್‌ಕೌಂಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆಟದ ಮೈದಾನವನ್ನು ಲೇಔಟ್ ಮಾಡುತ್ತದೆ. ಪ್ರತಿ ಪ್ಯಾರಾಮೀಟರ್ ಸ್ವೀಕಾರಾರ್ಹ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ. ಪ್ರಸರಣ ಮೌಲ್ಯವು ವ್ಯಾಪ್ತಿಯಿಂದ ಹೊರಗಿದ್ದರೆ, ಆಟದ ಮೈದಾನದ ನಿಯತಾಂಕದ ಮೌಲ್ಯವನ್ನು ಉಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಬದಲಾಗುವುದಿಲ್ಲ. ಗಣಿಗಳ ಸಂಖ್ಯೆಗೆ ಹೆಚ್ಚುವರಿ ಚೆಕ್ ಇದೆ ಎಂದು ಗಮನಿಸಬೇಕು. ವರ್ಗಾವಣೆಗೊಂಡ ಗಣಿಗಳ ಸಂಖ್ಯೆಯು ಕ್ಷೇತ್ರದ ಗಾತ್ರವನ್ನು ಮೀರಿದರೆ, ನಾವು ಅದನ್ನು ಘಟಕವಿಲ್ಲದ ಕೋಶಗಳ ಸಂಖ್ಯೆಗೆ ಮಿತಿಗೊಳಿಸುತ್ತೇವೆ. ಆದಾಗ್ಯೂ, ಅಂತಹ ಆಟವು ಹೆಚ್ಚು ಅರ್ಥವಿಲ್ಲ ಮತ್ತು ಒಂದು ಹಂತದಲ್ಲಿ ಪೂರ್ಣಗೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಅಂತಹ ಸಂದರ್ಭದಲ್ಲಿ ನಿಮ್ಮದೇ ಆದ ಕೆಲವು ನಿಯಮಗಳೊಂದಿಗೆ ಬರಬಹುದು.

ಸೆಲ್‌ಟೇಬಲ್ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿನ ಕೋಶಗಳ ಪಟ್ಟಿಗಳ ಪಟ್ಟಿಯಂತೆ ಆಟದ ಮೈದಾನವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ. ಇದಲ್ಲದೆ, ಸ್ಟಾರ್ಟ್‌ಗೇಮ್ () ವಿಧಾನದಲ್ಲಿ, ಕೋಶಗಳ ಸ್ಥಾನ ಮೌಲ್ಯವನ್ನು ಮಾತ್ರ ಹೊಂದಿಸಲಾಗಿದೆ, ಆದರೆ ಗಣಿಗಳನ್ನು ಇನ್ನೂ ಇರಿಸಲಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಆದರೆ ಮೊದಲ ಹಂತದ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನಿಜವಾದ ಮೌಲ್ಯದೊಂದಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಮೊದಲ ನಡೆಯಿಂದ ಅವಕಾಶದ ಅಂಶವನ್ನು ತೆಗೆದುಹಾಕಲು ಮತ್ತು ತ್ವರಿತ ನಷ್ಟವನ್ನು ತಡೆಗಟ್ಟಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ. ಉಳಿದ ಕೋಶಗಳಲ್ಲಿ ಮೊದಲ ಚಲನೆಯ ನಂತರ ಗಣಿಗಳನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ.

ಗೆಟ್‌ಸೆಲ್ () ವಿಧಾನವು ಆಟದ ಮೈದಾನದ ಕೋಶವನ್ನು ಸಾಲು ಸಾಲು ಮತ್ತು ಕಾಲಮ್ ಕಾಲಮ್ ಮೂಲಕ ಸರಳವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸಾಲು ಅಥವಾ ಕಾಲಮ್ ಮೌಲ್ಯವು ಅಮಾನ್ಯವಾಗಿದ್ದರೆ, ಯಾವುದನ್ನೂ ಹಿಂತಿರುಗಿಸಲಾಗುವುದಿಲ್ಲ.

isWin() ವಿಧಾನವು ಆಟದ ಮೈದಾನದಲ್ಲಿ ಉಳಿದಿರುವ ಎಲ್ಲಾ ತೆರೆಯದ ಕೋಶಗಳನ್ನು ಗಣಿಗಾರಿಕೆ ಮಾಡಿದರೆ ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಂದರೆ, ವಿಜಯದ ಸಂದರ್ಭದಲ್ಲಿ, ಇಲ್ಲದಿದ್ದರೆ ಅದು ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. isGameOver() ವಿಧಾನವು ಗೇಮ್‌ಓವರ್ ವರ್ಗ ಗುಣಲಕ್ಷಣದ ಮೌಲ್ಯವನ್ನು ಸರಳವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಓಪನ್ ಸೆಲ್ () ವಿಧಾನವು ಆಟದ ಸೆಲ್ ವಸ್ತುವಿಗೆ ಮುಕ್ತ () ಕರೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇದು ವಿಧಾನದ ನಿಯತಾಂಕಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸ್ಥಾನದಲ್ಲಿ ಆಟದ ಮೈದಾನದಲ್ಲಿದೆ. ತೆರೆದ ಕೋಶವು ಗಣಿಗಾರಿಕೆಗೆ ತಿರುಗಿದರೆ, ನಾವು ಗೇಮ್‌ಓವರ್ ಮೌಲ್ಯವನ್ನು ಸರಿ ಎಂದು ಹೊಂದಿಸುತ್ತೇವೆ ಮತ್ತು ವಿಧಾನದಿಂದ ನಿರ್ಗಮಿಸುತ್ತೇವೆ. ಆಟವು ಇನ್ನೂ ಮುಗಿದಿಲ್ಲದಿದ್ದರೆ, ಮೊದಲ ಹಂತದ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಇದು ಮೊದಲ ಹೆಜ್ಜೆಯೇ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಇದು ನಿಜವಾಗಿಯೂ ಮೊದಲ ಹೆಜ್ಜೆಯಾಗಿದ್ದರೆ, GenerateMines () ಸಹಾಯಕ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಗಣಿಗಳನ್ನು ಆಟದ ಮೈದಾನದಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಅದನ್ನು ನಾವು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ಮಾತನಾಡುತ್ತೇವೆ. ಮುಂದೆ, ನಾವು ಗಣಿಗಾರಿಕೆ ಮಾಡಿದ ನೆರೆಯ ಕೋಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುತ್ತೇವೆ ಮತ್ತು ಕೋಶವನ್ನು ಸಂಸ್ಕರಿಸುವ ಕೌಂಟರ್ ಗುಣಲಕ್ಷಣದ ಅನುಗುಣವಾದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ. ಕೌಂಟರ್ ಶೂನ್ಯವಾಗಿದ್ದರೆ, ನಾವು getCellNeighbours() ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ನೆರೆಯ ಸೆಲ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ವಿನಂತಿಸುತ್ತೇವೆ ಮತ್ತು ಎಲ್ಲಾ ಮುಚ್ಚಿದ "ನೆರೆಹೊರೆಯವರಿಗಾಗಿ" ತೆರೆದ ಸೆಲ್ () ವಿಧಾನವನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಕರೆಯುತ್ತೇವೆ, ಅಂದರೆ, "ಮುಚ್ಚಿದ" ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿರುವ ಕೋಶಗಳಿಗೆ.

ಮುಂದಿನ ಸೆಲ್‌ಮಾರ್ಕ್ () ವಿಧಾನವು ಪಾಸ್‌ನಲ್ಲಿರುವ ಸೆಲ್‌ಗಾಗಿ ಮುಂದಿನ ಮಾರ್ಕ್ () ವಿಧಾನಕ್ಕೆ ಕರೆಯನ್ನು ಸರಳವಾಗಿ ನಿಯೋಜಿಸುತ್ತದೆ.

ಗಣಿಗಳ ನಿಯೋಜನೆಯು GenerateMines() ವಿಧಾನದಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ. ಇಲ್ಲಿ ನಾವು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಮೈದಾನದೊಳಕ್ಕೆ ಒಂದು ಸ್ಥಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಈ ಸ್ಥಾನದಲ್ಲಿರುವ ಕೋಶವು ತೆರೆದಿಲ್ಲ ಮತ್ತು ಈಗಾಗಲೇ ಗಣಿಗಾರಿಕೆ ಮಾಡಲಾಗಿಲ್ಲ ಎಂದು ಪರಿಶೀಲಿಸಿ. ಎರಡೂ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಿದರೆ, ನಾವು ಗಣಿಗಾರಿಕೆ ಮಾಡಿದ ಗುಣಲಕ್ಷಣದ ಮೌಲ್ಯವನ್ನು ಸರಿ ಎಂದು ಹೊಂದಿಸುತ್ತೇವೆ, ಇಲ್ಲದಿದ್ದರೆ ನಾವು ಇನ್ನೊಂದು ಉಚಿತ ಸೆಲ್‌ಗಾಗಿ ಹುಡುಕುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತೇವೆ. ಪೈಥಾನ್‌ನಲ್ಲಿ ಯಾದೃಚ್ಛಿಕ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಲು, ನೀವು ಅದನ್ನು ಆಮದು ಯಾದೃಚ್ಛಿಕ ಆಜ್ಞೆಯೊಂದಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಬೇಕು ಎಂಬುದನ್ನು ಮರೆಯಬೇಡಿ.

ಆಟದ ಮೈದಾನದ ನಿರ್ದಿಷ್ಟ ಕೋಶದ ಸುತ್ತಲಿನ ಗಣಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ ಕೌಂಟ್‌ಮೈನ್ಸ್‌ಅರೌಂಡ್‌ಸೆಲ್ () ವಿಧಾನವು ಸಂಪೂರ್ಣವಾಗಿ getCellNeighbours() ವಿಧಾನವನ್ನು ಆಧರಿಸಿದೆ. getCellNeighbours() ವಿಧಾನದಲ್ಲಿ ಸೆಲ್‌ನ "ನೆರೆಹೊರೆಯವರ" ವಿನಂತಿಯನ್ನು ಸಹ ಅತ್ಯಂತ ಸರಳವಾಗಿ ಅಳವಡಿಸಲಾಗಿದೆ. ಇದರಲ್ಲಿ ನಿಮಗೆ ಯಾವುದೇ ತೊಂದರೆಗಳು ಉಂಟಾಗುವುದಿಲ್ಲ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

ಮೈನ್ಸ್ವೀಪರ್ ವ್ಯೂ

ಈಗ ಪ್ರದರ್ಶನಕ್ಕೆ ಬರೋಣ. MinesweeperView ವರ್ಗದ ಪೈಥಾನ್ ಕೋಡ್ ಕೆಳಗಿದೆ:

ವರ್ಗ ಮೈನ್ಸ್ವೀಪರ್ ವ್ಯೂ(ಫ್ರೇಮ್): ಡೆಫ್ __init__(ಸ್ವಯಂ, ಮಾದರಿ, ನಿಯಂತ್ರಕ, ಪೋಷಕ = ಯಾವುದೂ ಇಲ್ಲ): ಫ್ರೇಮ್.__init__(ಸ್ವಯಂ, ಪೋಷಕ) self.model = ಮಾದರಿ self.controller = ನಿಯಂತ್ರಕ self.controller.setView(self) self.createBoard( ) ಫಲಕ = ಫ್ರೇಮ್(ಸ್ವಯಂ) ಪ್ಯಾನೆಲ್.ಪ್ಯಾಕ್(ಸೈಡ್ = ಬಾಟಮ್, ಫಿಲ್ = ಎಕ್ಸ್) ಬಟನ್(ಪ್ಯಾನಲ್, ಟೆಕ್ಸ್ಟ್ = "ಹೊಸ ಆಟ", ಕಮಾಂಡ್ = self.controller.startNewGame).pack(side = RIGHT) self.mineCount = StringVar (ಪ್ಯಾನೆಲ್) self.mineCount.set(self.model.mineCount) ಸ್ಪಿನ್‌ಬಾಕ್ಸ್(ಪ್ಯಾನೆಲ್, ಇಂದ_ = MIN_MINE_COUNT, to = MAX_MINE_COUNT, textvariable = self.mineCount, width = 5).pack(side = RIGHT) Label(panel, text = "ನಿಮಿಷಗಳ ಸಂಖ್ಯೆ: ").pack(side = RIGHT) self.rowCount = StringVar(panel) self.rowCount.set(self.model.rowCount) ಸ್ಪಿನ್‌ಬಾಕ್ಸ್(ಪ್ಯಾನೆಲ್, ಇಂದ_ = MIN_ROW_COUNT, to = MAX_ROW_COUNT, textvariable = self. rowCount , width = 5).pack(side = RIGHT) ಲೇಬಲ್(ಫಲಕ, ಪಠ್ಯ = " x ").pack(side = RIGHT) self.columnCount = StringVar(panel) self.columnCount.set(self.model.columnCount) ಸ್ಪಿನ್‌ಬಾಕ್ಸ್ (ಪ್ಯಾನಲ್, ಇಂದ_ = MIN_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.model.rowCount): ಶ್ರೇಣಿಯಲ್ಲಿರುವ ಕಾಲಮ್‌ಗಾಗಿ(self.model.columnCount): ಸೆಲ್ = self.model.getCell(ಸಾಲು, ಕಾಲಮ್) ಕೋಶವಾಗಿದ್ದರೆ: btn = self.buttonsTable[ ಸಾಲು ] [ ಕಾಲಮ್ ] self.model.isGameOver() ಮತ್ತು ಸೆಲ್ ) elif ಸೆಲ್ bg = "ಕೆಂಪು") elif cell.state == "ಫ್ಲ್ಯಾಗ್ಡ್": btn.config(ಪಠ್ಯ = "P") elif cell.state == "ಪ್ರಶ್ನಿಸಲಾಗಿದೆ": btn.config(text = "?") def blockCell(self , ಸಾಲು, ಕಾಲಮ್, ಬ್ಲಾಕ್ = ನಿಜ): btn = self.buttonsTable[ row ][ column ] btn ಅಲ್ಲದಿದ್ದರೆ: ಬ್ಲಾಕ್ ಆಗಿದ್ದರೆ ಹಿಂತಿರುಗಿ: btn.bind(" ", "ಬ್ರೇಕ್") else: btn.unbind(" ") def getGameSettings(self): return self.rowCount.get(), self.columnCount.get(), self.mineCount.get() def createBoard(self): ಪ್ರಯತ್ನಿಸಿ: self.board.pack_forget() self.board .destroy() self.rowCount.set(self.model.rowCount) self.columnCount.set(self.model.columnCount) self.mineCount.set(self.model.mineCount) ಹೊರತುಪಡಿಸಿ: pass self.board = Frame(self) ) self.board.pack() self.buttonsTable = ಶ್ರೇಣಿಯಲ್ಲಿನ ಸಾಲಿಗೆ(self.model.rowCount): line = Frame(self.board) line.pack(side = TOP) self.buttonsRow = ಶ್ರೇಣಿಯಲ್ಲಿನ ಕಾಲಮ್‌ಗಾಗಿ(ಸ್ವಯಂ .model.columnCount): btn = ಬಟನ್ (ರೇಖೆ, ಅಗಲ = 2, ಎತ್ತರ = 1, ಆಜ್ಞೆ = ಲ್ಯಾಂಬ್ಡಾ ಸಾಲು = ಸಾಲು, ಕಾಲಮ್ = ಕಾಲಮ್: self.controller.onLeftClick (ಸಾಲು, ಕಾಲಮ್), padx = 0, pady = 0) btn.pack(side = LEFT) btn.bind(" ", ಲ್ಯಾಂಬ್ಡಾ ಇ, ಸಾಲು = ಸಾಲು, ಕಾಲಮ್ = ಕಾಲಮ್: self.controller.onRightClick(ಸಾಲು, ಕಾಲಮ್)) self.buttonsRow.append(btn) self.buttonsTable.append(self.buttonsRow) def showWinMessage(self): showinfo( "ಅಭಿನಂದನೆಗಳು!", "ನೀವು ಗೆಲ್ಲುತ್ತೀರಿ!") def showGameOverMessage(self): showinfo("ಆಟ ಮುಗಿದಿದೆ!", "ನೀವು ಕಳೆದುಕೊಳ್ಳುತ್ತೀರಿ!")

ನಮ್ಮ ವೀಕ್ಷಣೆಯು tkinter ಮಾಡ್ಯೂಲ್‌ನಿಂದ ಫ್ರೇಮ್ ವರ್ಗವನ್ನು ಆಧರಿಸಿದೆ, ಆದ್ದರಿಂದ ಸೂಕ್ತವಾದ ಆಮದು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಲು ಮರೆಯದಿರಿ: tkinter import * ನಿಂದ. ವರ್ಗ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಮಾದರಿ ಮತ್ತು ನಿಯಂತ್ರಕವನ್ನು ಹಾದುಹೋಗುತ್ತದೆ. ಕೋಶಗಳಿಂದ ಆಟದ ಮೈದಾನವನ್ನು ಹಾಕಲು createBoard () ವಿಧಾನವನ್ನು ತಕ್ಷಣವೇ ಕರೆಯಲಾಗುತ್ತದೆ. ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ನಾವು ಸಾಮಾನ್ಯ ಬಟನ್ ಬಟನ್ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ ಎಂದು ನಾನು ಮುಂಚಿತವಾಗಿ ಹೇಳುತ್ತೇನೆ. ನಂತರ ಒಂದು ಚೌಕಟ್ಟನ್ನು ರಚಿಸಲಾಗಿದೆ, ಇದು ಆಟದ ನಿಯತಾಂಕಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಕೆಳಗಿನ ಫಲಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ಪ್ಯಾನೆಲ್‌ನಲ್ಲಿ ನಾವು ಅನುಕ್ರಮವಾಗಿ "ಹೊಸ ಆಟ" ಬಟನ್ ಅನ್ನು ಇರಿಸುತ್ತೇವೆ, ಅದರ ಹ್ಯಾಂಡ್ಲರ್ ಅದರ ಸ್ಟಾರ್ಟ್‌ನ್ಯೂಗೇಮ್ () ವಿಧಾನದೊಂದಿಗೆ ನಮ್ಮ ನಿಯಂತ್ರಕವಾಗಿದೆ ಮತ್ತು ನಂತರ ಮೂರು ಸ್ಪಿನ್‌ಬಾಕ್ಸ್ ಕೌಂಟರ್‌ಗಳನ್ನು ಆಟಗಾರನು ಆಟದ ಮೈದಾನದ ಗಾತ್ರ ಮತ್ತು ಗಣಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

syncWithModel() ವಿಧಾನವು ಪ್ರತಿ ಆಟದ ಕೋಶದ ಮೂಲಕ ಎರಡು ಬಾರಿ ಲೂಪ್ ಆಗುತ್ತದೆ ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ನಮ್ಮ GUI ನಲ್ಲಿ ಅದನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಬಟನ್‌ನ ನೋಟವನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ. ಸರಳತೆಗಾಗಿ, ನಾನು ಚಿಹ್ನೆಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಪಠ್ಯ ಚಿಹ್ನೆಗಳನ್ನು ಬಳಸಿದ್ದೇನೆ, ಆದರೆ ಪಠ್ಯವನ್ನು ಬಾಹ್ಯ ಗ್ರಾಫಿಕ್ಸ್ ಫೈಲ್‌ಗಳಿಂದ ಗ್ರಾಫಿಕ್ಸ್‌ಗೆ ಬದಲಾಯಿಸುವುದು ಕಷ್ಟವೇನಲ್ಲ.

ಅಲ್ಲದೆ, ತೆರೆದ ಕೋಶವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ನಾವು SUNKEN ಬಟನ್ ಶೈಲಿಯನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಮತ್ತು ನಷ್ಟದ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಆಟದ ಮೈದಾನದಲ್ಲಿರುವ ಎಲ್ಲಾ ಗಣಿಗಳ ಸ್ಥಳವನ್ನು ತೆರೆಯುತ್ತೇವೆ, ಅನುಗುಣವಾದ ಗುಂಡಿಗಳನ್ನು ಕಪ್ಪು ಬಣ್ಣದಲ್ಲಿ ತೋರಿಸುತ್ತೇವೆ ಮತ್ತು ಕೆಂಪು ಬಣ್ಣದಲ್ಲಿ ಗಣಿಯೊಂದಿಗೆ ಕೊನೆಯ ತೆರೆದ ಕೋಶಕ್ಕೆ ಅನುಗುಣವಾದ ಗುಂಡಿಯನ್ನು ಹೈಲೈಟ್ ಮಾಡುತ್ತೇವೆ:

ಕೆಳಗಿನ blockCell() ವಿಧಾನವು ಪೋಷಕ ಪಾತ್ರವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ನಿಯಂತ್ರಕವು ಬಟನ್‌ಗಳ ನಿರ್ಬಂಧಿಸುವ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಫ್ಲ್ಯಾಗ್ ಮಾಡಲಾದ ಆಟದ ಕೋಶಗಳನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ತೆರೆಯುವುದನ್ನು ತಡೆಯುವುದು ಮತ್ತು ಖಾಲಿ ಎಡ-ಕ್ಲಿಕ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ ಇದನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ.

getGameSettings() ವಿಧಾನವು ಆಟದ ಮೈದಾನದ ಗಾತ್ರ ಮತ್ತು ಗಣಿಗಳ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಕೆಳಗಿನ ಫಲಕದಲ್ಲಿರುವ ಕೌಂಟರ್‌ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಸರಳವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಆಟದ ಮೈದಾನದ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ರಚಿಸುವುದು createBoard () ವಿಧಾನದಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ. ಮೊದಲನೆಯದಾಗಿ, ಹಳೆಯ ಆಟದ ಮೈದಾನವು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೆ ಅದನ್ನು ಅಳಿಸಲು ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ ಮತ್ತು ಮಾದರಿಯ ಪ್ರಸ್ತುತ ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ ಅನುಗುಣವಾಗಿ ಫಲಕದಿಂದ ಕೌಂಟರ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಲು ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ. ನಂತರ ಹೊಸ ಚೌಕಟ್ಟನ್ನು ರಚಿಸಲಾಗಿದೆ, ಅದನ್ನು ನಾವು ಆಟದ ಮೈದಾನವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಬೋರ್ಡ್ ಎಂದು ಕರೆಯುತ್ತೇವೆ. ಡಬಲ್ ಲೂಪ್ ಬಳಸಿ ಮಾದರಿಯಲ್ಲಿನ ಆಟದ ಕೋಶಗಳಂತೆಯೇ ನಾವು ಬಟನ್‌ಟೇಬಲ್‌ನ ಟೇಬಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ. ಪ್ರತಿ ಬಟನ್‌ನ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು ಕ್ರಮವಾಗಿ ಎಡ ಮತ್ತು ಬಲ ಮೌಸ್ ಬಟನ್‌ಗಳನ್ನು ಕ್ಲಿಕ್ ಮಾಡಲು ನಿಯಂತ್ರಕದ onLeftClick() ಮತ್ತು onRightClick() ವಿಧಾನಗಳಿಗೆ ಬದ್ಧವಾಗಿರುತ್ತವೆ.

ಕೊನೆಯ ಎರಡು ವಿಧಾನಗಳು ShowWinMessage() ಮತ್ತು showGameOverMessage() ಕೇವಲ showinfo() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಅನುಗುಣವಾದ ಸಂದೇಶಗಳೊಂದಿಗೆ ಸಂವಾದ ಪೆಟ್ಟಿಗೆಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತವೆ. ಇದನ್ನು ಬಳಸಲು, ನೀವು ಇನ್ನೂ ಒಂದು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಬೇಕು: tkinter.messagebox ಇಂಪೋರ್ಟ್ * .

ನಿಯಂತ್ರಕ ಮೈನ್ಸ್ವೀಪರ್ ಕಂಟ್ರೋಲರ್

ಈಗ ನಾವು ನಿಯಂತ್ರಕದ ಅನುಷ್ಠಾನಕ್ಕೆ ಬಂದಿದ್ದೇವೆ:

ವರ್ಗ ಮೈನ್‌ಸ್ವೀಪರ್ ಕಂಟ್ರೋಲರ್: ಡೆಫ್ __init__(ಸ್ವಯಂ, ಮಾದರಿ): self.model = ಮಾದರಿ ಡೆಫ್ ಸೆಟ್‌ವೀವ್ (ಸ್ವಯಂ, ವೀಕ್ಷಣೆ): self.view = ವೀಕ್ಷಿಸಿ ಡೆಫ್ startNewGame(self): gameSettings = self.view.getGameSettings() ಪ್ರಯತ್ನಿಸಿ: self.model. startGame(*map(int, gamesettings)) ಹೊರತುಪಡಿಸಿ: 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.model.nextCellMark(ಸಾಲು, ಕಾಲಮ್) self.view.blockCell(ಸಾಲು, ಕಾಲಮ್, self.model.getCell(ಸಾಲು, ಕಾಲಮ್).ರಾಜ್ಯ == "ಫ್ಲ್ಯಾಗ್ಡ್") self.view.syncWithModel()

ವೀಕ್ಷಣೆಯನ್ನು ನಿಯಂತ್ರಕಕ್ಕೆ ಬಂಧಿಸಲು, ನಾವು setView() ವಿಧಾನವನ್ನು ಸೇರಿಸಿದ್ದೇವೆ. ಏಕೆಂದರೆ ನಾವು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ವೀಕ್ಷಣೆಯನ್ನು ರವಾನಿಸಲು ಬಯಸಿದರೆ, ನಿಯಂತ್ರಕವನ್ನು ರಚಿಸುವ ಮೊದಲು ಈ ವೀಕ್ಷಣೆಯು ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿರಬೇಕು. ತದನಂತರ ಬೈಂಡಿಂಗ್‌ಗಾಗಿ ಹೆಚ್ಚುವರಿ ವಿಧಾನದೊಂದಿಗೆ ಇದೇ ರೀತಿಯ ಪರಿಹಾರವು ನಿಯಂತ್ರಕದಿಂದ ವೀಕ್ಷಣೆಗೆ ಸರಳವಾಗಿ ಚಲಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ ಸೆಟ್ ಕಂಟ್ರೋಲರ್ () ವಿಧಾನವು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ಹೊಸ ಗೇಮ್ ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡುವ ಹ್ಯಾಂಡ್ಲರ್ ವಿಧಾನ, startNewGame(), ಮೊದಲು ವೀಕ್ಷಣೆಯಲ್ಲಿ ನಮೂದಿಸಲಾದ ಆಟದ ನಿಯತಾಂಕಗಳನ್ನು ವಿನಂತಿಸುತ್ತದೆ. ಆಟದ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಮೂರು ಘಟಕಗಳ ಟ್ಯೂಪಲ್ ಆಗಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ, ಅದನ್ನು ನಾವು ಇಂಟ್‌ಗೆ ಪರಿವರ್ತಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದೇವೆ. ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ನಡೆದರೆ, ಆಟದ ಮೈದಾನವನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ಈ ಮೌಲ್ಯಗಳನ್ನು ಮಾದರಿಯ ಸ್ಟಾರ್ಟ್‌ಗೇಮ್ () ವಿಧಾನಕ್ಕೆ ರವಾನಿಸುತ್ತೇವೆ. ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ, ನಾವು ಹಳೆಯ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಆಟದ ಮೈದಾನವನ್ನು ಸರಳವಾಗಿ ಮರುಸೃಷ್ಟಿಸುತ್ತೇವೆ. ಅಂತಿಮವಾಗಿ, createBoard() ವಿಧಾನವನ್ನು ಕರೆಯುವ ಮೂಲಕ ವೀಕ್ಷಣೆಯಲ್ಲಿ ಗೇಮ್ ಬೋರ್ಡ್‌ನ ಹೊಸ ಪ್ರದರ್ಶನವನ್ನು ರಚಿಸಲು ನಾವು ವಿನಂತಿಯನ್ನು ಮಾಡುತ್ತೇವೆ.

onLeftClick() ಹ್ಯಾಂಡ್ಲರ್ ಮೊದಲು ಆಟಗಾರನ ಆಯ್ಕೆಯ ಸ್ಥಾನದಲ್ಲಿ ಆಟದ ಕೋಶವನ್ನು ತೆರೆಯಲು ಮಾದರಿಗೆ ಹೇಳುತ್ತದೆ. ನಂತರ ಅದು ಮಾದರಿಯ ಸ್ಥಿತಿ ಬದಲಾಗಿದೆ ಎಂದು ವೀಕ್ಷಣೆಗೆ ತಿಳಿಸುತ್ತದೆ ಮತ್ತು ಎಲ್ಲವನ್ನೂ ಮತ್ತೆ ಸೆಳೆಯಲು ನೀಡುತ್ತದೆ. ನಂತರ ಮಾದರಿಯನ್ನು ಗೆಲುವು ಅಥವಾ ನಷ್ಟಕ್ಕಾಗಿ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ. ಇದರಲ್ಲಿ ಯಾವುದಾದರೂ ಸಂಭವಿಸಿದಲ್ಲಿ, ಸೂಕ್ತವಾದ ಅಧಿಸೂಚನೆಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ಮೊದಲು ವೀಕ್ಷಣೆಗೆ ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಹೊಸ ಆಟವನ್ನು ಪ್ರಾರಂಭಿಸಲು startNewGame() ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.

ಬಲ ಕ್ಲಿಕ್ ಅನ್ನು onRightClick() ವಿಧಾನದಲ್ಲಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. ಆಯ್ಕೆ ಮಾಡಿದ ಆಟದ ಕೋಶದ ಗುರುತುಗಳನ್ನು ಆವರ್ತಕವಾಗಿ ಬದಲಾಯಿಸಲು ಮೊದಲ ಸಾಲು ಮಾದರಿಯ ಮುಂದಿನ ಸೆಲ್‌ಮಾರ್ಕ್ () ವಿಧಾನವನ್ನು ಕರೆಯುತ್ತದೆ. ಸೆಲ್‌ನ ಹೊಸ ಸ್ಥಿತಿಯನ್ನು ಅವಲಂಬಿಸಿ, ಅನುಗುಣವಾದ ಬಟನ್‌ನಲ್ಲಿ ಲಾಕ್ ಅನ್ನು ಹೊಂದಿಸಲು ಅಥವಾ ತೆಗೆದುಹಾಕಲು ವೀಕ್ಷಣೆಗೆ ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಮತ್ತು ಕೊನೆಯಲ್ಲಿ, ಮಾದರಿಯ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ವೀಕ್ಷಣೆಯನ್ನು ಮತ್ತೊಮ್ಮೆ ನವೀಕರಿಸಲಾಗುತ್ತದೆ.

ಮಾದರಿ, ವೀಕ್ಷಣೆ ಮತ್ತು ನಿಯಂತ್ರಕವನ್ನು ಸಂಯೋಜಿಸುವುದು

MVC ಮಾದರಿಯ ಆಧಾರದ ಮೇಲೆ ನಮ್ಮ ಮೈನ್‌ಸ್ವೀಪರ್‌ನ ಅನುಷ್ಠಾನದಲ್ಲಿನ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಸಂಪರ್ಕಿಸಲು ಮತ್ತು ಆಟವನ್ನು ಪ್ರಾರಂಭಿಸಲು ಈಗ ಉಳಿದಿದೆ:

ಮಾದರಿ = ಮೈನ್ಸ್ವೀಪರ್ ಮಾಡೆಲ್ () ನಿಯಂತ್ರಕ = ಮೈನ್ಸ್ವೀಪರ್ ಕಂಟ್ರೋಲರ್ (ಮಾದರಿ); ವೀಕ್ಷಿಸಿ = ಮೈನ್‌ಸ್ವೀಪರ್ ವ್ಯೂ(ಮಾದರಿ, ನಿಯಂತ್ರಕ) view.pack() view.mainloop()

ತೀರ್ಮಾನ

ಆದ್ದರಿಂದ ನಾವು MVC ಮಾದರಿಯನ್ನು ನೋಡಿದ್ದೇವೆ. ಸಿದ್ಧಾಂತದ ಮೂಲಕ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೋಗೋಣ. ತದನಂತರ ನಾವು ಪೂರ್ಣ ಪ್ರಮಾಣದ ಗೇಮಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹಂತ ಹಂತವಾಗಿ ರಚಿಸಿದ್ದೇವೆ, ಸಮಸ್ಯೆ ಹೇಳಿಕೆ ಮತ್ತು ಆರ್ಕಿಟೆಕ್ಚರ್ ವಿನ್ಯಾಸದಿಂದ tkinter ಗ್ರಾಫಿಕಲ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ಅನುಷ್ಠಾನಕ್ಕೆ ಹೋಗುತ್ತೇವೆ.

ಒಳ್ಳೆಯದು, ಮೊದಲನೆಯದಾಗಿ, ಇದು ಒಂದು ಮಾದರಿ ಅಥವಾ ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಇಂಟರ್ನೆಟ್‌ನಲ್ಲಿ ವೆಬ್‌ಸೈಟ್‌ಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ವಿಧಾನ, ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿರುವ ವ್ಯವಸ್ಥೆಗಳ ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸಲು ಮತ್ತು ಸುರಕ್ಷತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು MVC ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಮತ್ತು ಹ್ಯಾಕಿಂಗ್ಗೆ ಪ್ರತಿರೋಧ.

MVC ಎಂದರೆ ಮಾದರಿ-ವೀಕ್ಷಿಸಿ-ನಿಯಂತ್ರಕಮತ್ತು ಅಕ್ಷರಶಃ ಅನುವಾದಿಸಬಹುದು ಮಾದರಿ-ವೀಕ್ಷಣೆ-ನಿಯಂತ್ರಕ.

ಅಭಿವೃದ್ಧಿ ಮಾದರಿಯು ಹೊಸದಾಗಿ ತೋರುತ್ತದೆ ಎಂಬ ವಾಸ್ತವದ ಹೊರತಾಗಿಯೂ, ಇದು ದೀರ್ಘಕಾಲದವರೆಗೆ ಸ್ವತಃ ಸಾಬೀತಾಗಿದೆ ಮತ್ತು ವೆಬ್‌ಸೈಟ್‌ಗಳ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲ್ಪಡುತ್ತದೆ. MVC ಪರಿಕಲ್ಪನೆಯನ್ನು ಮೊದಲು 1979 ರಲ್ಲಿ ಟ್ರೈಗ್ವ್ ರೀನ್ಸ್‌ಕಾಗ್ ವಿವರಿಸಿದರು.

MVC ಪರಿಕಲ್ಪನೆ ಅಥವಾ ಅದು ಏನು ಒಳಗೊಂಡಿದೆ

MVC ಮಾದರಿಮೂರು ಘಟಕಗಳನ್ನು ಒಳಗೊಂಡಿದೆ: ಮಾದರಿ, ವೀಕ್ಷಣೆ ಮತ್ತು ನಿಯಂತ್ರಕ.

ಇಲ್ಲಿ ಪ್ರಮುಖ ವಿಷಯವೆಂದರೆ, ಸಹಜವಾಗಿ, ಮಾದರಿ. ಮಾದರಿಯು ಡೇಟಾ ಸಂಸ್ಕರಣೆಗಾಗಿ ಕಾರ್ಯವಿಧಾನಗಳು ಮತ್ತು ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಒಂದು ಗುಂಪಾಗಿದೆ. ಮಾದರಿಯು ಸ್ವತಃ ಡೇಟಾವನ್ನು ಹೊಂದಿಲ್ಲ, ಆದರೆ ನಿಯಮದಂತೆ, ಇದು ಡೇಟಾಬೇಸ್ನಿಂದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಪೂರ್ವ-ನಿರ್ಧರಿತ ಅಲ್ಗಾರಿದಮ್ಗಳ ಪ್ರಕಾರ ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. ನಾವು ವೆಬ್ ಅಭಿವೃದ್ಧಿಯ ಬಗ್ಗೆ ಮಾತನಾಡಿದರೆ, ಮಾದರಿಯು ತರಗತಿಗಳು ಮತ್ತು ಕಾರ್ಯಗಳ ಗುಂಪನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಉದಾಹರಣೆಗೆ PHP ನಲ್ಲಿ.

ಎರಡನೆಯ ಅಂಶವೆಂದರೆ ವೀಕ್ಷಣೆ. ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ವೆಬ್‌ಸೈಟ್ ಆಗಿದ್ದರೆ, ಮಾಹಿತಿಯನ್ನು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ವೆಬ್‌ಸೈಟ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ಒಂದು ವೀಕ್ಷಣೆಯು HTML ಕೋಡ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಅದರಲ್ಲಿ ಅಸ್ಥಿರಗಳನ್ನು ಬದಲಿಸಲಾಗುತ್ತದೆ, ಅದನ್ನು ಮಾದರಿಯಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ನಿಯಂತ್ರಕದಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಮೂರನೇ ಅಂಶವೆಂದರೆ ನಿಯಂತ್ರಕ. ಬಳಕೆದಾರ ಮತ್ತು ಮಾದರಿಯ ನಡುವೆ ಸಂವಹನವನ್ನು ಒದಗಿಸುವುದು ಇದರ ಮುಖ್ಯ ಕಾರ್ಯವಾಗಿದೆ. PHP ಕೋಡ್ ಅನ್ನು ಸಹ ಹೊಂದಿರಬಹುದು.

ಅನೇಕ ಅನನುಭವಿ ಡೆವಲಪರ್‌ಗಳು ಮಾದರಿಯನ್ನು ಬಳಸುವುದಿಲ್ಲ ಅಥವಾ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಮಾತ್ರ ಬಳಸುವುದಿಲ್ಲ, ಇದು ಒಂದು ಪ್ರಮುಖ ತಪ್ಪು, ತಪ್ಪಾಗಿದೆ ಮತ್ತು MVC ಮಾದರಿಯ ತರ್ಕಕ್ಕೆ ವಿರುದ್ಧವಾಗಿದೆ. ಮತ್ತು ಎಲ್ಲಾ ಮುಖ್ಯ ಕೋಡ್ ಅನ್ನು ನಿಯಂತ್ರಕದಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ. ಇದರ ಪರಿಣಾಮಗಳು, ಮೊದಲನೆಯದಾಗಿ, ಒಂದು ದೊಡ್ಡ ಕೋಡ್, ಮತ್ತು ಎರಡನೆಯದಾಗಿ, ಅಪ್ಲಿಕೇಶನ್ನ ಕಡಿಮೆ ವೇಗ. ಒಳ್ಳೆಯದು, ಅಂತಹ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಕೋಡ್‌ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವುದು ಹೆಚ್ಚು ಕಷ್ಟ.

ಉದಾಹರಣೆಗೆ, ಸುದ್ದಿ ಸೈಟ್‌ಗಾಗಿ MVC ಮಾದರಿಯನ್ನು ಪರಿಗಣಿಸಿ

ಬಳಕೆದಾರರು ವೆಬ್‌ಸೈಟ್ ಪುಟದಲ್ಲಿ ಇಳಿಯುತ್ತಾರೆ. ಸುದ್ದಿಗಳ ನಿರ್ದಿಷ್ಟ ಪಟ್ಟಿಯೊಂದಿಗೆ ಅವನಿಗೆ ಡೀಫಾಲ್ಟ್ ಪುಟವನ್ನು ತೋರಿಸಲಾಗುತ್ತದೆ. ಸುದ್ದಿಯನ್ನು ಉತ್ಪಾದಿಸುವ ಮಾಹಿತಿಯನ್ನು ಡೇಟಾಬೇಸ್‌ನಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ.

ಬಳಕೆದಾರರು ಬ್ರೌಸರ್‌ನ ವಿಳಾಸ ಪಟ್ಟಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಪುಟವನ್ನು ಟೈಪ್ ಮಾಡಿದಾಗ, ವಿನಂತಿಯನ್ನು ನಿಯಂತ್ರಕಕ್ಕೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮತ್ತು ಮಾದರಿಯನ್ನು ಲೋಡ್ ಮಾಡುವ ಕಾರ್ಯವನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ.

ಮಾದರಿ, ಅಗತ್ಯ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಿದ ನಂತರ, ಈಗಾಗಲೇ ಸಂಸ್ಕರಿಸಿದ ಮತ್ತು ಆಬ್ಜೆಕ್ಟ್ ಅಥವಾ ಅರೇ ಆಗಿ ಗುಂಪು ಮಾಡಲಾಗಿದ್ದು, ಡೇಟಾಬೇಸ್‌ಗೆ ಪ್ರಶ್ನೆಯನ್ನು ರಚಿಸುತ್ತದೆ. ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಿದ ನಂತರ, ಮಾದರಿಯು ಅದನ್ನು ಒಂದು ನಿರ್ದಿಷ್ಟ ರೂಪದಲ್ಲಿ ರೂಪಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ನಿಯಂತ್ರಕಕ್ಕೆ ವರ್ಗಾಯಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಅದನ್ನು ವೀಕ್ಷಣೆಗೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ. ಡೇಟಾವನ್ನು ನೇರವಾಗಿ ವೀಕ್ಷಣೆಗೆ ರವಾನಿಸಿದರೆ ಅದು ದೋಷವಾಗುವುದಿಲ್ಲ. ಆದರೆ ಮತ್ತೆ, ಅನಗತ್ಯ ಕ್ರಿಯೆಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಅಂತಿಮವಾಗಿ ಸೈಟ್ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಹೆಚ್ಚಿನ ಲೋಡ್ ಸಮಯಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.

ವೀಕ್ಷಣೆ, ಸುದ್ದಿಯೊಂದಿಗೆ ರಚನೆ ಅಥವಾ ವಸ್ತುವನ್ನು ಸ್ವೀಕರಿಸಿದ ನಂತರ, ಅಗತ್ಯವಿದ್ದಲ್ಲಿ ಕೆಲವು HTML ಕೋಡ್, CSS ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಳಕೆದಾರರಿಗೆ ಎಲ್ಲವನ್ನೂ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಈ ಮಾದರಿಯನ್ನು ಅನೇಕ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಗಳು ಮತ್ತು ಚೌಕಟ್ಟುಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ, ಅವುಗಳಲ್ಲಿ ಒಂದು ಕೋಡ್ಇಗ್ನಿಟರ್, ಇದು ಇತ್ತೀಚೆಗೆ ಹೊಸ ಜೀವನವನ್ನು ಪಡೆದುಕೊಂಡಿದೆ.

ಹೀಗಾಗಿ, MVC ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ಸುಲಭವಾಗಿ ವೆಬ್ಸೈಟ್ ಅಥವಾ ಇಂಟರ್ನೆಟ್ ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ ಆಡಳಿತ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸಬಹುದು. ಆದ್ದರಿಂದ CodeIgniter ಫ್ರೇಮ್ವರ್ಕ್ ನಿಖರವಾಗಿ ಈ ಮಾದರಿಯನ್ನು ಬಳಸುತ್ತದೆ.

ಶುಭ ಮಧ್ಯಾಹ್ನ, ಆತ್ಮೀಯ ಸಹೋದ್ಯೋಗಿಗಳು. ಈ ಲೇಖನದಲ್ಲಿ ನಾನು MVC, MVP ಮತ್ತು MVVM ಮಾದರಿಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳ ಬಗ್ಗೆ ನನ್ನ ವಿಶ್ಲೇಷಣಾತ್ಮಕ ತಿಳುವಳಿಕೆಯನ್ನು ಕುರಿತು ಮಾತನಾಡಲು ಬಯಸುತ್ತೇನೆ. ದೊಡ್ಡ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಗೆ ಆಧುನಿಕ ವಿಧಾನಗಳು ಮತ್ತು ಅನುಗುಣವಾದ ವಾಸ್ತುಶಿಲ್ಪದ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಬಯಕೆಯಿಂದ ಈ ಲೇಖನವನ್ನು ಬರೆಯಲು ನಾನು ಪ್ರೇರೇಪಿಸಿದ್ದೇನೆ. ನನ್ನ ವೃತ್ತಿಜೀವನದ ಏಣಿಯ ಪ್ರಸ್ತುತ ಹಂತದಲ್ಲಿ, ನಾನು ನೇರ ಡೆವಲಪರ್ ಅಲ್ಲ, ಆದ್ದರಿಂದ ಲೇಖನವು ದೋಷಗಳು, ತಪ್ಪುಗಳು ಮತ್ತು ತಪ್ಪುಗ್ರಹಿಕೆಯನ್ನು ಹೊಂದಿರಬಹುದು. ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಮತ್ತು ವಾಸ್ತುಶಿಲ್ಪಿಗಳು ಏನು ಮಾಡುತ್ತಿದ್ದಾರೆ ಎಂಬುದನ್ನು ವಿಶ್ಲೇಷಕರು ಹೇಗೆ ನೋಡುತ್ತಾರೆ ಎಂಬುದರ ಕುರಿತು ಆಸಕ್ತಿ ಇದೆಯೇ? ನಂತರ ಬೆಕ್ಕಿಗೆ ಸ್ವಾಗತ.

ಲಿಂಕ್‌ಗಳು

ಈ ಲೇಖನವನ್ನು ಬರೆಯುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನನಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡಿದ ಬಾಹ್ಯ ವಸ್ತುಗಳಿಗೆ ಲಿಂಕ್‌ಗಳೊಂದಿಗೆ ನಾನು ಪ್ರಾರಂಭಿಸಲು ಬಯಸುವ ಮೊದಲ ವಿಷಯ:

ಪರಿಚಯ

ಸೂರ್ಯನು ಪ್ರಕಾಶಮಾನವಾಗಿ ಬೆಳಗುತ್ತಿದ್ದಾಗ ಮತ್ತು ಹುಲ್ಲು ಹಸಿರಾಗಿರುವ ಸಮಯದಲ್ಲಿ, ಈ ಲೇಖನದ ಲೇಖಕರಂತಹ ವಿದ್ಯಾರ್ಥಿಗಳ ತಂಡವು ನೂರಾರು ಕೋಡ್‌ಗಳ ಸಾಲುಗಳನ್ನು ನೇರವಾಗಿ ಉತ್ಪನ್ನ ಇಂಟರ್ಫೇಸ್‌ಗೆ ಬರೆಯುವ ಮೂಲಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿತು. ಕೆಲವೊಮ್ಮೆ ಸೇವೆಗಳು ಮತ್ತು ನಿರ್ವಾಹಕರನ್ನು ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತಿತ್ತು ಮತ್ತು ನಂತರ ಡಾಕ್ಯುಮೆಂಟ್-ವೀಕ್ಷಣೆ ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಪರಿಹಾರವನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ. ಅಂತಹ ಕೋಡ್ ಅನ್ನು ಬೆಂಬಲಿಸಲು ಅಗಾಧವಾದ ವೆಚ್ಚಗಳು ಬೇಕಾಗುತ್ತವೆ, ಏಕೆಂದರೆ ಹೊಸ ಡೆವಲಪರ್‌ಗೆ ತರಬೇತಿ ನೀಡಬೇಕಾಗಿತ್ತು (ಹೇಳಬೇಕು) ಉತ್ಪನ್ನದಲ್ಲಿನ ಯಾವುದಕ್ಕೆ ಯಾವ ಕೋಡ್ ಕಾರಣವಾಗಿದೆ ಮತ್ತು ಯಾವುದೇ ಘಟಕ ಪರೀಕ್ಷೆಯ ಬಗ್ಗೆ ಯಾವುದೇ ಮಾತುಕತೆ ಇರಲಿಲ್ಲ. ಅಭಿವೃದ್ಧಿ ತಂಡವು ಒಂದು ಕೋಣೆಯಲ್ಲಿ ಕುಳಿತುಕೊಳ್ಳುವ 4 ಜನರು.
ಸಮಯ ಕಳೆದಿದೆ, ಕೆಲಸ ಬದಲಾಗಿದೆ. ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗುತ್ತಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ದೊಡ್ಡದಾಗಿ ಮತ್ತು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದವು ಮತ್ತು ಡೆವಲಪರ್‌ಗಳ ಒಂದು ಸುಸಂಘಟಿತ ತಂಡದಿಂದ ಡೆವಲಪರ್‌ಗಳು, ವಾಸ್ತುಶಿಲ್ಪಿಗಳು, ಉಪಯುಕ್ತತೆ ತಜ್ಞರು, ವಿನ್ಯಾಸಕರು ಮತ್ತು PM ಗಳ ವಿವಿಧ ತಂಡಗಳಾಗಿ ಮಾರ್ಪಟ್ಟವು. ಈಗ ಪ್ರತಿಯೊಬ್ಬರೂ ತಮ್ಮದೇ ಆದ ಪ್ರದೇಶಕ್ಕೆ ಜವಾಬ್ದಾರರಾಗಿರುತ್ತಾರೆ: GUI, ವ್ಯವಹಾರ ತರ್ಕ, ಘಟಕಗಳು. ವಿಶ್ಲೇಷಣೆ, ಪರೀಕ್ಷೆ ಮತ್ತು ವಾಸ್ತುಶಿಲ್ಪದ ವಿಭಾಗವು ಕಾಣಿಸಿಕೊಂಡಿತು. ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ವೆಚ್ಚವು ನೂರಾರು ಮತ್ತು ಸಾವಿರಾರು ಪಟ್ಟು ಹೆಚ್ಚಾಗಿದೆ. ಅಭಿವೃದ್ಧಿಯ ಈ ವಿಧಾನಕ್ಕೆ ಸ್ಥಿರವಾದ ವಾಸ್ತುಶಿಲ್ಪದ ಅಗತ್ಯವಿರುತ್ತದೆ ಅದು ಉತ್ಪನ್ನದ ವಿಭಿನ್ನ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರದೇಶಗಳನ್ನು ಪರಸ್ಪರ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುತ್ತದೆ.

ಪ್ಯಾಟರ್ನ್ಸ್

ಸಂಕೀರ್ಣ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಕಾರ್ಮಿಕ ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಗುರಿಯನ್ನು ನೀಡಿದರೆ, ಸಿದ್ಧ-ಸಿದ್ಧ ಏಕೀಕೃತ ಪರಿಹಾರಗಳನ್ನು ಬಳಸುವುದು ಅವಶ್ಯಕ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ. ಎಲ್ಲಾ ನಂತರ, ಟೆಂಪ್ಲೇಟ್ ಮಾಡಲಾದ ಕ್ರಮಗಳು ಡೆವಲಪರ್ಗಳ ನಡುವಿನ ಸಂವಹನವನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ, ತಿಳಿದಿರುವ ವಿನ್ಯಾಸಗಳನ್ನು ಉಲ್ಲೇಖಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತದೆ ಮತ್ತು ದೋಷಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ವಿಕಿಪೀಡಿಯಾದ ಪ್ರಕಾರ, ವಿನ್ಯಾಸ ಮಾದರಿಯು ಪುನರಾವರ್ತಿತ ವಾಸ್ತುಶಿಲ್ಪದ ವಿನ್ಯಾಸವಾಗಿದ್ದು ಅದು ಆಗಾಗ್ಗೆ ಸಂಭವಿಸುವ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ವಿನ್ಯಾಸ ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

ಮೊದಲ ಮುಖ್ಯ ವಿಷಯದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ - ಮಾದರಿ-ವೀಕ್ಷಣೆ-ನಿಯಂತ್ರಕ. MVC ಒಂದು ಮೂಲಭೂತ ಮಾದರಿಯಾಗಿದ್ದು ಅದು ಅನೇಕ ತಂತ್ರಜ್ಞಾನಗಳಲ್ಲಿ ತನ್ನ ದಾರಿಯನ್ನು ಕಂಡುಕೊಂಡಿದೆ, ಹೊಸ ತಂತ್ರಜ್ಞಾನಗಳನ್ನು ಹುಟ್ಟುಹಾಕಿದೆ ಮತ್ತು ಪ್ರತಿದಿನ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಜೀವನವನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.

MVC ಮಾದರಿಯು ಮೊದಲು ಸ್ಮಾಲ್‌ಟಾಕ್ ಭಾಷೆಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಂಡಿತು. ವ್ಯಾಪಾರ ತರ್ಕದಿಂದ ಚಿತ್ರಾತ್ಮಕ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಮತ್ತು ಡೇಟಾದಿಂದ ವ್ಯಾಪಾರ ತರ್ಕವನ್ನು ಪ್ರತ್ಯೇಕಿಸುವ ವಾಸ್ತುಶಿಲ್ಪದ ಪರಿಹಾರದೊಂದಿಗೆ ಡೆವಲಪರ್‌ಗಳು ಬರಬೇಕಾಗಿತ್ತು. ಹೀಗಾಗಿ, ಅದರ ಕ್ಲಾಸಿಕ್ ಆವೃತ್ತಿಯಲ್ಲಿ, MVC ಮೂರು ಭಾಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಅದು ಅದರ ಹೆಸರನ್ನು ನೀಡುತ್ತದೆ. ಅವುಗಳನ್ನು ನೋಡೋಣ:

ಮಾದರಿ

ಒಂದು ಮಾದರಿಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ನ ಕ್ರಿಯಾತ್ಮಕ ವ್ಯವಹಾರ ತರ್ಕವನ್ನು ಒಳಗೊಂಡಿರುವ ಭಾಗವಾಗಿ ಅರ್ಥೈಸಲಾಗುತ್ತದೆ. ಮಾದರಿಯು ಉಳಿದ ಉತ್ಪನ್ನದಿಂದ ಸಂಪೂರ್ಣವಾಗಿ ಸ್ವತಂತ್ರವಾಗಿರಬೇಕು. ವಿನ್ಯಾಸದ ಅಂಶಗಳ ಬಗ್ಗೆ ಅಥವಾ ಅದನ್ನು ಹೇಗೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ಮಾದರಿ ಪದರವು ಏನನ್ನೂ ತಿಳಿದುಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ. ಮಾದರಿಯನ್ನು ಸ್ಪರ್ಶಿಸದೆಯೇ ಡೇಟಾದ ಪ್ರಸ್ತುತಿಯನ್ನು ಬದಲಾಯಿಸಲು, ಅವುಗಳನ್ನು ಹೇಗೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಫಲಿತಾಂಶವನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ.

ಮಾದರಿಯು ಈ ಕೆಳಗಿನ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿದೆ:

• ಮಾದರಿಯು ಅಪ್ಲಿಕೇಶನ್‌ನ ವ್ಯವಹಾರ ತರ್ಕವಾಗಿದೆ;
• ಮಾದರಿಯು ತನ್ನ ಬಗ್ಗೆ ಜ್ಞಾನವನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ನಿಯಂತ್ರಕಗಳು ಮತ್ತು ವೀಕ್ಷಣೆಗಳ ಬಗ್ಗೆ ತಿಳಿದಿಲ್ಲ;
• ಕೆಲವು ಯೋಜನೆಗಳಿಗೆ, ಮಾದರಿಯು ಕೇವಲ ಡೇಟಾ ಲೇಯರ್ ಆಗಿದೆ (DAO, ಡೇಟಾಬೇಸ್, XML ಫೈಲ್);
• ಇತರ ಯೋಜನೆಗಳಿಗೆ, ಮಾದರಿಯು ಡೇಟಾಬೇಸ್ ಮ್ಯಾನೇಜರ್, ವಸ್ತುಗಳ ಒಂದು ಸೆಟ್ ಅಥವಾ ಸರಳವಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ತರ್ಕವಾಗಿದೆ;

ವೀಕ್ಷಿಸಿ

ವೀಕ್ಷಣೆಯ ಜವಾಬ್ದಾರಿಗಳು ಮಾದರಿಯಿಂದ ಸ್ವೀಕರಿಸಿದ ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನೋಟವು ಮಾದರಿಯ ಮೇಲೆ ನೇರವಾಗಿ ಪ್ರಭಾವ ಬೀರುವುದಿಲ್ಲ. ವೀಕ್ಷಣೆಯು ಡೇಟಾಗೆ ಓದಲು-ಮಾತ್ರ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದೆ ಎಂದು ನಾವು ಹೇಳಬಹುದು.

ಪ್ರಾತಿನಿಧ್ಯವು ಈ ಕೆಳಗಿನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ:

• ನೋಟವು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಮಾದರಿಯಿಂದ ಪಡೆದ ಡೇಟಾದ ಪ್ರದರ್ಶನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ;
• ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ವೀಕ್ಷಣೆಯು ಕೆಲವು ವ್ಯವಹಾರ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕೋಡ್ ಅನ್ನು ಹೊಂದಿರಬಹುದು.

ಪ್ರಸ್ತುತಿಯ ಉದಾಹರಣೆಗಳು: HTML ಪುಟ, WPF ಫಾರ್ಮ್, ವಿಂಡೋಸ್ ಫಾರ್ಮ್.

MVP ಮತ್ತು MVVM ಮತ್ತು MVP ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳು

MVC ಮಾದರಿಯ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ವಿಧಗಳು:

• ಮಾದರಿ-ವೀಕ್ಷಣೆ-ನಿಯಂತ್ರಕ
• ಮಾದರಿ-ವೀಕ್ಷಣೆ-ಪ್ರೆಸೆಂಟರ್
• ಮಾದರಿ-ವೀಕ್ಷಣೆ-ವೀಕ್ಷಣೆ ಮಾದರಿ

ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದನ್ನು ಪರಿಗಣಿಸಿ ಮತ್ತು ಹೋಲಿಕೆ ಮಾಡೋಣ.

ಮಾದರಿ-ವೀಕ್ಷಣೆ-ಪ್ರೆಸೆಂಟರ್

ಈ ವಿಧಾನವು ಪ್ರಾತಿನಿಧ್ಯ ಅಮೂರ್ತತೆಯನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ನೀವು ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳೊಂದಿಗೆ ವೀಕ್ಷಣೆ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಪ್ರೆಸೆಂಟರ್, ಪ್ರತಿಯಾಗಿ, ಇಂಟರ್ಫೇಸ್ ಅನುಷ್ಠಾನಕ್ಕೆ ಉಲ್ಲೇಖವನ್ನು ಪಡೆಯುತ್ತಾರೆ, ಪ್ರಸ್ತುತಿ ಘಟನೆಗಳಿಗೆ ಚಂದಾದಾರರಾಗುತ್ತಾರೆ ಮತ್ತು ವಿನಂತಿಯ ಮೇರೆಗೆ ಮಾದರಿಯನ್ನು ಮಾರ್ಪಡಿಸುತ್ತಾರೆ.

ಪ್ರೆಸೆಂಟರ್‌ನ ಚಿಹ್ನೆಗಳು:

• ಪ್ರೆಸೆಂಟರ್ ನಿದರ್ಶನದಲ್ಲಿ ಸೂಕ್ತವಾದ ಕಾರ್ಯಗಳು ಅಥವಾ ಈವೆಂಟ್‌ಗಳನ್ನು ಕರೆಯುವ ಮೂಲಕ ವೀಕ್ಷಣೆ ನೇರವಾಗಿ ನಿರೂಪಕರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ;
• ಪ್ರೆಸೆಂಟರ್ ವೀಕ್ಷಣೆಯಿಂದ ವಿಶೇಷ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ವೀಕ್ಷಣೆಯೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ;
• ಒಂದು ಪ್ರೆಸೆಂಟರ್ ನಿದರ್ಶನವನ್ನು ಒಂದು ಪ್ರದರ್ಶನದೊಂದಿಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ.

ಅನುಷ್ಠಾನ:
ಪ್ರತಿಯೊಂದು ವೀಕ್ಷಣೆಯು ಅನುಗುಣವಾದ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು. ಪ್ರಸ್ತುತಿ ಇಂಟರ್ಫೇಸ್ ಬಳಕೆದಾರರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಅಗತ್ಯವಿರುವ ಕಾರ್ಯಗಳು ಮತ್ತು ಘಟನೆಗಳ ಗುಂಪನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, IView.ShowErrorMessage(string msg)). ಪ್ರೆಸೆಂಟರ್ ಅನುಗುಣವಾದ ಇಂಟರ್ಫೇಸ್ನ ಅನುಷ್ಠಾನಕ್ಕೆ ಉಲ್ಲೇಖವನ್ನು ಹೊಂದಿರಬೇಕು, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ನಲ್ಲಿ ರವಾನಿಸಲಾಗುತ್ತದೆ.
ಪ್ರಸ್ತುತಿ ತರ್ಕವು ಪ್ರೆಸೆಂಟರ್ ನಿದರ್ಶನಕ್ಕೆ ಉಲ್ಲೇಖವನ್ನು ಹೊಂದಿರಬೇಕು. ಎಲ್ಲಾ ವೀಕ್ಷಣೆ ಈವೆಂಟ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಪ್ರೆಸೆಂಟರ್‌ಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರಸ್ತುತಿ ತರ್ಕದಿಂದ (ಇತರ ವೀಕ್ಷಣೆಗಳ ರಚನೆಯನ್ನು ಒಳಗೊಂಡಂತೆ) ಎಂದಿಗೂ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ.

ಬಳಕೆಯ ಉದಾಹರಣೆ: ವಿಂಡೋಸ್ ಫಾರ್ಮ್‌ಗಳು.

ಮಾದರಿ-ವೀಕ್ಷಣೆ-ವೀಕ್ಷಣೆ ಮಾದರಿ

ಈ ವಿಧಾನವು ವ್ಯೂ ಮಾದರಿಯ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಘಟನೆಗಳೊಂದಿಗೆ ವೀಕ್ಷಣೆ ಅಂಶಗಳನ್ನು ಸಂಯೋಜಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಈ ಮಾದರಿಯ ಪ್ರತಿಯೊಂದು ಪದರವು ಮತ್ತೊಂದು ಪದರದ ಅಸ್ತಿತ್ವದ ಬಗ್ಗೆ ತಿಳಿದಿಲ್ಲ ಎಂದು ವಾದಿಸಬಹುದು.

ವೀಕ್ಷಣೆ ಮಾದರಿಯ ವೈಶಿಷ್ಟ್ಯಗಳು:

• ಪ್ರಸ್ತುತಿಯೊಂದಿಗೆ ದ್ವಿಮುಖ ಸಂವಹನ;
• ನೋಟ ಮಾದರಿಯು ನೋಟದ ಅಮೂರ್ತತೆಯಾಗಿದೆ. ಸಾಮಾನ್ಯವಾಗಿ ವೀಕ್ಷಣೆಯ ಗುಣಲಕ್ಷಣಗಳು ವೀಕ್ಷಣೆ/ಮಾದರಿ ಗುಣಲಕ್ಷಣಗಳಂತೆಯೇ ಇರುತ್ತವೆ ಎಂದರ್ಥ
• ವೀಕ್ಷಣೆ ಮಾದರಿಯು ವೀಕ್ಷಣೆ ಇಂಟರ್ಫೇಸ್ (IView) ಗೆ ಉಲ್ಲೇಖವನ್ನು ಹೊಂದಿಲ್ಲ. ವೀಕ್ಷಣೆ ಮಾದರಿಯ ಸ್ಥಿತಿಯನ್ನು ಬದಲಾಯಿಸುವುದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವೀಕ್ಷಣೆಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಯಾಗಿ, ಡೇಟಾ ಬೈಂಡಿಂಗ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸುವುದರಿಂದ (ಬೈಂಡಿಂಗ್‌ಗಳು)
• ಒಂದು ವೀಕ್ಷಣೆ ಮಾದರಿಯ ಒಂದು ನಿದರ್ಶನವು ಒಂದು ವೀಕ್ಷಣೆಯೊಂದಿಗೆ ಸಂಬಂಧ ಹೊಂದಿದೆ.

ಅನುಷ್ಠಾನ:
ಈ ಮಾದರಿಯನ್ನು ಬಳಸುವಾಗ, ವೀಕ್ಷಣೆಯು ಅನುಗುಣವಾದ ಇಂಟರ್ಫೇಸ್ (IView) ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ.
ವೀಕ್ಷಣೆಯು ಡೇಟಾ ಮೂಲಕ್ಕೆ (ಡೇಟಾಕಾಂಟೆಕ್ಸ್) ಲಿಂಕ್ ಅನ್ನು ಹೊಂದಿರಬೇಕು, ಅದು ಈ ಸಂದರ್ಭದಲ್ಲಿವೀಕ್ಷಣೆ ಮಾದರಿಯಾಗಿದೆ. ವೀಕ್ಷಣೆಯ ಅಂಶಗಳು ವೀಕ್ಷಣೆ ಮಾದರಿಯ ಅನುಗುಣವಾದ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಘಟನೆಗಳಿಗೆ ಬದ್ಧವಾಗಿರುತ್ತವೆ.
ಪ್ರತಿಯಾಗಿ, ವೀಕ್ಷಣೆ ಮಾದರಿಯು ವಿಶೇಷ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಇದನ್ನು ವೀಕ್ಷಣೆ ಅಂಶಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನವೀಕರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. WPF ನಲ್ಲಿ ಅಂತಹ ಇಂಟರ್ಫೇಸ್‌ನ ಉದಾಹರಣೆಯೆಂದರೆ INotifyPropertyChanged.

ಬಳಕೆಯ ಉದಾಹರಣೆ: WPF

ಮಾದರಿ-ವೀಕ್ಷಣೆ-ನಿಯಂತ್ರಕ

ಈ ಮಾದರಿಯ ಮುಖ್ಯ ಆಲೋಚನೆಯೆಂದರೆ ನಿಯಂತ್ರಕ ಮತ್ತು ನೋಟ ಎರಡೂ ಮಾದರಿಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ, ಆದರೆ ಮಾದರಿಯು ಈ ಎರಡು ಘಟಕಗಳನ್ನು ಅವಲಂಬಿಸಿಲ್ಲ.

ನಿಯಂತ್ರಕ ಗುಣಲಕ್ಷಣಗಳು

• ಕ್ಷಣದಲ್ಲಿ ಯಾವ ವೀಕ್ಷಣೆಯನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕು ಎಂಬುದನ್ನು ನಿಯಂತ್ರಕ ನಿರ್ಧರಿಸುತ್ತದೆ;
• ಈವೆಂಟ್‌ಗಳನ್ನು ವೀಕ್ಷಿಸಿ ನಿಯಂತ್ರಕವು ಮಾದರಿಯ ಮೇಲೆ ಮಾತ್ರ ಪರಿಣಾಮ ಬೀರಬಹುದು ಮತ್ತು ಇನ್ನೊಂದು ವೀಕ್ಷಣೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು.
• ಕೇವಲ ಒಂದು ನಿಯಂತ್ರಕಕ್ಕೆ ಬಹು ವೀಕ್ಷಣೆಗಳು ಸಾಧ್ಯ;

ಅನುಷ್ಠಾನ:
ನಿಯಂತ್ರಕವು ಈವೆಂಟ್ ಅನ್ನು ಹೊರಗಿನಿಂದ ಪ್ರತಿಬಂಧಿಸುತ್ತದೆ ಮತ್ತು ಅದರಲ್ಲಿ ಹುದುಗಿರುವ ತರ್ಕಕ್ಕೆ ಅನುಗುಣವಾಗಿ, ಸೂಕ್ತವಾದ ವಿಧಾನವನ್ನು ಕರೆಯುವ ಮೂಲಕ ಮಾದರಿಯನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಈ ಘಟನೆಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ. ಬದಲಾವಣೆಯ ನಂತರ, ಮಾದರಿಯು ಅದು ಬದಲಾದ ಈವೆಂಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಇದಕ್ಕೆ ಚಂದಾದಾರರಾಗಿರುವ ಎಲ್ಲಾ ವೀಕ್ಷಣೆ ಈವೆಂಟ್‌ಗಳು ಅದನ್ನು ಸ್ವೀಕರಿಸಿದ ನಂತರ ನವೀಕರಿಸಿದ ಡೇಟಾಕ್ಕಾಗಿ ಮಾದರಿಗೆ ತಿರುಗಿ, ನಂತರ ಅವುಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

ಬಳಕೆಯ ಉದಾಹರಣೆ: MVC ASP.NET

ಪುನರಾರಂಭಿಸಿ

MVVM ಮತ್ತು MVP ಮಾದರಿಗಳ ಅನುಷ್ಠಾನವು ಮೊದಲ ನೋಟದಲ್ಲಿ ಸಾಕಷ್ಟು ಸರಳ ಮತ್ತು ಹೋಲುತ್ತದೆ. ಆದಾಗ್ಯೂ, MVVM ಗಾಗಿ ವೀಕ್ಷಣೆ-ಮಾಡೆಲ್‌ಗೆ ವೀಕ್ಷಣೆಯ ಬೈಂಡಿಂಗ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ, ಆದರೆ MVP ಗಾಗಿ ಪ್ರೋಗ್ರಾಂ ಮಾಡುವುದು ಅವಶ್ಯಕ
MVC ವೀಕ್ಷಣೆಯ ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ಹೊಂದಿರುವಂತೆ ತೋರುತ್ತಿದೆ.

ಮಾದರಿಯನ್ನು ಆಯ್ಕೆಮಾಡಲು ಸಾಮಾನ್ಯ ನಿಯಮಗಳು

ಎಂವಿವಿಎಂ

• ವಿಶೇಷ ವೀಕ್ಷಣೆ ಇಂಟರ್ಫೇಸ್ಗಳನ್ನು ಪರಿಚಯಿಸುವ ಅಗತ್ಯವಿಲ್ಲದೇ ಡೇಟಾ ಬೈಂಡಿಂಗ್ ಸಾಧ್ಯವಿರುವ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ (ಅಂದರೆ IView ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲ);
• ಸಾಮಾನ್ಯ ಉದಾಹರಣೆಯೆಂದರೆ WPF ತಂತ್ರಜ್ಞಾನ.

MVP

• ಡೇಟಾ ಬೈಂಡಿಂಗ್ ಸಾಧ್ಯವಾಗದ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ (ಬೈಂಡಿಂಗ್ ಅನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ);
• ವಿಂಡೋಸ್ ಫಾರ್ಮ್‌ಗಳನ್ನು ಬಳಸುವುದು ಸಾಮಾನ್ಯ ಉದಾಹರಣೆಯಾಗಿದೆ.

MVC

• ವೀಕ್ಷಣೆ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ನ ಇತರ ಭಾಗಗಳ ನಡುವಿನ ಸಂವಹನವು ಸಾಧ್ಯವಾಗದ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ (ಮತ್ತು ನೀವು MVVM ಅಥವಾ MVP ಅನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ);
• ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಸಂದರ್ಭವೆಂದರೆ ASP.NET MVC.

ತೀರ್ಮಾನ

ಕೊನೆಯಲ್ಲಿ, ಈ ಲೇಖನದ ಲೇಖಕರು ಕೇವಲ ಒಂದು ಮಾದರಿಗೆ ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಂಟಿಕೊಳ್ಳುವುದು ಯಾವಾಗಲೂ ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿಲ್ಲ ಎಂದು ಸೂಚಿಸಲು ಬಯಸುತ್ತಾರೆ. ಉದಾಹರಣೆಗೆ, ನಿಯಂತ್ರಣಗಳ ಬೈಂಡಿಂಗ್ ಪ್ರಾಪರ್ಟಿ ಮೂಲಕ ವಿಂಡೋಸ್ ಫಾರ್ಮ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ನೀವು MVVM ಅನ್ನು ಬಳಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಊಹಿಸಿ. ಪ್ರಸ್ತುತಿಯನ್ನು ವ್ಯಾಪಾರ ತರ್ಕದಿಂದ ಮತ್ತು ಅವುಗಳನ್ನು ಸಂಪರ್ಕಿಸುವ ತರ್ಕದಿಂದ ಪ್ರತ್ಯೇಕಿಸುವುದು ನಿಮ್ಮ ಗುರಿಯಾಗಿದೆ. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ಬೆಂಬಲಿಸಲು ಸುಲಭವಾಗಿರಬೇಕು ಮತ್ತು ವಿಶ್ಲೇಷಕರಿಗೆ ಅರ್ಥವಾಗುವಂತೆ ಇರಬೇಕು (ಎಲ್ಲಾ ನಂತರ, "ಹಾರ್ಡ್ ಡ್ರೈವ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೇಗೆ ಅಳೆಯಲಾಗುತ್ತದೆ" ಎಂಬ ಪ್ರಶ್ನೆಗೆ ಒಂದೇ ಒಂದು ಸರಿಯಾದ ಉತ್ತರವಿದೆ - ಜೌಲ್ಸ್‌ನಲ್ಲಿ (ಅಮೂರ್ತ ಉದಾಹರಣೆ ಮಾದರಿ -> ವೀಕ್ಷಣೆಗಳು)) .

ನಿಮ್ಮ ಸಮಯಕ್ಕೆ ತುಂಬಾ ಧನ್ಯವಾದಗಳು, ಓದಿ ಆನಂದಿಸಿ!

MVC (ಮಾದರಿ-ವೀಕ್ಷಣೆ-ನಿಯಂತ್ರಕ) ಪರಿಕಲ್ಪನೆಯನ್ನು ವೆಬ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಜಗತ್ತಿನಲ್ಲಿ ಹೆಚ್ಚಾಗಿ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ ಇತ್ತೀಚಿನ ವರ್ಷಗಳು. ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿಯೊಂದಿಗೆ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಸಂಪರ್ಕ ಹೊಂದಿದ ಪ್ರತಿಯೊಬ್ಬರೂ ಈ ಸಂಕ್ಷೇಪಣವನ್ನು ಒಂದಲ್ಲ ಒಂದು ರೀತಿಯಲ್ಲಿ ನೋಡಿದ್ದಾರೆ. MVC ಪರಿಕಲ್ಪನೆ ಏನು ಮತ್ತು ಅದು ಏಕೆ ಜನಪ್ರಿಯವಾಯಿತು ಎಂಬುದನ್ನು ಇಂದು ನಾವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ.

ಪ್ರಾಚೀನ ಇತಿಹಾಸ

MVC ಯೋಜನಾ ಮಾದರಿಯಲ್ಲ, ಇದು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ರಚನೆಯನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು, ಈ ರಚನೆಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಭಾಗಗಳ ಜವಾಬ್ದಾರಿಗಳು ಮತ್ತು ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ವಿವರಿಸುವ ವಿನ್ಯಾಸದ ಮಾದರಿಯಾಗಿದೆ.

ಇದನ್ನು ಮೊದಲು 1979 ರಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ, ಸಹಜವಾಗಿ, ವಿಭಿನ್ನ ಪರಿಸರಕ್ಕಾಗಿ. ಆಗ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಪರಿಕಲ್ಪನೆ ಇರಲಿಲ್ಲ. ಟಿಮ್ ಬರ್ನರ್ಸ್ ಲೀ ಬೀಜಗಳನ್ನು ಬಿತ್ತಿದರು ವರ್ಲ್ಡ್ ವೈಡ್ತೊಂಬತ್ತರ ದಶಕದ ಆರಂಭದಲ್ಲಿ ವೆಬ್ (WWW) ಹೊರಹೊಮ್ಮಿತು ಮತ್ತು ಜಗತ್ತನ್ನು ಶಾಶ್ವತವಾಗಿ ಬದಲಾಯಿಸಿತು. ನಾವು ಇಂದು ಬಳಸುವ ಟೆಂಪ್ಲೇಟ್ ವೆಬ್ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಮೂಲ ಟೆಂಪ್ಲೇಟ್‌ನ ರೂಪಾಂತರವಾಗಿದೆ.

ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಈ ರಚನೆಯ ಜನಪ್ರಿಯತೆಯು ಎರಡು ಅಭಿವೃದ್ಧಿ ಪರಿಸರದಲ್ಲಿ ಅದರ ಸೇರ್ಪಡೆಯಿಂದಾಗಿ ಬಹಳ ಜನಪ್ರಿಯವಾಗಿದೆ: ಸ್ಟ್ರಟ್ಸ್ ಮತ್ತು ರೂಬಿ ಆನ್ ರೈಲ್ಸ್. ಈ ಎರಡು ಅಭಿವೃದ್ಧಿ ಪರಿಸರಗಳು ನಂತರ ರಚಿಸಲಾದ ನೂರಾರು ಅಭಿವೃದ್ಧಿ ಪರಿಸರಗಳಿಗೆ ಮಾರ್ಗವನ್ನು ಹೊಂದಿಸುತ್ತವೆ.

ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ MVC

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 ಅನ್ನು ಈಗಾಗಲೇ ಸಿದ್ಧಪಡಿಸಲಾಗಿದೆ ಮತ್ತು MVC ಮಾದರಿಯನ್ನು ಹೊಂದಿಸಲು ನಿಮ್ಮ ಫೈಲ್‌ಗಳನ್ನು ಸೂಕ್ತವಾದ ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿ ಇರಿಸುವ ಮೂಲಕ ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ರಚನೆಯನ್ನು ವಿಸ್ತರಿಸುವುದು. ಜೊತೆಗೆ, ನೀವು ಈಗಾಗಲೇ ಬರೆದಿರುವ ಮತ್ತು ಉತ್ತಮವಾಗಿ ಪರೀಕ್ಷಿಸಲಾದ ವೈಶಿಷ್ಟ್ಯಗಳ ಗುಂಪನ್ನು ಹೊಂದಿರುವಿರಿ.

ಉದಾಹರಣೆಯಾಗಿ ಕೇಕ್ ಪಿಎಚ್ಪಿ ತೆಗೆದುಕೊಳ್ಳೋಣ ಕೆಲಸದ ವಾತಾವರಣ MVC. ಅನುಸ್ಥಾಪನೆಯ ನಂತರ ನೀವು ಮೂರು ಮುಖ್ಯ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಹೊಂದಿರುತ್ತೀರಿ:

• ಕೇಕ್/
• ಮಾರಾಟಗಾರರು/

ಫೋಲ್ಡರ್ ಅಪ್ಲಿಕೇಶನ್ನಿಮ್ಮ ಫೈಲ್‌ಗಳು ಇರುವ ಸ್ಥಳ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಭಾಗವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಇದು ಸ್ಥಳವಾಗಿದೆ.

ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಕೇಕ್ cakePHP ಫೈಲ್‌ಗಳನ್ನು (ವರ್ಕ್‌ಬೆಂಚ್ ಕಾರ್ಯನಿರ್ವಹಣೆ) ಹೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ.

ಫೋಲ್ಡರ್ ಮಾರಾಟಗಾರರುಗ್ರಂಥಾಲಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ PHP ಮೂರನೇ ವ್ಯಕ್ತಿಅಭಿವರ್ಧಕರು.

ನಿಮ್ಮದು ಕಾರ್ಯಕ್ಷೇತ್ರ(ಅಪ್ಲಿಕೇಶನ್ ಡೈರೆಕ್ಟರಿ) ಕೆಳಗಿನ ರಚನೆಯನ್ನು ಹೊಂದಿದೆ:

• ಅಪ್ಲಿಕೇಶನ್/
  • ಸಂರಚನೆ/
  • ನಿಯಂತ್ರಕರು/
  • ಸ್ಥಳ/
  • ಮಾದರಿಗಳು/
  • ಪ್ಲಗಿನ್‌ಗಳು/
  • ಪರೀಕ್ಷೆಗಳು/
  • ಮಾರಾಟಗಾರರು/
  • ವೀಕ್ಷಣೆಗಳು/
  • ವೆಬ್‌ರೂಟ್/

ನಿಮ್ಮ ನಿಯಂತ್ರಕಗಳನ್ನು ನೀವು ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಇರಿಸಬೇಕಾಗುತ್ತದೆ ನಿಯಂತ್ರಕರು, ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಮಾದರಿಗಳು ಮಾದರಿಗಳುಮತ್ತು ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ವಿಧಗಳು ವೀಕ್ಷಣೆಗಳು!

ಒಮ್ಮೆ ನೀವು ವರ್ಕ್‌ಬೆಂಚ್ ಅನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿದರೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ವಾಸ್ತವಿಕವಾಗಿ ರಚಿಸಬೇಕಾದ ಅಥವಾ ಮಾರ್ಪಡಿಸಬೇಕಾದ ಪ್ರತಿಯೊಂದು ಭಾಗವು ಎಲ್ಲಿ ನೆಲೆಸಿದೆ ಎಂಬುದು ತಕ್ಷಣವೇ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ. ಈ ಸಂಸ್ಥೆಯು ಸ್ವತಃ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಮತ್ತು ನಿರ್ವಹಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೆಚ್ಚು ಸರಳಗೊಳಿಸುತ್ತದೆ.

ನಮ್ಮ ಉದಾಹರಣೆಗಾಗಿ ವರ್ಕ್‌ಬೆಂಚ್ ಅನ್ನು ಬಳಸುವುದು

ಏಕೆಂದರೆ ಈ ಪಾಠಕೇಕ್‌ಪಿಎಚ್‌ಪಿ ಬಳಸಿಕೊಂಡು ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ತೋರಿಸಲು ಉದ್ದೇಶಿಸಿಲ್ಲ, ನಾವು ಮಾದರಿ, ನಿಯಂತ್ರಕ ಮತ್ತು ಎಂವಿಸಿ ವರ್ಕ್‌ಬೆಂಚ್ ಅನ್ನು ಬಳಸುವ ಪ್ರಯೋಜನಗಳ ಕುರಿತು ಕಾಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ವೀಕ್ಷಣೆಗಾಗಿ ಕೋಡ್ ಅನ್ನು ಮಾತ್ರ ತೋರಿಸುತ್ತೇವೆ. ಕೋಡ್ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಸರಳೀಕೃತವಾಗಿದೆ ಮತ್ತು ನೈಜ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಬಳಸಲು ಸೂಕ್ತವಲ್ಲ.

ನೆನಪಿಡಿ, ನಾವು ಪುಸ್ತಕದಂಗಡಿಯನ್ನು ಮತ್ತು ನೋಡಲು ಬಯಸುವ ಕುತೂಹಲಕಾರಿ ಬಳಕೆದಾರರನ್ನು ನೋಡುತ್ತಿದ್ದೇವೆ ಪೂರ್ಣ ಪಟ್ಟಿವಿಷಯದ ಮೇಲೆ ಪುಸ್ತಕಗಳು ಫ್ಯಾಂಟಸಿ. ನಿಯಂತ್ರಕವು ಬಳಕೆದಾರರ ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸಿದೆ ಮತ್ತು ಅಗತ್ಯ ಕ್ರಮಗಳನ್ನು ಸಂಯೋಜಿಸಿದೆ.

ಆದ್ದರಿಂದ, ಬಳಕೆದಾರರು ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿದ ತಕ್ಷಣ, ಬ್ರೌಸರ್ ನೀಡಿದ url ಅನ್ನು ವಿನಂತಿಸುತ್ತದೆ:

www.ourstore.com/books/list/fantasy

CakePHP ಮಾದರಿಯನ್ನು ಬಳಸಿಕೊಂಡು URL ಅನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುತ್ತದೆ /ನಿಯಂತ್ರಕ/ಆಕ್ಷನ್/param1/param2, ಎಲ್ಲಿ ಕ್ರಮನಿಯಂತ್ರಕದಿಂದ ಕರೆಯಲಾಗುವ ಒಂದು ಕಾರ್ಯವಾಗಿದೆ. ಹಳೆಯದರಲ್ಲಿ ಕ್ಲಾಸಿಕ್ ನೋಟ url ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

www.ourstore.com/books_controller.php?action=list&category=fantasy

ನಿಯಂತ್ರಕ

ಕೇಕ್ಪಿಎಚ್ಪಿ ಕೆಲಸದ ವಾತಾವರಣದಲ್ಲಿ, ನಮ್ಮ ನಿಯಂತ್ರಕವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಕ್ಲಾಸ್ ಬುಕ್ಸ್ ಕಂಟ್ರೋಲರ್ ಆಪ್ ಕಂಟ್ರೋಲರ್ ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ (

ಕಾರ್ಯ ಪಟ್ಟಿ($ವರ್ಗ) (

$this->set("ಪುಸ್ತಕಗಳು", $this->Book->findAllByCategory($category));

ಫಂಕ್ಷನ್ ಆಡ್() (... ...)

ಫಂಕ್ಷನ್ ಡಿಲೀಟ್() (... ...)

... ... } ?>

ಸರಳ, ಅಲ್ಲವೇ? ಈ ನಿಯಂತ್ರಕಎಂದು ಉಳಿಸಲಾಗುವುದು books_controller.phpಮತ್ತು ಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ / ಅಪ್ಲಿಕೇಶನ್ / ನಿಯಂತ್ರಕಗಳು. ಇದು ನಮ್ಮ ಉದಾಹರಣೆಗಾಗಿ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದೆ, ಹಾಗೆಯೇ ಪುಸ್ತಕ-ಸಂಬಂಧಿತ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಇತರ ಕಾರ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ (ಸೇರಿಸು ಹೊಸ ಪುಸ್ತಕ, ಪುಸ್ತಕವನ್ನು ಅಳಿಸಿ, ಮತ್ತು ಹೀಗೆ).

ಕೆಲಸದ ವಾತಾವರಣವು ನಮಗೆ ಅನೇಕರನ್ನು ಒದಗಿಸುತ್ತದೆ ಸಿದ್ಧ ಪರಿಹಾರಗಳುಮತ್ತು ನೀವು ಕೇವಲ ಪುಸ್ತಕಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ನಿಯಂತ್ರಕದ ಮೂಲ ಕಾರ್ಯವನ್ನು ಈಗಾಗಲೇ ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲ ವರ್ಗವಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಈ ವರ್ಗದ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯಬೇಕು ( ಆಪ್ ಕಂಟ್ರೋಲರ್ವಾರಸುದಾರನಾಗಿದ್ದಾನೆ ನಿಯಂತ್ರಕ).

ಕ್ರಿಯೆಯ ಪಟ್ಟಿಯಲ್ಲಿ ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ಡೇಟಾವನ್ನು ಪಡೆಯಲು ಮಾದರಿಗೆ ಕರೆ ಮಾಡಿ ಮತ್ತು ನಂತರ ಅದನ್ನು ಬಳಕೆದಾರರಿಗೆ ಪ್ರಸ್ತುತಪಡಿಸಲು ವೀಕ್ಷಣೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ. ಇದನ್ನು ಹೇಗೆ ಮಾಡಲಾಗಿದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ.

ಈ->ಪುಸ್ತಕ- ಇದು ನಮ್ಮ ಮಾದರಿ ಮತ್ತು ಕೋಡ್‌ನ ಭಾಗವಾಗಿದೆ:

$this->ಪುಸ್ತಕ->findAllByCategory($category)

ಆಯ್ಕೆಮಾಡಿದ ವಿಷಯದ ಪುಸ್ತಕಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸಲು ಮಾದರಿಗೆ ಹೇಳುತ್ತದೆ (ನಾವು ನಂತರ ಮಾದರಿಯನ್ನು ನೋಡೋಣ).

ವಿಧಾನ ಸೆಟ್ಸಾಲಿನಲ್ಲಿ:

$this->set("ಪುಸ್ತಕಗಳು", $this->Book->findAllByCategory($category));

ನಿಯಂತ್ರಕವು ವೀಕ್ಷಣೆಗೆ ಡೇಟಾವನ್ನು ರವಾನಿಸುತ್ತದೆ. ವೇರಿಯಬಲ್ ಪುಸ್ತಕಗಳುಮಾದರಿಯಿಂದ ಹಿಂತಿರುಗಿದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ವೀಕ್ಷಣೆಗೆ ಲಭ್ಯವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ.

ಈಗ ಉಳಿದಿರುವುದು ವೀಕ್ಷಣೆಯನ್ನು ಪ್ರದರ್ಶಿಸುವುದು, ಆದರೆ ನಾವು ಡೀಫಾಲ್ಟ್ ವೀಕ್ಷಣೆಯನ್ನು ಬಳಸಿದರೆ ಈ ಕಾರ್ಯವನ್ನು ಕೇಕ್ಪಿಎಚ್ಪಿಯಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ. ನಾವು ಬೇರೆ ಪ್ರಕಾರವನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ, ನಾವು ವಿಧಾನವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕರೆಯಬೇಕು ನಿರೂಪಿಸಲು.

ಮಾದರಿ

ಮಾದರಿ ಇನ್ನೂ ಸರಳವಾಗಿದೆ:

ವರ್ಗ ಪುಸ್ತಕವು AppModel ಅನ್ನು ವಿಸ್ತರಿಸುತ್ತದೆ (

ಏಕೆ ಖಾಲಿಯಾಗಿದೆ? ಏಕೆಂದರೆ ಆಕೆಯೇ ವಾರಸುದಾರಳು ಮೂಲ ವರ್ಗ, ಇದು ಅಗತ್ಯವಿರುವ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ವರ್ಕ್‌ಬೆಂಚ್ ಎಲ್ಲಾ ಇತರ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು CakePHP ನ ಹೆಸರಿಸುವ ಸಂಪ್ರದಾಯವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, cakePHP ಹೆಸರಿನ ಆಧಾರದ ಮೇಲೆ ತಿಳಿದಿದೆ ಈ ಮಾದರಿನಲ್ಲಿ ಬಳಸಲಾಗಿದೆ ಪುಸ್ತಕ ನಿಯಂತ್ರಕ, ಮತ್ತು ಇದು ಪುಸ್ತಕಗಳ ಹೆಸರಿನ ಡೇಟಾಬೇಸ್ ಟೇಬಲ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದೆ.

ಈ ವ್ಯಾಖ್ಯಾನದೊಂದಿಗೆ, ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಓದಲು, ಅಳಿಸಲು ಅಥವಾ ಸಂಗ್ರಹಿಸಬಹುದಾದ ಮಾದರಿಯನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ.

ಕೋಡ್ ಅನ್ನು ಹೀಗೆ ಉಳಿಸಿ book.phpಫೋಲ್ಡರ್‌ನಲ್ಲಿ / ಅಪ್ಲಿಕೇಶನ್ / ಮಾದರಿಗಳು.

ವೀಕ್ಷಿಸಿ

ನಾವು ಈಗ ಮಾಡಬೇಕಾಗಿರುವುದು ವೀಕ್ಷಣೆಯನ್ನು ರಚಿಸುವುದು (ಮೂಲಕ ಕನಿಷ್ಠ, ಒಂದು) ಕ್ರಿಯೆಗಳ ಪಟ್ಟಿಗಾಗಿ. ವೀಕ್ಷಣೆಯು HTML ಕೋಡ್ ಮತ್ತು ಮಾದರಿ ಒದಗಿಸುವ ಪುಸ್ತಕಗಳ ರಚನೆಯ ಮೂಲಕ ಲೂಪ್ ಮಾಡಲು PHP ಕೋಡ್‌ನ ಕೆಲವು (ಸಾಧ್ಯವಾದಷ್ಟು ಕಡಿಮೆ) ಸಾಲುಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಹೆಸರು	ಲೇಖಕ	ಬೆಲೆ

ನೀವು ನೋಡುವಂತೆ, ವೀಕ್ಷಣೆಯು ಪೂರ್ಣ ಪುಟವನ್ನು ರಚಿಸುವುದಿಲ್ಲ, ಆದರೆ HTML ನ ಒಂದು ತುಣುಕು ಮಾತ್ರ (ಈ ಸಂದರ್ಭದಲ್ಲಿ ಟೇಬಲ್). ಏಕೆಂದರೆ CakePHP ಪುಟದ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮತ್ತೊಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ವೀಕ್ಷಣೆಯನ್ನು ಆ ಟೆಂಪ್ಲೇಟ್‌ಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ. ವರ್ಕ್‌ಬೆಂಚ್ ನಮಗೆ ನಿರ್ವಹಿಸಲು ಕೆಲವು ಸಹಾಯಕ ವಸ್ತುಗಳನ್ನು ಸಹ ಒದಗಿಸುತ್ತದೆ ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳುಭಾಗಗಳ ರಚನೆಯ ಸಮಯದಲ್ಲಿ HTML ಪುಟಗಳು(ಫಾರ್ಮ್‌ಗಳು, ಲಿಂಕ್‌ಗಳು, ಅಜಾಕ್ಸ್ ಅಥವಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸೇರಿಸುವುದು).

ವೀಕ್ಷಣೆಯನ್ನು ಹೀಗೆ ಉಳಿಸಿ list.ctp(ಪಟ್ಟಿಯು ಕ್ರಿಯೆಯ ಹೆಸರು ಮತ್ತು ctp ಎಂದರೆ CakePHP ಟೆಂಪ್ಲೇಟ್) ಫೋಲ್ಡರ್‌ನಲ್ಲಿ / ಅಪ್ಲಿಕೇಶನ್ / ವೀಕ್ಷಣೆಗಳು / ಪುಸ್ತಕಗಳು(ಏಕೆಂದರೆ ಇದು ನಿಯಂತ್ರಕ ಕ್ರಿಯೆಗೆ ಒಂದು ನೋಟವಾಗಿದೆ).

CakePHP ವರ್ಕ್‌ಬೆಂಚ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಎಲ್ಲಾ ಮೂರು ಘಟಕಗಳನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ!