עפֿן / קלאָוזד, לויט די סאָליד פּרינציפּ

ווייכווארג ענטיטיז (קלאסן, מאַדזשולז, פאַנגקשאַנז, אאז"ו ו) זאָל זיין אָפן פֿאַר פאַרלענגערונג, אָבער פֿאַרמאַכט פֿאַר עדיטינג.

דיזיינינג די ווייכווארג: מאַדזשולז, קלאסן און פאַנגקשאַנז אַזוי אַז ווען נייַ פאַנגקשאַנאַליטי איז נידאַד, מיר זאָל נישט מאָדיפיצירן די יגזיסטינג קאָד, אָבער שרייַבן נייַ קאָד וואָס וועט זיין געוויינט דורך יגזיסטינג קאָד. דאָס קען געזונט מאָדנע, ספּעציעל מיט שפראכן ווי Java, C, C ++ אָדער C #, וווּ עס אַפּלייז ניט בלויז צו די מקור קאָד זיך אָבער אויך פֿאַר די ביינערי. מיר וועלן צו שאַפֿן נייַע פֿעיִקייטן אין וועגן וואָס טאָן ניט דאַרפן רידיסטראַביושאַן פון יגזיסטינג בינאַריעס, עקסעקוטאַבלעס אָדער דללס.
OCP אין די סאָליד קאָנטעקסט

קאָמפּלעמענטאַרי סרפּ און אָקפּ

מיר האָבן שוין געזען די SRP פּרינציפּ פון איין רעספּאָנסיביליטי וואָס שטייט אַז אַ מאָדולע זאָל האָבן בלויז איין סיבה צו טוישן. די פּרינציפּן פון OCP און SRP זענען קאַמפּלאַמענטשי. דער קאָד דיזיינד לויט די SRP פּרינציפּ וועט אויך רעספּעקט די OCP פּרינציפּן. ווען מיר האָבן קאָד מיט בלויז איין סיבה צו טוישן, די ינטראַדוסינג אַ נייַע שטריך וועט מאַכן אַ צווייטיק סיבה פֿאַר די ענדערונג. אַזוי ביידע SRP און OCP וואָלט זיין בריטשט. פּונקט אַזוי, אויב מיר האָבן קאָד וואָס זאָל נאָר טוישן ווען די הויפּט פונקציע ענדערונגען און זאָל בלייבן אַנטשיינדזשד ווען נייַ פאַנגקשאַנאַליטי איז מוסיף, אַזוי רעספּעקט די OCP, עס וועט מערסטנס רעספּעקט SRP.
דאָס קען נישט מיינען אַז SRP שטענדיק פירן צו OCP אָדער וויצע ווערסאַ, אָבער אין רובֿ קאַסעס אויב איינער פון זיי איז אַדכירד צו דערגרייכן די רגע איז גאַנץ פּשוט.

בייַשפּיל פון הילעל פון די OCP פּרינציפּ

פֿון אַ ריין טעכניש פונט פון מיינונג, די עפֿענען / קלאָוזד פּרינציפּ איז זייער פּשוט. א פּשוט שייכות צווישן צוויי קלאסן, ווי די ונטער, ווייאַלייץ די OCP פּרינציפּ.

דער באַניצער קלאַס ניצט די לאָגיק קלאַס גלייַך. אויב מיר דאַרפֿן צו ינסטרומענט אַ רגע לאָגיק קלאַס אַזוי אַז מיר קענען נוצן די קראַנט און די נייַע, די יגזיסטינג לאָגיק קלאַס דאַרף זיין טשיינדזשד. דער באַניצער איז גלייַך טייד צו די ימפּלאַמענטיישאַן פון די לאָגיק, עס איז קיין וועג פֿאַר אונדז צו צושטעלן נייַ לאָגיק אָן אַפעקטינג די קראַנט. און ווען מיר רעדן וועגן סטאַטיקלי טייפּט שפּראַכן, די באַניצער קלאַס איז זייער מסתּמא צו דאַרפן מאַדאַפאַקיישאַנז. אויב מיר רעדן וועגן צונויפגעשטעלט שפּראַכן, דאָך די עקסעקוטאַבלע באַניצער און די לאָגיק עקסעקוטאַבלע אָדער די דינאַמיש ביבליאָטעק דאַרפֿן רעקאָמפּילאַטיאָן און עקספּרעס, בעסער צו ויסמיידן ווען מעגלעך.

מיט דערמאָנען די פריערדיקע סכעמע, מיר קענען אַרויסדרינגען אַז קיין סאָרט וואָס ניצט גלייך אַן אנדערן קלאַס קען פירן צו די הילעל פון די עפֿן / קלאָוזד פּרינציפּ. 
זאל ס רעכן מיר וועלן צו שרייַבן אַ קלאַס וואָס קענען צושטעלן די פּראָגרעס "אין פּראָצענט" פון אַ דאַונלאָודיד טעקע דורך אונדזער אַפּלאַקיישאַן. מיר וועלן האָבן צוויי הויפּט קלאסן, אַ פּראָגרעס און אַ טעקע, און איך טראַכטן מיר וואָלט ווי צו נוצן זיי ווי גייט:

function testItCanGetTheProgressOfAFileAsAPercent () {
     $ טעקע = נייַ טעקע ();
     $ טעקע-> לענג = 200;
     $ טעקע-> געשיקט = 100;
     $ פּראָגרעס = נייַ פּראַגרעס ($ טעקע);
     $ this-> assertEquals (50, $ progress-> getAsPercent ());
}

אין דעם קאָד מיר זענען פּראָגרעס וסערס. מיר ווילן צו באַקומען אַ ווערט ווי אַ פּראָצענט, ראַגאַרדלאַס פון די פאַקטיש טעקע גרייס. מיר נוצן File ווי אַ מקור פון אינפֿאָרמאַציע. א טעקע האט אַ לענג בייט און אַ פעלד גערופֿן געשיקט וואָס רעפּראַזענץ די סומע פון ​​דאַטן געשיקט צו די דאָוונלאָאַדער. מיר טאָן ניט זאָרגן ווי די וואַלועס זענען דערהייַנטיקט אין די אַפּלאַקיישאַן. מיר קענען יבערנעמען אַז עס איז עטלעכע מאַדזשיקאַל לאָגיק וואָס טאָן דאָס פֿאַר אונדז, אַזוי אין אַ פּראָבע מיר קענען שטעלן זיי בפירוש.

קלאַס טעקע {
     פובליק $ לענג;
     ציבור $ געשיקט;
}

דער טעקע קלאַס איז נאָר אַ פּשוט דאַטן כייפעץ מיט די צוויי פעלדער. דאָך עס זאָל אויך אַנטהאַלטן אנדערע אינפֿאָרמאַציע און ביכייוויערז, אַזאַ ווי פילענאַמע, דרך, קאָרעוו דרך, קראַנט וועגווייַזער, טיפּ, פּערמישאַנז, און אַזוי אויף.

קלאַס פּראָגרעס {

     פּריוואַט $ טעקע;

     פונקציע __קאָנסטרוקט (טעקע $ טעקע) {
          $ טהיס-> טעקע = $ טעקע;
     }

     פונקציע getAsPercent () {
          צוריקקומען $ דאָס-> טעקע-> געשיקט * 100 / $ דעם-> טעקע-> לענג;
     }

}

פּראָגרעס איז פשוט אַ סאָרט וואָס אַקסעפּץ אַ טעקע אין זיין קאַנסטראַקטער. פֿאַר קלעריטי, מיר האָבן ספּעציפיצירט די טיפּ פון בייַטעוודיק אין די קאָנסטרוקטאָר פּאַראַמעטערס. עס איז אַ איין נוציק אופֿן אויף פּראָגרעס, getAsPercent (), וואָס וועט נעמען די געשיקט וואַלועס און לענג פֿון טעקע און קער זיי אין אַ פּראָצענט. פּשוט און עס אַרבעט.

דער קאָד איז ריכטיק, אָבער עס ווייאַלייץ די עפֿענען / קלאָוזד פּרינציפּ.

אָבער וואָס?

און ווי אַזוי?

זאל ס פּרובירן צו טוישן די באדערפענישן

יעדער אַפּלאַקיישאַן צו אַנטוויקלען זיך מיט צייט וועט דאַרפֿן נייַ פֿעיִקייטן. א נייַע שטריך פֿאַר אונדזער אַפּלאַקיישאַן קען זיין צו לאָזן מוזיק סטרימינג אַנשטאָט פון בלויז דאַונלאָודינג טעקעס. די לענג פון דער טעקע איז רעפּריזענטיד אין ביטעס, די געדויער פון די מוזיק אין סעקונדעס. מיר וועלן פאָרשלאָגן אַ פּראָגרעס באַר צו אונדזער צוהערערס, אָבער קענען מיר נוצן די אויבן געשריבן קלאַס?

ניין מיר קענען נישט. אונדזער פּראַגרעשאַן איז געבונדן צו טעקע. עס קען בלויז פירן טעקע אינפֿאָרמאַציע, כאָטש עס קען אויך זיין געווענדט צו מוזיק אינהאַלט. אָבער צו טאָן דאָס, מיר האָבן צו מאָדיפיצירן עס, מיר האָבן צו מאַכן פּראַגרעס וויסן די מוזיק און טעקעס. אויב אונדזער פּלאַן קאַמפּלייד מיט OCP, מיר טאָן ניט דאַרפֿן צו פאַרבינדן די טעקע אָדער פּראָגרעס. מיר קען נאָר רייוז יגזיסטינג פּראָגרעס און צולייגן עס צו מוזיק.

מעגלעך לייזונג

דינאַמיקאַללי טייפּט שפּראַכן האָבן די מייַלע פון ​​אָנפירונג כייפעץ טייפּס אין לויפן צייט. דאָס אַלאַוז אונדז צו באַזייַטיקן דעם טיפּ טיפּ פון די פּראָגרעס קאַנסטראַקטער און די קאָד וועט פאָרזעצן צו אַרבעטן.

קלאַס פּראָגרעס {

     פּריוואַט $ טעקע;

     פונקציע __קאָנסטרוקט ($ טעקע) {
         $ טהיס-> טעקע = $ טעקע;
     }

    פונקציע getAsPercent () {
         צוריקקומען $ דאָס-> טעקע-> געשיקט * 100 / $ דעם-> טעקע-> לענג;
     }

}

מיר קענען איצט אָנהייבן עפּעס ביי פּראַגרעס. און דורך עפּעס, איך מיינען ממש עפּעס:

קלאַס מוזיק {

פובליק $ לענג;
ציבור $ געשיקט;

פובליק $ קינסטלער;
פובליק $ אלבאם;
פובליק $ ריליסדאטע;

פונקציע getAlbumCoverFile () {
צוריקקומען 'בילדער / קאָווערס /'. $ דאָס-> קינסטלער. '/'. $ דעם-> אלבאם. '.פּנג';
}
}

און די מוזיק קלאַס ווי דער אויבן וועט אַרבעטן בישליימעס. מיר קענען לייכט פּרובירן עס מיט אַ פּראָבע וואָס איז זייער ענלעך צו טעקע.
function testItCanGetTheProgressOfAMusicStreamAsAPercent () {
$ מוזיק = נייַ מוזיק ();
$ מוזיק-> לענג = 200;
$ מוזיק-> געשיקט = 100;

$ פּראָגרעס = נייַ פּראַגרעס ($ מוזיק);

$ this-> assertEquals (50, $ progress-> getAsPercent ());
}

אַזוי בייסיקלי, יעדער מעזשעראַבאַל אינהאַלט קענען זיין געוויינט מיט די פּראַגרעס קלאַס. אפֿשר מיר זאָל עקספּרעסס עס אין קאָד דורך טשאַנגינג די בייַטעוודיק נאָמען:

קלאַס פּראָגרעס {

פּריוואַט $ מעזשעראַבאַל קאָנטענט;

פונקציע __construct ($ measureableContent) {
$ טהיס-> מעזשעראַבאַלContent = $ מעאַסוראַבלעקאָנטענט;
}

פונקציע getAsPercent () {
צוריקקומען $ דאָס-> מעזשעראַבאַל קאָנטענט-> געשיקט * 100 / $ דעם-> מעזשעראַבאַל קאָנטענט-> לענג;
}

}

ווען מיר ספּעציפיצירן טעקע ווי די טיפּ טיפּ, מיר זענען אָפּטימיסטיש וועגן וואָס אונדזער קלאַס קענען שעפּן. עס איז געווען יקספּליסאַט און אויב עפּעס אַנדערש וואָלט קומען, אַ גרויס גרייַז וואָלט זאָגן אונדז.

Uאַ קלאַס וואָס אָוווערריידז אַ מעטאָד פון אַ באַזע קלאַס אַזוי אַז דער באַזע קלאַס קאָנטראַקט איז נישט אַנערד דורך די דערייווד קלאַס. 

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

בשעת דער סוף רעזולטאַט איז די זעלבע אין ביידע קאַסעס, טייַטש די קאָד ברייקס, די ערשטע געשאפן אַ פייַן אָנזאָג. דאָס איז אָבער זייער פינצטער. עס איז קיין וועג צו וויסן וואָס די בייַטעוודיק איז - אַ שטריקל אין אונדזער פאַל - און וואָס פּראָפּערטיעס זענען געזוכט און ניט געפֿונען. עס איז שווער צו דיבוג און פאַרריכטן דעם פּראָבלעם. א פּראָגראַמיסט מוזן עפענען די פּראָגרעס קלאַס, לייענען און פֿאַרשטיין עס. דער אָפּמאַך, אין דעם פאַל, ווען איר טאָן ניט בפירוש ספּעציפיצירן די טיפּהינט, איז defiדורכגעקאָכט דורך די נאַטור פון פּראָגרעס. עס איז אַ ימפּלייד קאָנטראַקט באקאנט בלויז צו פּראָגרעס. אין אונדזער בייַשפּיל, עס איז defiדורכגעגאנגען דורך אַקסעס די צוויי פעלדער, געשיקט און לענג, אין די getAsPercent () אופֿן. אין פאַקטיש לעבן די ימפּלייד קאָנטראַקט קענען זיין זייער קאָמפּליצירט און שווער צו אַנטדעקן דורך נאָר קוקן פֿאַר אַ ביסל סעקונדעס אין קלאַס.

די לייזונג איז בלויז רעקאַמענדיד אויב קיינער פון די אנדערע עצות ונטער קענען זיין לייכט ימפּלאַמענאַד אָדער אויב זיי וואָלט פאַרשאַפן ערנסט אַרקאַטעקטשעראַל ענדערונגען וואָס טאָן נישט באַרעכטיקן די מי.

Ercole Palmeri