Egyéb programozási tanácsok

Egyéb programozási tanácsok

Programozási praktikák

Ebben a fejezetben a legfontosabb technikákat írom le, melyeket mindenképpen érdemes elsajátítani. Ezek mindegyike hivatásos programozóktól ered, de hogy használod-e őket, az természetesen csakis tőled függ.

Varázsszámok

Lehetőleg kerüld az úgynevezett "varázsszámok" használatát. Ezek azok a számok, amelyek a deklarációs rész után szerepelnek a kódban (kivéve a 0 és az 1):

If helyekSzama < 80 Then
Writeln('Maradt még üres hely.')
Else
Writeln('Nem maradt üres hely.');

Itt a 80 varázsszám. Érdemesebb az ilyen számokat konstansként felvenni, különösen akkor, ha többször is előfordul. Amikor meg kell változtatni ezt az értéket, csak egy helyen kell, mégpedig a konstans deklarációs részében. (Ahelyett, hogy ki kellene bogarászni a kódban az összes előfordulást.)

Strukturáltság

Törekedjünk a jól strukturált programok írására! Válasszuk szét az egybetartozó programrészeket, és helyezzük őket modulokba, osztályokba. Készítsünk eljárásokat, függvényeket minden egyes külön feladathoz. Egy eljárás vagy függvény mindig egyszerre csak egy dolgot csináljon, mégpedig azt, amire a neve is utal. Törekedjünk a rövid függvényekre (30-40 sornál ne nagyon legyen hosszabb), de arra is vigyázzunk, nehogy átláthatatlanul sok legyen.

Védekező programozás

Egy eljárás vagy függvény megírásakor a következőre kell ügyelnünk: sose bocsátkozzunk feltételezésekbe a paraméterekkel szemben!
Pl.: a következő függvény megvizsgálja, hogy az adott szám prím-e:

Function Primszam(szam: Integer): Boolean;
Begin
    If szam >= 0 Then Begin
        {Osztók vizsgálata}
        ...
    End
    Else Begin
        Writeln('Hiba a Primszam()-ban: a paraméter negatív');
        Primszam := False;
    End;
End;

Ebben a kódban hibaüzenettel leállna a program, ha nem vizsgálnánk meg szám előjelét (mivel a mod csak pozitív számokra van értelmezve). Attól függetlenül, hogy (ismerve magunkat) sosem adnánk meg negatív számot paraméterként ennek a függvénynek, mindig készüljünk fel az esetleges hibalehetőségekre.
A hiba kezelése tetszőleges lehet. (Akár saját hibaüzenetet is generálhatunk.) Ez a fajta óvatosság hosszabb programoknál elengedhetetlen.

Adatrejtés

Az adatrejtés (vagy egységbezárás) elve különösen objektumorientált nyelveknél fontos. Minden változót vagy függvényt a lehető legkisebb kiterjedésben deklarálunk, azaz elzárjuk a külvilágtól, megvédve attól, hogy arra jogosulatlan elemek is használhassák. Másképpen szólva: minden egyes tag csak annyi másikat ismerhet, amennyire a működéséhez feltétlenül szüksége van. Ez a programozó szempontjából is előnyösebb: így pontosan tudja, hogy egy változót melyik eljárás használja, illetve könnyebb annak a visszakeresése is az adott blokk deklarációs részében.
Pl.: a Load() eljárás használ egy f nevű változót a fájlok megnyitásához, illetve bezárásához. Az f változót felesleges globálisként deklarálnunk, hiszen csak egyetlenegy eljárás használja. Ugyanakkor nemcsak felesleges, hanem veszélyes is: sosem tudhatjuk, hogy egy másik eljárás nem akarja-e használni ugyanazt a változót. Ha igen, a végzetes hiba elkerülhetetlen.

Ciklusok

Kerüljük a mélyen egymásba ágyazott ciklusokat! Hiba esetén ugyanis nagyon nehézkessé válik a debuggolás. Legyen 3 mélységű ciklus a maximális. Ha szükséges, helyezzük a belső ciklusokat külön eljárásba, amit majd külön meghívunk.

Globális változók

Mint az előbb már írtam, a globális változók különösen sok hibalehetőséget rejtenek magukban. Mégis, sok esetben elengedhetetlenek a használatuk. (Pontosabban csak nagyon nehezen kerülhetők meg.) Ha egy változót legalább két egyenrangú eljárás közösen használ, vagy gyakran kell megváltoztatni az értékét, akkor érdemes globális változót használni.
Egy dologra azonban különösen figyeljünk: soha ne adjunk át paraméterként globális változót! Főleg akkor nem, ha cím szerint adjuk át. Ekkor ugyanis két különböző néven keresztül férhet hozzá az eljárás ugyanahhoz a változóhoz.

Privát tagok

Objektumorientált nyelveknél egy osztályon belül lehetőleg csak privát adatok szerepeljenek. Ha az egyik változó értékét szeretnénk lekérdezni vagy megváltoztatni, azt függvényen illetve eljáráson keresztül tegyük. Erre néhány nyelvben az ún. property használata a legalkalmasabb.
Ezáltal megakadályozhatjuk, hogy egy változónk rossz értéket vegyen fel, illetve megtagadhatjuk mások számára a módosítás jogát.

Erőforrások

Egy erőforrást (fájl, adatbázis) a lehető legkevesebb ideig célszerű használni. Hálózati programozás esetén ez különösen fontos. Ha egy fájlt megnyitunk, olvassunk ki belőle minden adatot (még ha nincs is rá rögtön szükségünk), majd zárjuk be. Sosem lehet tudni, hogy mi történhet egy megnyitott fájllal, ha a program egy része nem úgy viselkedik, ahogyan azt elvárnánk.

További trükkök

Rövidítések

Sok különböző lehetőségünk van arra, hogy az egyes utasításokat lerövidítsük, egyszerűsítsük. Azonban a túlzott ügyeskedés könnyen olvashatatlanná teszi a kódot. Ügyeljünk tehát arra, hogy a tömörítés ne váljon az olvashatóság kárára.

Feltételek

Ha egy változó boolean típusú, akkor felesleges egy if szerkezetben vizsgálni, hogy értéke megyenyzik-e a true vagy false konstansokkal. Pl.:

If vege = True Then ...
If paratlan = False Then ...

helyett elég lenne, hogy

If vege Then ...
If Not paratlan Then ...

Sok esetben olvashatóbb, ha megfelelően választjuk ki a boolean változónevet.

Feltételes értékadás

Egy boolean típusú változónak szeretnénk értéket adni, mégpedig egy adott kifejezéstől függően. A legkézenfekvőbb megoldást így írnánk meg:

If szam < 0 Then
negativ := True
Else
negativ := False;

Azonban ha jobban megfigyeljük, a vizsgálandó kifejezés is egy boolean érték. A fenti programot akár így is írhattuk volna:

negativ := (szam < 0);
{vagy}
negativ := szam < 0;

Mivel a szam < 0 kifejezést előbb értékeli ki a fordító, a zárójeleket akár el is hagyhatjuk. Csupán az olvashatóságot könnyítik meg.

Ez és az előző megoldás csupán szintaktikailag különböző, a fordítóprogram ugyanis mindkét esetben azonos gépi kódot generál. Így a választás a programozóra van bízva.