שלום, אני רוצה לבנות מערכת גדולה, אבל גדולה באמת... אני רוצה שזאת תהיה מערכת MVC ואני עכשיו בשלבי דיזיין.
חילקתי דפים לשני חלקים:
כלי מערכת
מודולים

כלי מערכת זה למשל:
db.php
config.php
וגם דף שמנהל מודלים, זאת אומרת מקבל ב- GET שם של מודל, מוודא אם זה בסדר, ואז מוסיף את המודל, מעטפות מראה, מערכת ניהול...

היה לי קצת קשה להבין, איפה אני משלב את ה- view, model, controller.
חשבתי ככה:
תהייה לי תיקייה בשם modules ובתוכה תיקיות, לכל תיקייה יש שם של המודל, ובתוך התיקייה שיהיו 3 קבצים:
view.php
model.php
controller.php
כשהמודל זה מחלקה עם כל מה שהמודל צריך לעשות, controller זה החלק שמקבל נתונים מה- GET, מבין מה רוצים ממנו, ועושה בהתאם, ככה שבעצם, המודל זה הגרעין, והקונטרולר זה המעטפת, וה- view מוציא את הפלט.

ואז חשבתי לעצמי, המודל לא אמור להיות הדינאמי? זאת אומרת שלכל מודל יהיה רק מחלקה, וככה זה נכון מבחינת תחזוקה, זאת אומרת, הם במיילא נפרדים, אבל ככל שאני עושה פחות לכל מודל, ככה יותר טוב, ואז ניתקלתי בבעיה: איך אני עושה את זה? איך אני מכין קונטרולר שיודע להבין מה רוצים ממנו, אם הוא בכלל נפרד מהמודל (גם במצב הקודם הוא היה נפרד, אבל זה שונה, כי הוא נוצר במיוחד בשביל המודל) ובכלל, ה- view.. מאיפה הוא יודע איך אני רוצה להציג את המידע?

מה שגרם לי לפקפק בזה שהבנתי בכלל מה זה MVC.
אז השאלה שלי היא כזאת: אני בכיוון? מה שתכננתי בסדר? אם לא, איך כן? איך זה עובד?

ממה שאמרת נראה לי שיש כמה נושאים קרובים שטיפה מעורבבים אצלך ביחד.

קודם כל:
Model זה מודל
Module זה מודול
אתה מערבב ביניהם ומחליף ביניהם בלי לתת חשבון. אלה דברים שונים לגמרי.

אפשר להבין מאיפה הבלבול (חוץ מהדימיון הלשוני בין model ל module)...יש דימיון בין MVC לבין עיקרון המודולריות מהבחינה שיש לשניהם אותה מטרה כללית: להקטין כמה שיותר את הקשר בין חלקים שונים בתכנית, כדי לעשות אותה יותר גמישה, עמידה לשינויים וקלה לתחזוקה ועוד אלף דברים..

אבל מודולריות זה רעיון הרבה יותר כללי, ו MVC זה רק אמצעי להשגת מודולריות גבוהה יותר.

ציטוט:

איך אני מכין קונטרולר שיודע להבין מה רוצים ממנו, אם הוא בכלל נפרד מהמודל (גם במצב הקודם הוא היה נפרד, אבל זה שונה, כי הוא נוצר במיוחד בשביל המודל) ובכלל, ה- view.. מאיפה הוא יודע איך אני רוצה להציג את המידע?

אוקיי. ה"קונטרולר" לא מופרד מהמודל. הוא מטפל באירועים ובקלט(למשל GET, כמו שציינת), ופונה ל Model לאחר שהוא מחליט מה צריך לעשות. אבל המודל כן מופרד מה Controller. הוא לא יודע על ה Controller (לא באופן ישיר). למען האמת, ה Model לא יודע גם על התצוגה (שוב - לא באופן ישיר).
התצוגה גם לא מופרדת מהמודל. היא לוקחת ממנו נתונים, אבל הוא כן מופרד ממנה, וכמו שאמרתי, הוא לא יודע עליה בכלל.
אם היה לך שלוש מחלקות: Model, View, Controller, אז התוכנית שלך הייתה יכולה להכיל:

קוד PHP:

 $Model->setX($Controller->getUserX());
$View->print($Model->getX()); 


אבל היא לא הייתה יכולה להכיל, לדוגמא, שבקוד של המחלקה Model יהיה שימוש במחלקות View או Controller.

אז לסיכום, הנה הקשרים בין החלקים השונים של MVC באופן עקרוני:
Model לא יודע על אף אחד. הוא לא יכול להשתמש או לפנות לView או לController לעולם. הוא אחראי בעיקר על עבודה עם הנתונים.
View רק מקבל מידע מה Model כדי לדעת מה להציג. ה Model הוא כמו חוצץ בין הנתונים האמיתיים לבין הView, ככה של View אין גישה ישירה לנתונים.
Controller שולח מידע לModel לפי הקלט או אירועים שונים שיכולים לקרות ואומר לו מה לעשות.

עכשיו, ממה שאמרת אני מבין שאתה רוצה לעשות מערכת מודולרית. אין לזה שום קשר לMVC, מלבד העובדה שכל Module במערכת חייב גם הוא להיות כפוף לכללים של MVC.

ז רגע, אז כל מודול הוא MVC משל עצמו? (ניראה לי שוב בליבלתי, מקווה שאתה תבין)
ו- model זה מחלקה אחת, controller מחלקה אחרת ו- view מחלקה אחרת? (אני לא מבין למה view צריך מחלקה)

אני בטעות לא השלמתי את המשפט האחרון, וזה כנראה גרם לבלבול. המשפט האחרון היה אמור להיות:

ציטוט:

אני מבין שאתה רוצה לעשות מערכת מודולרית. אין לזה שום קשר לMVC, מלבד העובדה שכל Module במערכת חייב גם הוא להיות כפוף לכללים של MVC אם אתה רוצה שהמערכת כולה תהיה כפופה לעקרונות של MVC

מצטער אם בילבלתי אותך בטעות

ציטוט:

ז רגע, אז כל מודול הוא MVC משל עצמו? (ניראה לי שוב בליבלתי, מקווה שאתה תבין)

מה זאת אומרת "כל מודול הוא MVC משל עצמו?" MVC זה רק רעיון לחלוקת תפקידים.
אם אתה רוצה שהוא יהיה בנוי לפי MVC - תבנה אותו כזה. לי זה נראה מיותר בגלל שMVC מיועד למערכות גדולות ומסובכות, אבל עבור מודול קטן זה סתם מיותר וזה יותר עבודה מאשר תועלת, כי המודול גם ככה מאפשר גמישות מעצם היותו מודול.
ובכלל, גם המערכת וגם המודול לא חייבים להיות כלום. MVC זה רק design pattern, אתה רשאי לסטות ממנו לפי ראות עיניך או לא להשתמש בו בכלל. צריך להפעיל שיקול דעת.

ציטוט:

ו- model זה מחלקה אחת, controller מחלקה אחרת ו- view מחלקה אחרת? (אני לא מבין למה view צריך מחלקה)

View לא צריך מחלקה. גם Model לא וגם Controller לא. שום דבר לא "צריך" מחלקה.
זה סמלי, אבל כן - נוח לממש הרבה מהמרכיבים כמחלקות בגלל שהרבה מעקרונות OOD עולים בקנה אחד עם MVC, למשל כימוס, אבסטרקציה,..
בכל מקרה, כמו שאמרתי, אף אחד מהמרכיבים של MVC לא חייב להיות כלום. זה תלוי בדרך שאתה בוחר לממש את זה.

אבל אם כבר שאלת למה View צריך מחלקה? לפי התשובה הקודמת ברור שהוא לא "צריך" מחלקה, אבל יש כמה סיבות בעד:
1. זה סמלי
2. דרך נוחה לממש MVC בphp הוא עם templates. יש הרבה מנועים של templates אבל הרעיון העיקרי זהה בכולם: להפריד בין HTML לphp. עם templates מה שאתה עושה זה יוצר קובץ HTML כלשהו (הרבה פעמים הסיומת היא tpl או tpl.php) ובו נמצא רק HTML, אבל אתה מסמן בו שדות מסויימים אשר אמורים להיות מוחלפים בתוכן.
קבצי php רגילים אמורים להכיל רק קוד php, ובעזרת מנוע ה template (בד"כ מדובר במחלקה) להחליף את השדות בתוכן.
בד"כ כאשר משתמשים ב templates אז הView הוא המחלקה של ה template, ה Controller הוא הקוד שמתבצע בדף הphp, וה model הוא המחלקה של מסד הנתונים. זה לא בדיוק MVC, כמו שאתה רואה, אבל לא חובה להיצמד בדיוק לMVC כי זה יכול להוביל לחוסר יעילות וליותר עבודה בסופו של דבר, תלוי באיזה סביבה אתה עובד. בגלל זה חשוב להשתמש גם בשיקול דעת ולדעת איך לקחת מה שאתה צריך מMVC, ןלחשוב על רעיונות אחרים שישלימו מה שחסר.
אם אתה רוצה לממש MVC בצורה טובה בphp, אז templates is the way to go..

אני אף פעם לא הבנתי את הרעיון הזה, מערכת template.
במקום למשל לעשות:

קוד:

...
<span class="title">{$title]</span>
...

אז אותו דבר לעשות:

קוד:

...
<span class="title"><?=$title ?></span>
...

למה בשביל ההבדל הקטן הזה לבנות עכשיו מערכת גדולה?
תחזוקה? אולי אני רוצה להחליף משתנה, טוב, אז שים פונקציה עם כמה ארגומנטים..

אוקי, הפנמתי שאין קשר בין מערכת מודולרית ל-MVC, MVC זה רק שיטת עבודה...
אני רוצה לבנות את המערכת לפי הרעיון של MVC, למערכת הולכים להיות המון המון מודולים..
אני פשוט לא מבין, איך איך אני מיישים את זה?
החלטתי שרוב מה שיהיה קיים המערכת, יהיה מודולים, וכל השאר זה דברים קטנים..
אפילו למשל שיהיה מודל בשם Home שהמטרה שלו היא ליצור לי את עמוד הבית, עד כדי כך להתסתמך על מודולים... ככה שאיפה שיש לי לבנות משהו בצורה של MVC, זה רק במודולים. האם לדעתכם זה נכון?
אני חושב שאני יבנה את זה ככה:
דף modules.php (הדף העיקרי במערכת, רוב הפעולות עוברות דרכו, אני יודע שזה בעייתי מבחינת SEO... בשביל זה יש mod_rewrite ):
אופן הפעולה:
1) מאנקלד דפי מערכת (login_check, db ועוד כל מיני שטויות...)
2) מוסיף את המחלקה model
3) מוסיף את המחלקה controller
4) מבצע פעולות מוגדרות הנמצאות בדף ה- controller
5) מוסיף Template שהוא ה- view ומסיים את הפעולה

נראה לי שזה מזכיר קצת את המבנה של PHPNUKE

תעיין בו אולי זה יועיל לך במשהו

ציטוט:

אני אף פעם לא הבנתי את הרעיון הזה, מערכת template. למה בשביל ההבדל הקטן הזה לבנות עכשיו מערכת גדולה? תחזוקה? אולי אני רוצה להחליף משתנה, טוב, אז שים פונקציה עם כמה ארגומנטים..

תתאר לך שיש לך מערכת גדולה. לכל דף יש אותו עיצוב כללי, נכון? אותו HTML, מלבד כמה מקומות שבהם את השם תוכן...אז עבור כל דף PHP תוסיף את כל הHTML? לא יותר פשוט להוסיף 5 שורות קוד בphp שיעשו את זה? זה יוצר גם קבצים קטנים יותר, גם קוד נקי יותר ויותר אבסטרקציה. אם תרצה לשנות את הHTML לא תצטרך לשנות שורת קוד אחת מלבד ה HTML, בעוד שבשיטה שלך, אני אצטרך לעבור על כל קובץ.

בקשר למה שהצעת:

קוד PHP:

 ...
<span class="title"><?=$title ?></span>
... 


יש לזה הרבה חסרונות, ובאמת שקשה לפרט את כולם, אבל הנה כמה:

1. העיצוב לא מופרד מהתכנות, וזה אחד מהדברים הכי חשובים בMVC.
2. עם templates אין לי שום אילוץ לגבי התכנות שלי. אצלך אני חייב לדאוג שכל עמוד יכיל את כל המשתנים המתאימים או הפונקציות המתאימות.
3. אין לי שליטה על הHTML - מה שאני כותב יוצא, בעוד שעם Template מתאפשרת הרבה יותר שליטה. למשל שדות אופציונליים, שדות שחוזרים על עצמם, אזורים, ועוד. ואם אני רוצה להחליף במהלך התוכנית את כל הHTML לדף אחר לגמרי? כמובן שאפשר לעשות את זה גם בדרך שלך, אבל עם כל אפשרות נוספת דולף יותר ויותר קוד php לעיצוב.

ציטוט:

אני רוצה לבנות את המערכת לפי הרעיון של MVC, למערכת הולכים להיות המון המון מודולים.. אני פשוט לא מבין, איך איך אני מיישים את זה?

המון המון מודולים נשמע מגניב, אבל בטח כמו ששמת לב, זה יותר מסובך ממה שזה נשמע.
כדי לתכנן את המערכת נכון, את חייב קודם כל לדעת מה המערכת שלך עושה, וזה אחד מהדברים שנראה לי שחסר אצלך, כי חוץ מזה שהיא לפי MVC ושהיא מודולרית לא שמעתי עליה כלום.
אחרי שיש לך מטרה, אתה חייב להחליט איזה חלק בה הוא מודולרי, ואיזה חלק נשאר קבוע. זה טבעי לרצות שהכל יהיה מודולרי, אבל אי אפשר לעשות הכל מודולרי, כי חייב להיות חלק "מעוגן" במערכת. בנוסף זה לא תמיד נכון, כי הרבה פעמים מודולריות באה על חשבון המשתמש מבחינת יעילות, שגיאות וכך הלאה. לא צריך לרצות שהכל יהיה מודולרי. צריך לקבוע מראש מה יהיה מודול ועד איזה רמה בתוכנית שלך יש מודולים כדי שיהיה איזון בין יעילות למודולריות.

בקשר לשלבים שאתה מציע:
אין דרך נכונה ודרך לא נכונה. זה תלוי במבנה המערכת שלך. אבל כמה דברים שכדאי שתזכור בזמן שאתה מתכנן/בונה את המערכת זה שלא באמת צריכה להיות מחלקה בשם Model, או מחלקה בשם Controller, אלא רק מישהו שימלא את התפקיד הזה.

עוד דבר - מה שיותר חשוב במודולים זה האי-תלות שלהם אחד ביחס לשני, אבל לא ביחס למערכת, ככה שמודולים צריכים להשתמש כמה שפחות אחד בשני, ולחלוק כמה שיותר דברים משותפים, למשל מחלקת template אחת או מחלקת db אחת.
זאת לא המלצה, זו רק דוגמא, והמבנה הזה לא בהכרח מתאים לך.

לפני שאתה מתחיל לתכנן, מומלץ שגם תחליט על טיב הקשר בין המודולים. אם אתה רוצה שיהיה ביניהם קשר כלשהו, אתה יכול לחפש בגוגל על Mediator pattern או observer pattern - אלה design patterns שמשתמשות בדרכים שונות ליצור קשרים עקיפים בין חלקים שונים בתוכנה כדי למנוע coupling (תלות בין החלקים השונים).

וואו.. אני ממש מנדנד כמו נוב רציני...
ככל כנראה, לא הכנתי מה אותה מערכת Template כוללת, עד כה, מה שהבנתי זה שיש לי מחלקה קטנה שמחליפה סימנים מוגדרים במשתנים, כמו למשל:

קוד PHP:

 <span class="title">{$title}</span> 


ואז באמת, ההבדל מאוד מאוד קטן, ופה אני לא רואה צורך, שחשבתי על תחזוקה זה על אם אולי יחליפו את השם של המשתנה, אבל בינינו, גם הדבר הזה למעלה לא ממש נותן מענה לתשובה.

הרעיון של המערכת שאני רוצה לבנות, זה איזשהו מאגר "ויקי" וכרגע, אני פשוט לא רוצה להגביל אותי במדיות, אז אני אומר הרבה הרבה מדיות או המון המון מודולים, כעיקרון אני רוצה מאמרים, מדריכים, משחקים, סרטונים בדיחות, קטעי טקסט מצחיקים.. זה כעיקרון הבסיס, אבל השמיים הם הגבול.

בהתחלת האשכול, אני אמרתי שיש מודולים ויש קבצי מערכת, אבל כעיקרון הכל מושתת על מודולים (אפילו דף הבית למשל זה מודול בשם home) ושאלתי האם זה בסדר

ציטוט:

אבל בינינו, גם הדבר הזה למעלה לא ממש נותן מענה לתשובה.

templates דווקא מאוד מביא תשובה, אבל כנראה שתצטרך להיווכח בכך בדרך הקשה

בקשר לויקי - בהצלחה. תעדכן אותנו

אם יש הרבה מחלקות, מה הבעיה לעשות פונקציות פומביות סופיות (final) ומי שירצה לערוך ירשום

קוד:

$user->getNickname()

במקום לרשום {USER_NICKNAME} - ובכך אינך צריך ליצור parser ענק, רק בשביל להמיר מהצורה השניה לצורה הראשונה.

הקונספט של MVC זה לכך שלכל מחלקה יש תפקיד מוגדר משלה?
אין איזושהי מחלקת 'אם' שמפקחת על הכל?

EVERYTHING SHOULD BE MADE AS SIMPLE AS POSSIBLE, BUT NOT ONE BIT SIMPLER
ALBERT EINSTEIN

templates מאפשר שליטה הרבה יותר טובה, ולא רק בהצגת דפי html.
בכל מקרה, מכיוון שעייפתי מלהסביר את יתרונות ה templates, אני מפנה אותך לפה ולפה

ובנוגע לקונספט של MVC, אתה יכול לקרוא פה. זה כבר יענה לך על השאלות שלך.

מצטער שאני לא מפרט כמו בהודעות קודמות, אבל היד כואבת ויש כבר כאלו שרשמו את זה במסודר