מדוע עקרונות קוד מיצוי מידע וכיצד עקרונות SOLID עוזרים

כל צוות פיתוח מתמודד עם אותו אתגר: כיצד לכתוב קוד שאינו צריך להיות כתוב מחדש עבור כל פרויקט חדש.קוד Reusability להפחית את השכפול, להאיץ את הפיתוח, והופך את תחזוקה לקלה יותר.ללא גישה מובנת, קוד ניתן להגדרה במהירות הופכת קבוצות מבולגות של רכיבי הפיכה ותופעות לוואי .עקרונות SOLID, שהוצגו על ידי רוברט C Martin, לספק מסגרת מוכחת עבור תוכנה כי הוא גמיש, וקבוע, על ידי פיתוח, וחדש, על ידי חמישה מתכנתים חדשים, באופן עקבי, ואפקטים, באופן עקבי, ואפקטים, על ידי פונקציות, ואפקטים יותר, על ידי פונקציות, כאשר הם באמת, החלים יותר, כדי להפוך את המשתנים, על ידי פונקציות, על ידי פונקציות, ואפקטים יותר, ואפקטים יותר, על ידי פונקציות אסטרטגיות יותר, ואפקטים יותר, עם תכונות אסטרטגיות יותר, ואפקטים, באופן עקבי, ואפקטים יותר, באופן עקבי, עם תכונות אסטרטגיות יותר, עם תכונות קידוד יעיל יותר, באופן עקבי, החלפני קידוד, עם תכונות אסטרטגיות קידוד, באופן עקבי, החלרקטיביות, החלרקטיביות, כאשר הם באמת, כאשר הם באמת, החלפני קידוד, כדי להפוך את זה, 000 קידוד,

חמשת העקרונות של SOLID ב-Glance

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

  • (ב) ⁇ (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • (ב) קוד פתוח/סגור את עקרון ה-OCP: FLT:1 ישויות תוכנה צריכות להיות פתוחות להרחבה, אך סגורות לשינויים.
  • (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • (ב) ,0) יחסי סגירה Principle (ISPIR): לקוחות 1FLT:1 לא צריך להיות נאלץ להיות תלוי ממשקים שהם לא משתמשים בהם.
  • (FLT:0) דחייה של עקרון (DIR): 1FLT:1 מודולים ברמה גבוהה לא צריך להיות תלוי במודולים ברמה נמוכה; שניהם צריכים להיות תלויים מופשטים.

עקרון אחריות יחיד: בניית בלוקים שעושים דבר אחד טוב

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

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

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

קוד פתוח/סגור: סיום ללא שוברים

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

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

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

Liskov Substitution Principle: Parts בלתי ניתנים לשינוי שעובד יחד

ה- Liskov Substitution Principle מבטיח כי שיעורים נגזרים יכולים להחליף את מעמדות הבסיס שלהם מבלי לשבור את התוכנית.אם תת-קבוצה מפרה LSP, קוד המסתמך על מעמד הבסיס להיכשל כאשר ניתנת לרמה, מה שהופך את הקוד לערעור ותלוי בהקשר.

הפרה קלאסית של LSP היא הבעיה המסובכת של ריבוע (אם יש לך מעמד 6FLT) עם סטים רוחב וגובה, ו-FLT 7 תת-מחלקה אשר מעלים את אותם המדפים כדי לשמור על רוחב וגובה שווה, אז קוד אשר מצפה ל-FLT:8 עשוי לשבור כאשר עבר FPLT 9.

כדי לדבוק ב-LSP, לתכנן את ממשקים ואת שיעורי הבסיס עם חוזים התנהגותיים בראש. השתמש בטכניקות עיצוב-על-ידי-contract: מסמך תנאים מוקדמים, תנאי דואר, ו- invariants. subclasses חייב לכבד חוזים אלה.כאשר אתה יוצר מרכיב שניתן להגדרה מחודשת המסתמך על סוג בסיס, LSP מבטיח כי כל תת-classed היטב יעבוד.זה מאפשר פרויקטים אחרים להרחיב את הרכיב שלך עם העקרון האמיתי, אשר פועל באמת.

מיפוי פשטות: חוזים קטנים, ממוקדים

ה- Interface Segregation Principle מייעץ נגד ממשקי שומן שמחייבים את הלקוחות להיות תלויים בשיטות שהם לא משתמשים בהן.כאשר מחלקה מיישמת ממשק עם שיטות רבות, ייתכן שיהיה צורך לספק יישום ריק או לזרוק שיטות שאינן רלוונטיות למטרה שלה.זה יוצר הפיכה בין התנהגויות שאינן קשורות והופך את השיעור קשה יותר לשימוש מחדש. ISP פותר את זה על ידי פיצול ממשקים גדולים לשיטות קטנות יותר, ספציפיות יותר.

שקול ממשק שנקרא (FLT:10) שיש לו שיטות ליצירת PDF, CSV ו- HTML דוחות. מחלקה שצריכה רק לייצר דוחות PDF, היא מוכרחה להיות תלויה בשיטות CSV ו- HTML.זה לא רק הופך את השיעור קשה יותר להבין, אלא גם מגביר את הסיכון של שינוי אם הממשק מתפתח.

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

הסתברות: תלוי בפירושים, לא במתינות

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

לדוגמה, שירות רישום משתמשים לא צריך להיות תלוי ישירות על שיעור מסד הנתונים של MySQL במקום, להגדיר ממשק כמו FLT:14 עם שיטות לחיסכון ולחדש משתמשים.שירות הרישום תלוי ממשק זה. הטמעת קידוד, כגון FLT:15:15 או FLT:16 או FLT:16, מוזרקים בריצה דפוס זה, המכונה הזרקת תלות, מאפשר את אותו לוגיקה לשימוש חוזר בפרויקטים שונים.

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

שילוב עקרונות: הסינרגיה שיוצרת מערכות אמינות

עקרונות SOLID אינם כללים מבודדים; הם מחזקים אחד את השני.SRP יוצר כיתות ממוקדות שמובילות באופן טבעי לממשקים קטנים (ISP) OCP מעודד פולימורפיזם, אשר תלוי ב-LSP עבור החלפת תיקון.DIP כל דבר יחד על ידי הבטחת מדיניות ברמה גבוהה נשאר עצמאי של פרטי יישום. כאשר אתה מחיל את כל חמשת העקרונות יחד, אתה יוצר מערכת שבה ניתן לחלק, לשתף, עם מאמץ מינימלי ומינימום.

גישה מעשית אחת היא להתחיל עם SRP ו- ISP. לזהות את האחריות הליבה בתחום שלך ולהגדיר ממשקים צרים עבור כל אחד מהם, ולאחר מכן ליישם DIP על ידי הפיכת לוגיקה עסקית שלך תלויה ממשקים אלה. השתמש ב- OCP כדי לעצב נקודות שבו התנהגות חדשה ניתן להוסיף מבלי לשנות קוד קיים.בסוף, ודא כי ההיררכיה המעמדית שלך לדבוק ל-LSP על ידי כתיבת בדיקות כי יישום זה עובד לייצר באופן טבעי קוד זה הוא קל יותר לחבילה.

תפיסה שגויה נפוצה היא שעקרונות SOLID חלים רק על שפות מוכוונות.למעשה, המושגים מתרגמים היטב לתכנות פונקציונלית, מיקרו-שירותים ואפילו עיצוב API. הרעיון הליבה – חששות נפרדים, תלויים בהפשטות, ועיצוב להרחבה – הוא אוניברסלי.אם אתה כותב מודול שירות JavaScript, חבילת עבודה או ספריית Python, SOLID מספקת דרך ליצירת קוד זה נעים בין פרויקטים.

מלכודות נפוצות בעת הפעלת SOLID עבור אחריות

גם עם הבנה חזקה של SOLID, מפתחים לעתים קרובות לעשות טעויות כי לערער את האחריות.שגיאה תכופה אחת היא over-engineering. החלת העקרונות באופן דוגמטי יכול להוביל לשכבות מופרזות של מופשטות, מה שהופך את הקוד קשה יותר להבין ולשמור.המטרה היא לא להשתמש בכל עיקרון בכל מחלקה, אלא ליישם אותם איפה הם מספקים תועלת ברורה.

עוד נפילה מזניחת את העלות של תלותיות. מרכיב שניתן להעלות במסגרת גדולה או בספריה לא יכול להיות ניתן לשנות בכל הפרויקטים המשתמשים בערימה שונה. שמור על תכונות המינימום והמעדיפים ספריה סטנדרטיות או חבילות קטנות וממוקדות.זה תואם עם ISP ו- DIP: הפשטות שלך לא צריכה לכפות על הצרכנים לאמץ תלות לא רצויה.

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

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

דוגמה אמיתית לעולם: בניית ספריית אי-ההזדהות

כדי לראות SOLID בפעולה, לדמיין בניית ספריית הודעה שניתן להשתמש בה על פני פרויקטים מרובים.הספריה חייבת לתמוך בערוצים שונים: דואר אלקטרוני, SMS, לדחוף הודעות, והודעות ללא SOLID, ייתכן שתיצור מונוליטית (FLT:17) עם שיטה שלוקחת פרמטר ערוץ ומשתמשת בתנאי לשלוח את ההודעה.

החלת SRP, אתה מתפצל אחריות: AFLT:18 מארגן את התהליך, בעוד שיעורים בודדים לשלוח מטפל כל ערוץ.שימוש ISP, אתה מגדיר ממשק צר FLT:19 עם שיטה אחת (FLT:20 כל ערוץ ליישם את ממשק זה.

התוצאה היא ספרייה שכל פרויקט יכול להשתמש בה.פרויקט שרק צריך אימייל יכול ליישר את ה-FLT:24 ולהעביר אותו לשולח.פרויקט שדורש ערוצים מרובים יכול לרשום מספר שולחנים.הספריה ניתנת לבדיקה כי כל שולח יכול להיות לעג.ערוצים חדשים נוספו ללא שינוי קוד קיים.

צעדים מעשיים להתחיל ליישם SOLID היום

אם אתה חדש SOLID, להתחיל קטן.בחר עיקרון אחד וליישם אותו לכיתה או מודול יחיד. לספק מחלקה שיש לו אחריות רבה בכיתות נפרדות (SRP) ולאחר מכן, לזהות מקום בבסיס הקוד שלך שבו אתה משתמש תנאים כדי להתמודד עם התנהגויות שונות ולהחליף אותם עם פולימורפיזם (OCP). כמו שאתה מקבל ביטחון, מציג ממשקים וזריקת תלות (DIP).

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

לקריאה נוספת, לחקור את המשאבים הסמכותיים הללו על עקרונות עיצוב ועיצוב מוכווני אובייקטים:0רוברט C. Martin מאמרו המקורי של SRPGFLT:1, FLT:2 כניסת ויקיפדיה לעקרונות SOLIDOVASFLT 3 המספק סקירה מקיפה, ומדריך מעשי של FLT:4DigitalOcean ל-SOLIDFID:5 LT-gnoaדוגמאות.

אחריות: איך לדעת שאתה סובל

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

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

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