Kód áttekintés: A szélsőséges jogsértések általános forrásai és hogyan lehet elkerülni a javításukkal kapcsolatos érveket

Kések készülnek. A pengék élesek a konfliktusok miatt. A fejlesztők között vita merül fel. A kódológépek szenvedélyeit nem a hibás szoftverek, hanem a jelek szerint tömören tömör vagy szóbeszédű kódok gyulladják meg. Ezek a vonalak a hack jeleit jelentik. Bármely programozó, aki nem ért egyet, amatőr. Csak egy neofita képes olyan módszereket és blokkokat előállítani, amelyek nyilvánvalóan sértik a jó ízlést. Ennek ellenére a konfliktus és a vitriol forrása a különböző preferenciák, nem pedig a természet törvényei. A fejlesztők közötti gyűlölet ebben az esetben a különböző célok tömörségének kereskedése iránti eltérő hajlam eredménye. Ezek a célok és a hozzájuk való hajlam minden fejlesztőnél eltérőek, és bizonyos területeken állandó konfliktushoz vezetnek. Az egyik ilyen hely a kifejezett vagy pithy kód. A harc minimalizálása érdekében a csapat kód-áttekintések segítségével kiemelheti a legfélékesebb szegmenseket, és a csoport vitatkozhat ezekkel a részekkel szemben, ahelyett, hogy a kódbázis minden sorában és blokkjában vitatkozna.

Bizonyos kódkonstrukciók vagy technikák valószínűleg a szélsőséges jogsértéseket eredményezik, és érveléshez vezetnek az említett jogsértések kijavításával kapcsolatban. E visszaélések kijavítása intenzív érvekhez vezet. Ezeket a nézeteltéréseket az alábbiakban felsorolt ​​nyelvi jellemzők és technikák tekintetében meg lehet oldani, vagy legalábbis szétválaszthatjuk.

Feltételes üzemeltető vs. nyilatkozat

A nyelvi elemek, a feltételes operátor és az if-állítás érvekhez vezetnek, és a különféle táborok azzal érvelnek, hogy mindegyik a magasabb rendű technika bizonyos műveleteknél. Ezeket a műveleteket számtalan módon lehet végrehajtani, mindegyik technika előnyeket és hátrányokat hozva.

Ha nyilatkozat: Az if-állítás hozzájárulhat a félelmetesen terjedelmes kód létrehozásához, ha a feltételek sűrűsége magas. A nagy sűrűség miatt a blokk vagy módszer puffasnak tűnik. Ugyanakkor az if-utasításokkal írt kód szintén nagyon hibakereshető, mivel a fejlesztő léphet minden soron.

ha (label1IsRequired) {
 label1.Color = “piros”;
} más {
 label1.Color = “fekete”;
}
ha (label2IsRequired) {
 label2.Color = “piros”;
} más {
 label2.Color = “fekete”;
}
ha (label3IsRequired) {
 label3.Color = “piros”;
} más {
 label3.Color = “fekete”;
}

Feltételes operátor: A feltételes operátor vezethet néhány látszólag törésvonalat, amikor több if-állítás helyettesítésére használják. A beágyazott feltételes operátorok a kódot, ha véglegessé teszik, nagyon nehezen olvashatók, tesztelhetők vagy hibakereshetők. Bármely blokk vagy módszer, amely feltételes operátorok esetén nehéz, szintén nagyon kompakt, csökkentve a fejlesztők által beolvasandó kód mennyiségét.

healthIndicatorColor = (health == „Jó”)? „Zöld”: (egészség == „tisztességes”)? „Sárga”: (egészség == „rossz”)? „Piros”: (egészség == „élet_támogatás”)? „Narancs”: „lila”;

Potenciális felbontás: A feltételes operátorok akkor hasznosak, ha helyettesítik az if-utasításokon keresztül megvalósított feltételek alapján meghatározott nagy értékek sűrűségét. A feltételes szereplők pusztítóak, amikor még néhány, egymásba ágyazott döntést felváltanak. Az egy sorra átalakíthatóan illeszkedő imperatívák fő célja a feltételes operátorok számára, míg a több sorot igénylő feltételek az if-utasítások tartománya. Az if-állítások vagy a feltételes operátorok bármilyen szélsőséges használatát ki kell javítani, hogy telepítsék ezen konstrukciók egyikének megfelelő használatát. (Megjegyzés: A módosításhoz jelentős refaktor szükséges.)

if (egészség == „jó”) {
 healthIndicatorColor = „zöld”;
} máshol, ha (egészség == „tisztességes”) {
 healthIndicatorColor = „sárga”;
} máshol, ha (egészség == „rossz”) {
 healthIndicatorColor = „piros”;
} egyébként, ha (egészség == „élet_támogatás”) {
 healthIndicatorColor = „narancs”;
} más {
 healthIndicatorColor = “lila”;
}
label1.Color = (label1IsRequired)? "piros fekete";
label2.Color = (label2IsRequired)? "piros fekete";
label3.Color = (label3IsRequired)? "piros fekete";

Több visszatérési nyilatkozat vs. egy visszatérési nyilatkozat

Két érvhez vezető stílus a több visszatérés és az egyszeri visszatérés. Vita merül fel arról, hogy a módszereknek rendelkezniük kell-e egy visszatérési nyilatkozattal, vagy elfogadhatók-e több visszatérési nyilatkozat. Mindegyik megközelítés pozitív és negatív.

Többszörös visszatérési nyilatkozatok: A többszörös visszatérési nyilatkozatok hozzájárulhatnak a kód megértéséhez, követéséhez és teszteléséhez. A többszörös visszatéréssel rendelkező módszerek azonban rövidebbek lehetnek, mint az egyetlen visszatérésű funkciók.

SomeDataType someMethod (param1, param2, param3) {
 SomeDataType retVal;
 if (param1 == null) {
 retVal = null
 }
 if (retVal == null) {
 visszatérő retVal;
 }
 
 if (param2! = null) {
 retVal = param2;
 }
 ha (retVal.Equals (param2)) {
 visszatérő retVal;
 }
 
 retVal = param3;
 visszatérő retVal;
}

Egy visszatérési nyilatkozat: Egy visszatérési nyilatkozat hosszú módszerekhez vezethet. Ezeknek az eljárásoknak azonban egyetlen pontja van, így egyszerűbbé válik a tesztelés és a hibakeresés.

SomeDataType someMethod () {
 SomeDataType retVal;
 // százezrek vagy sorok kódja
 visszatérő retVal;
}

Lehetséges megoldás: A többszörös visszatérés megnehezíti a kód megértését, követését és tesztelését, ha azokat következetlenül használják. Az egyetlen visszatérési nyilatkozat hosszú módszerekhez vezet, amikor hosszú kódszakaszokkal hajtják végre őket. Ezeket a kihúzott szakaszokat lerövidítheti vagy legalább olvashatóvá teheti, ha egy helyett több visszatérési nyilatkozatot használ. Az egyszeri visszatérés teljesen elfogadható, ha rövid kódkövetést követnek. Az egyetlen visszatérési nyilatkozat vagy a többszörös visszatérítés visszaélésszerű használatát ki kell javítani, hogy alkalmazni lehessen az egyik stílus elfogadott felhasználási esetét. (Megjegyzés: a korrekcióhoz jelentős refaktor szükséges.)

SomeDataType someMethod (param1, param2, param3) {
 if (param1 == null || param3 == null) {
 visszatérés null;
 }
 
 SomeDataType retVal = null;
 if (param2! = null {
 retVal = param2;
 } máshol, ha (param1! = null) {
 retVal = param1;
 } ele if (param3! = null) {
 retVal = param3;
 }
 visszatérő retVal;
}
SomeDataType someMethod (param1, param2) {
 SomeDataType retVal = null;
 mert (int i = 0; i  ha a (param1 [i] .equals (param2)) {
 retVal = param1 [i];
 szünet;
 }
 }
 visszatérő retVal;
} Használat megszakítása és folytatása a hurkokban

A szünet és a folytatott konstrukciók intenzív viták tárgyát képezik. Az érv egyik oldalán a fejlesztők azzal érvelnek, hogy a törés és folytatás egyszerűsítheti a vezérlőáramlást. Más programozók szerint ezek a szolgáltatások bonyolultabbá teszik a program logikáját. A törés és folytatás feltétlenül használható a kód egyszerűsítésére vagy bonyolítására. Ezek a vonalak észrevehetők.

Break és a használat folytatása: Az elemek egyszerűsíthetik a kódot, de szükségtelenül bonyolíthatják őket.

SomeDataType someMethod (param1, param2) {
 SomeDataType retVal = null;
 mert (int i = 0; i  if (param1 [i] == null) {
 Folytatni;
 }
 ha a (param1 [i] .equals (param2)) {
 retVal = param1 [i];
 szünet;
 }
 }
 visszatérő retVal;
}
SomeDataType someMethod (adatok, 1. param) {
 SomeDataType retVal = null;
 csinálj valamit:
 mert (int i = 0; i  if (i> = adat.hossz) {
 szünet;
 }
 ha a (adatok [i] .equals (param1)) {
 retVal = adatok [i];
 } más {
 Folytatni;
 }
 }
if (retVal == null) {
 adatok - refreshData ();
 Goto dosomething;
 }
visszatérő retVal;
}

Lehetséges megoldás: A legtöbb fejlesztő azt állítja, hogy a kódnak egyszerű mechanizmusokat kell használnia a vezérlőáramláshoz. A vita forrása az, hogy mely konkrét mechanizmusok egyszerűek. Ez az érv sokkal kevésbé melegszik, ha az egyes eszközöket széles körben elfogadott módon használják. Az elfogadott megközelítések léteznek szünetként és folytatódnak. Tartsa be ezeket az egyezményeket a nézeteltérések elkerülése és az ellenőrzés folyamatának egyszerűsítése érdekében. Bármely ellenőrzési eszközt, amely nyilvánvalóan sérti ezeket a szabványokat, viták nélkül ki kell javítani.

SomeDataType someMethod (adatok, 1. param) {
 SomeDataType retVal = null;
 mert (int i = 0; i  if (adatok [i] == null) {
 Folytatni; // hagyja ki a hurok többi részét
 }
 ha a (adatok [i] .equals (param2)) {
 retVal = adatok [i];
 szünet; // ne hurkoljon többé b / c
 }
 }
 visszatérő retVal;
}

Védekező kivételek

A kivételek a probléma jelzésére vagy a jövőbeli problémák elkerülésére szolgálnak. Milyen fejfájást kell jeleznie vagy elhárítania a kódex egyes részei miatt, heves vita. A nézeteltérés egyik végén a kódolók azzal érvelnek, hogy az átfogó védekező kivételek megakadályozzák a hibákat és megkönnyítik azok helyét. A védelem mosodai listája azonban a kód felfúvódását és nehezen érthetővé teheti, amint egyes programozók azt állították. A vita mindkét oldalán levő fejlesztőknek van egy pontjuk. A védekező kivételeknek mind előnyei, mind hátrányai vannak.

A védekező kivételek előnyei és hátrányai: A hibák és más problémák elleni védelmet minimális hátrányokkal lehet védeni a védekező kivételek felhasználásával. Ezek a hibák nagyobbak lesznek, ha a technika megkülönböztetéstől mentes.

void someMethod (1. és 2. param) {
 if (param1 == null || param2 == null) {
 dobjon új ArgumentNullException („Egy vagy több paraméter hiányzik”);
 }
 // do módszer cucc
}
void someMethod (1. és 2. param) {
 // tucatnyi védekező ellenőrzés sor ...
 // végezzük el a módszer többi részét
}

Lehetséges megoldás: A védekező kivételek hiányosságai a legkisebbek, ha elfogadott gyakorlatban alkalmazzák őket. Az ezen egyezményektől eltérő technika alkalmazását ki kell javítani, kivéve ha kényszerítő ok mutatkozik be.

public void someMethod (1. és 2. param) {
 // ellenőrizze az egyes paramétereket nyilvános módszerrel
 if (param1 == null || param2 == null) {
 dobjon új ArgumentNullException („Egy vagy több paraméter hiányzik”);
 }
 
 // elhárítja a hibákat, amelyeket érvénytelen adatok okoznak
 if (! is érvénytelen (1. param) ||! is érvénytelen (2. param)) {
 dobjon új InvalidParameterException („Egy vagy több paraméter érvénytelen”);
 }
 
 // csinálj valamit a paraméterekkel
}

Wrap-up

Ezeket a kódkonstrukciókat és technikákat a jó és a rossz fejlesztők is használják. A programozók emberek. Az embereknek tendenciái vannak. Ezek a hajlamok kódban mutatkoznak meg. Időnként egy fejlesztő ösztönzése arra készteti őt, hogy írjon olyan kódot, amelyet más kódolók jogosan kritizálnak. A megsérült fejlesztő nem feltétlenül rossz programozó. Az őt kritizáló kódoló nem feltétlenül jó fejlesztő. Mindkét embert valószínűleg félrevezetik egy időben preferenciáik. Ezeknek a vágyaknak nem szabad a fejlõdésnek arra vezetni, hogy az egymással összegyûjtött sértések végtelenségévé váljon. Inkább a programozóknak felül kell vizsgálniuk egymás kódját, a csatáikat a legrosszabb szakaszokra kell korlátozniuk, és megállapodniuk kell bizonyos érvek rendezésében a fent leírt szabályok segítségével.