From bf8fe573a3512db6145f75f0a76a1853ae45a26d Mon Sep 17 00:00:00 2001 From: szabomarton Date: Fri, 24 Jan 2025 11:21:41 +0100 Subject: [PATCH] added solid --- adatstrukturak | 11 ++- cleancode | 178 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 188 insertions(+), 1 deletion(-) create mode 100644 cleancode diff --git a/adatstrukturak b/adatstrukturak index 151658d..0ce97b6 100644 --- a/adatstrukturak +++ b/adatstrukturak @@ -380,4 +380,13 @@ Beszúrásos rendezés Továbbá akkor igen hatékony, ha egy rendezett sorozatot bővítünk és a bővítés után is szeretnénk, hogy a sorozat rendezett maradjon. - Az algoritmus futási ideje legjobb esetben konstans, legrosszabb esetben négyzetes. \ No newline at end of file + Az algoritmus futási ideje legjobb esetben konstans, legrosszabb esetben négyzetes. + Pszeudokód: + Ciklus i = 6 -tól 1-ig + j = i - 1 + tmp = a[i] + AMÍG (j >= 0) és (a[j] > tmp) + a[j+1] = a[j] + j = j - 1 + a[j+1] = tmp + diff --git a/cleancode b/cleancode new file mode 100644 index 0000000..a301675 --- /dev/null +++ b/cleancode @@ -0,0 +1,178 @@ +Tiszta kód + +A tiszta kód olyan programkód, amely olvasható, könnyen érthető és karbantartható. +Ennek elérése érdekében a tiszta kód az egyszerűség, átláthatóság és megfelelő struktúra elveit követi. + +A tiszta kód elengedhetetlen a hosszú távú karbantartás és fejlesztás szempontjából. +Egy tiszta kódbázis segít a csapatot a hatékony együttműködésében, és csökkenti a hibák ekletkezésének esélyét. + +Olvashatóság A kódot más fejlesztők könnyen megérthetik. +egyszerűség A bonyolultság csökkentése gyorsabb hibajavítást és fejlesztést tesz lehetővé. +karbantarthatóság A kód hosszú távon fenntartható és módosítható marad. + +Olvashatóság + Azt jelenti, hogy a kód könnyen érthető mind a fejlesztők, mind a tesztelők számára. + Ennek érdekében: + használjunk értelmes változó és függvényneveket. + struktruáljuk a kódot logikus blokkokra. + használjunk megfelelő indentálást és sorhosszúságot. + +egyszerűség: + Az egyszerűség elve szerint a kódot a lehető legegyszerűbben kell megírni, miközben minden szükséges funkcionalitást megvalósít. + Kerüljük: + A felesleges bonyolultságot, + A fölösleges vagy redundáns kódrészeket + +karbantarthatóság + A karbantarthatóság érdekében a kódnak modulárisnak kell lennie, és megfelelően dokumentáltnak. + Ez azt jelenti, hogy a kódrészleteket könnyen újra lehet használni és módosítani. + +Kódolási szokások kialakítása + Kód átalakítása olvashatóbbá + Eredeti: + public int Szamol(int x, int y){ + return x * y + 10; + } + + átalakított: + public int TeljesArSzamitas(int mennyiseg, int egysegar){ + const int ado = 10; + return mennyiseg * egysegar + ado; + } + +indentálás és sorhosszúság + Indentálás: + Kövessük a nyelv által javasolt szabványokat + (C# esetáben 4 szóközel vagy tab karakterrel igazítjuk a sor elejét) + Sorhosszúság: + Tartsuk a sorokat 80 - 100 karakter között, + hogy a kód olvasható maradjon minden eszközön. + +Fehérterek XDDDD +Whitespace-ek és kommentek helyes használata + Hagyjunk üres sorokat a logikai blokkok között a kód strukturájának kiemelésére. + Használjunk szóközöket az operátorok körül a kód olvashatóságának javítása éredkében. + +Kommentek + A kommentek a kód megértését segítik, de csak akkor használjuk őket, ha valóban szükséges. + A fölösleges kommentek zavaróak lehetnek, és csökkentik az olvashatóságot. + + //A termék árának kiszámítása adóval + public int TeljesArSzamitas(int mennyiseg, int egysegar){ + const int ado = 10; + return mennyiseg * egysegar + ado; + } + +Megnevezési konvenciók és kódstruktúra + Változók és metódusok elnevezése + Válasszunk beszédes neveket, amelyek egyértelműen leírják a változó vagy metódus célját + Kerüljük a rövidítéseket és az érthetetlen neveket + rossz: + int c = 100; + jó: + int tetelszam = 100; + +Projekt struktúrája + Osztályokat és metódusokat rendezzünk logikus modulokba és csomagokba. + Egy fájl egyetlen felelősséget lásson el. + +Függvények és metódusok tisztasága + Az egyetlen felelősség elve + Egy függvény vagy metódus csak egy dolgot végezzen, és azt jól végezze el. + Rövidség és egyszerűség + A függvények legyenek rövidek, és kerüljük a túlzott összetettséget. + Ha egy függvény túl hosszú, osszuk fel kisebb részekre. + + Rossz: + public void ProcessData(string data){ + LoadData(data); + ValidateData(data); + SaveData(data); + } + + Jó: + public void LoadData(string data){ + + } + + public void ValidateData(string data){ + + } + + public void SaveData(string data){ + + } + + public void ProcessData(string data){ + LoadData(data); + ValidateData(data); + SaveData(data); + } + +Hibakezelés alapelvei + Try-catch blokkok helyes használata + Csak ott használjunk hibakezelést, ahol szükséges. + Adjunk pontos és érthető hibaüzeneteket. + + Rossz: + try { + int eredmeny = 10 / 0; + } catch { + Console.WriteLine("hiba"); + } + + Jó: + try { + int eredmeny = 10 / 0; + } catch (DivideByZeroException ex){ + Console.WriteLine($"Hiba történt: {ex.Message}"); + } + + Rossz: + try { + streamreader ... + file.Close(); + } catch (FileNotFoundException){ + CW("A fájl nem található") + } + + Jó: + try { + using(streamreader file = new streamreader("data.txt")){ + string tartalom = file.ReadToEnd(); + } + } catch (FileNotFoundException){ + CW("A fájl nem található") + } + +Refaktorálás + A refaktorálás célja a kód minőségének javítása anélkül, hogy megváltoztatnánk annak viselkedését. + Ez segít az olvashatóság és karbantarthatóság növelésében. + + Gyakori refaktoráláso lépések + Változók és függvények átnevezése + Redundáns kód eltávolítása + Hosszú függvények felosztása kisebbekre + +Kódszagok felismerése és javítása + Kódszagok definíciója + A kódszag olyan kódrészlet, amely potenciális problémára utal. + Ezek közé tartozik: + Hosszú függvények + Redundancia + Túl sok paraméter + +Solid alapelvek alkalmazása + S: Egyszeri felelősség elve (Single Responsibility Principle) + Egy osztály csak egy dolgot csináljon, és annak felelőssége jól körülhatárolható legyen. + O: Nyitott/zárt elv (open/closed Principle) + Egy osztály legyen nyitott a bővítésre, de zárt a módosításra + L: Liskov-helyettesítési elv (Liskov Substitution Principle) + Egy származtatott osztály heléyettesíthető legyen az alaposztályával anélkül, hogy a program helytelenül működne. + I: Interfész-szegregációs elv (Interface Segregation Principle) + Az interfészek legyenek kisebbel és specifikusabbak, hogy az implementáló osztályok ne legyenek + kénytelenek fölösleges metódusokat megvalósítani. + D: Függőség-inverzió elve (Dependency Inversion Principle) + A magas szintű modulok ne függjenek alacsony szintű moduloktól, mindkettő absztrakciótól függjön. + +