Vydělávej až 160.000 Kč měsíčně! Akreditované rekvalifikační kurzy s garancí práce od 0 Kč. Více informací.
Hledáme nové posily do ITnetwork týmu. Podívej se na volné pozice a přidej se do nejagilnější firmy na trhu - Více informací.

2. diel - Najčastejšie chyby programátorov - Vieš pomenovať objekty?

Predchádzajúci
Ďalší

V minulej lekcii, Najčastejšie chyby programátorov - Vieš pomenovať premenné? , sme si ukázali najčastejšie chyby začiatočníkov, ktorých sa dopúšťajú pri pomenovaní premenných.

V dnešnom tutoriále kurzu Best practices pre návrh softvéru si ukážeme prvé dobré praktiky pre objektovo orientované programovanie. Budeme sa zaoberať najmä správnym pomenovávaním tried, metód a atribútov. Pozrite sa, či nerobíte jednu z najčastejších chýb.

Miliónové straty

O dobrých praktikách sme sa už bavili a vieme, že neprehľadné programy nie sú vôbec žiadna malichernosť. Sú totiž:

  • Nezrozumiteľné pre ostatných - Keď tím 5 programátorov, každý s platom 100.000 Sk mesačne, strávi 20% pracovnej doby lúštením kódu, stojí to ročne 1.2 milióna Sk!
  • Náchylné k chybám - Tržby aj malých e-shopov sú mesačne obvykle v miliónoch korún, 1 deň nefunkčnosti teda stoja majiteľa stovky tisíc Sk, dodávateľovi hrozia nemalé zmluvné pokuty.
  • Prakticky nerozšíriteľné - V súčasnej funkčnosti sa už nikto nevyzná a nemožno ju rozšíriť. Programátorský tím o niekoľkých ľuďoch musí vytvoriť aplikáciu znova, sme opäť v miliónoch Sk.
  • Netestovateľné, nezabezpečené a takto by sme mohli pokračovať.

Niet pochýb, že dobré praktiky sú pre vývoj softvéru v tíme úplne zásadné a následky ich porušenia potom úplne fatálne.

Ako správne pomenovávať triedy, atribúty a metódy?

V dnešnej lekcii sa budeme zaoberať „objektovými súčiastkami“, z ktorých sú naše aplikácie zložené. Naučíme sa ich správne pomenovať, aby boli prehľadné.

Motivačný príklad

K doktorovi príde pacient a hovorí mu, že má problém so svojím orgánom Přesouvat. Nefunguje mu bota. Pacient sa zdá byť nejaký popletený a doktorovi trvá pomerne dlho, kým z neho dostane, že ho pichá v päte a preto si nemôže obuť ani topánku. Keď konečne vypustí pacienta z ordinácie, zistí, že bol súčasťou skupiny a takých ich tam ešte čaká niekoľko desiatok.

Best practices pre návrh softvéru

Pozrime sa ešte na druhý príbeh. Programátorovi pridelí program, ktorý spadne s chybou v triede MoveData, metóda data(). Program sa zdá byť nejaký popletený a programátorovi trvá dlho, než zistí, že ide o triedu importujúcu dáta z externej zálohy a že sa prvýkrát musí ručne zavolať metóda work(), ktorá import vykoná. Keď chybu konečne opraví, objaví sa ďalšia a zistí, že v programe je niekoľko desiatok tried a metód, z ktorých názvu vôbec nespozná, čo robia.

Určite vidíme paralelu týchto dvoch príbehov. Zatiaľ čo u ľudského tela by nás asi ťažko napadlo hovoriť o orgáne "presúvať" a funkciu "topánka", v programoch bohužiaľ nie je taký problém naraziť na objekty pomenované ako deje a funkcie pomenované ako veci, aj keď je princíp úplne rovnaký. Niet divu, že si Indescriptive naming vyslúžilo svoje miesto v šestici najhorších programátorských praktík STUPID.

Pomenovanie tried

Triedy definujú objekty, z ktorých je aplikácia zložená. Z toho vyplýva niekoľko triviálnych pravidiel. Názvy tried:

  • sú podstatné mená! - Ide o jednotlivé počítateľné objekty bez ohľadu na to, koľko objektov od triedy potom vytvoríme.
  • nie sú názvy dejov - Ide o objekty (veci). Triedy teda nemôžeme nazvať napr. WorkWithFile alebo Printing, ale napr. FileManager alebo Printer (alebo ešte lepšie UserInterface, pretože zriedka kedy tvoríme celú triedu len na vypísanie niečoho).
  • začínajú s veľkým písmenom - Každé ďalšie slovo má veľké písmeno (notácia PascalCase a to aj v Pythone). Je tak vidieť, že ide o všeobecnú triedu a nie o jej konkrétnu inštanciu.
  • sú pomenované podľa toho, akú súčasť programu reprezentujú, čo nemusí byť vždy rovnaké, ako to, čo vo vnútri robia.

Ukážme si niekoľko príkladov:

  • ✗ Špatně

    class employee {
class Employees {
class Invoiceitem {
class WorkingWithFile {
class Print {
class EnteringData {

    ✔ Správně

    class Employee {
class EmployeeManager {
class InvoiceItem {
class FileDatabase {
class UserInterface {

  • ✗ Špatně

    class employee
class Employees
class Invoiceitem
class WorkingWithFile
class Print
class EnteringData

    ✔ Správně

    class Employee
class EmployeeManager
class InvoiceItem
class FileDatabase
class UserInterface

  • ✗ Špatně

    class employee {
class Employees {
class Invoiceitem {
class WorkingWithFile {
class Print {
class EnteringData {

    ✔ Správně

    class Employee {
class EmployeeManager {
class InvoiceItem {
class FileDatabase {
class UserInterface {

  • ✗ Špatně

    class employee:
class Employees:
class invoice_item:
class WorkingWithFile:
class Print:
class EnteringData:

    ✔ Správně

    class Employee:
class EmployeeManager:
class InvoiceItem:
class FileDatabase:
class UserInterface:

  • ✗ Špatně

    class employee {
class Employees {
class Invoiceitem {
class WorkingWithFile {
class Print {
class EnteringData {

    ✔ Správně

    class Employee {
class EmployeeManager {
class InvoiceItem {
class FileDatabase {
class UserInterface {

  • ✗ Špatně

    class employee {
class Employees {
class Invoiceitem {
class WorkingWithFile {
class Print {
class EnteringData {

    ✔ Správně

    class Employee {
class EmployeeManager {
class InvoiceItem {
class FileDatabase {
class UserInterface {

  • ✗ Špatně

    class employee {
class Employees {
class Invoiceitem {
class WorkingWithFile {
class Print {
class EnteringData {

    ✔ Správně

    class Employee {
class EmployeeManager {
class InvoiceItem {
class FileDatabase {
class UserInterface {

Ak narazíte na program, kde sa trieda volá WorkingWithFile, jeho autor si pravdepodobne len vygooglil, že kód sa píše do class bez toho, aby tušil, že tým založil nejaký objekt.

Triedy v množnom čísle

V množnom čísle pomenovávame triedy veľmi zriedka. Napríklad v Jave takto nájdeme triedu Arrays. Od tej nevytvárame inštancie a používame ju len pre prácu s inštanciami triedy Array, teda s poľami. Pole zotriedime napr. ako:

Arrays.sort(employees);

Osobne by mi oveľa väčší zmysel dávalo, aby tieto metódy mala na sebe priamo trieda Array a písali sme teda:

employees.sort()

Autori Javy pravdepodobne nechceli triedu Array príliš zložitú a tak pre niektoré metódy vytvorili túto druhú triedu. Výsledný prínos je diskutabilný. My triedy v množnom čísle väčšinou deklarovať nebudeme.

Pomenovanie tried v angličtine

Základné kurzy sú na ITnetwork po slovensky, aby boli lepšie stráviteľné. Kódy tých pokročilých sú rovnako ako reálne obchodné aplikácie po anglicky. Pre anglické názvy tried platí samozrejme to isté, čo sme povedali vyššie. Môžeme však ľahko urobiť nasledujúce chyby:

  • Jednotné čísla - Keď v slovenčine pomenujeme triedu pracujúcu s autami SpravceAut, mohol by sa ponúkať anglický preklad CarsManager. Správne je však CarManager, jednotné číslo, pretože Car tu funguje ako prídavné meno.
  • Poradie slov - Na rozdiel od slovenčiny je podstatné meno na konci súslovia, správca áut teda nie je ManagerCars alebo ManageCars, ale CarManager. Cesta k súboru nie je PathFile (čo by bol cestový súbor), ale FilePath a pod.

V angličtine sa u tried často používa koncovka -er, napr. TaskRunner, podľa toho, čo trieda robí.

Ukážme si pár príkladov:

  • ✗ Špatně

    class CarsManager {
class PathFile {
class RunTasks {

    ✔ Správně

    class CarManager {
class FilePath {
class TaskRunner {

  • ✗ Špatně

    class CarsManager
class PathFile
class RunTasks

    ✔ Správně

    class CarManager
class FilePath
class TaskRunner

  • ✗ Špatně

    class CarsManager {
class PathFile {
class RunTasks {

    ✔ Správně

    class CarManager {
class FilePath {
class TaskRunner {

  • ✗ Špatně

    class CarsManager:
class PathFile:
class RunTasks:

    ✔ Správně

    class CarManager:
class FilePath:
class TaskRunner:

  • ✗ Špatně

    class CarsManager {
class PathFile {
class RunTasks {

    ✔ Správně

    class CarManager {
class FilePath {
class TaskRunner {

  • ✗ Špatně

    class CarsManager {
class PathFile {
class RunTasks {

    ✔ Správně

    class CarManager {
class FilePath {
class TaskRunner {

  • ✗ Špatně

    class CarsManager {
class PathFile {
class RunTasks {

    ✔ Správně

    class CarManager {
class FilePath {
class TaskRunner {

Pomenovanie atribútov

Atribúty sú "premenné" danej triedy. Pre ich pomenovanie teda platia úplne tie isté zásady ako pre premenné, ktoré sme si už detailne vysvetľovali v lekcii Najčastejšie chyby programátorov - Vieš pomenovať premenné?.

Základným pravidlom opäť je, že atribúty pomenovávame podľa toho, čo je v nich uložené. Názov atribútu chápeme v kontexte názvu triedy a nemusí teda dávať zmysel sám o sebe. Z jazykového hľadiska sú názvy atribútov:

  • podstatné mená (name, employees, ...)
  • prídavné mená (disabled, sent, ...)

Pripomeňme si tu aj zvyšné zásady:

  • všetky atribúty pomenovávame buď anglicky alebo česky bez diakritiky, ale nie kombináciou týchto jazykov
  • viacslovné atribúty pomenovávame pomocou notácie camelCase alebo snake_case v závislosti od jazyka
  • ak atribút obsahuje kolekciu s viacerými hodnotami (napr. pole alebo List), je jeho názov v množnom čísle

Ukážme si opäť nejaké príklady názvov atribútov tried:

  • ✗ Špatně

    private String Name;
private boolean send;
private String[] phonenumbers;
private Button tlačítko;
private Address[] uzivatelAddress;

    ✔ Správně

    private String name;
private boolean sent;
private String[] phoneNumbers;
private Button tlacitko; // ideálně button
private Address[] userAddresses;

  • ✗ Špatně

    private string Name;
private bool send;
private string[] phonenumbers;
private Button tlačítko;
private Address[] uzivatelAddress;

    ✔ Správně

    private string name;
private bool sent;
private string[] phoneNumbers;
private Button tlacitko; // ideálně button
private Address[] userAddresses;

  • ✗ Špatně

    private:
    string Name;
    bool send;
    string* phonenumbers;
    Button tlačítko;
    Address* uzivatelAddress;

    ✔ Správně

    private:
    string name;
    bool sent;
    string* phoneNumbers;
    Button tlacitko; // ideálně button
    Address* userAddresses;

  • ✗ Špatně

    self._Name = ""
self._send = False
self._phonenumbers = []
self._tlačítko = Button()
self._uzivatel_address = []

    ✔ Správně

    self._name = ""
self._sent = False
self._phone_numbers = []
self._tlacitko = Button() # ideálně _button
self._user_addresses = []

  • ✗ Špatně

    private var Name: String
private var send: Bool
private var phonenumbers: [String]()
private var tlačítko: Button
private var uzivatelAddress: [Address]()

    ✔ Správně

    private var name: String
private var sent: Bool
private var phoneNumbers: [String]()
private var tlacitko: Button // ideálně button
private var userAddresses: [Address]()

  • ✗ Špatně

    private string $Name;
private bool $send;
private array $phonenumbers;
private Button $tlačítko;
private array $uzivatelAddress;

    ✔ Správně

    private string $name;
private bool $sent;
private array $phoneNumbers;
private Button $tlacitko; // ideálně $button
private array $userAddresses;

  • ✗ Špatně

    this._Name = "";
this._send = false;
this._phonenumbers = [];
this._tlačítko = new Button();
this._uzivatelAddress = [];

    ✔ Správně

    this._name = "";
this._sent = false;
this._phoneNumbers = [];
this._tlacitko = new Button(); // ideálně _button
this._userAddresses = [];

Pomenovanie metód a parametrov

Metódy označujú deje, ich názov obsahuje teda sloveso ! Môže ísť o:

  • prikazovací tvar (load(), setId()) - Metóda prevažne vykonáva nejakú činnosť a jej výsledok môže alebo nemusí vracať. Nevolíme infinitív alebo -ing tvar, napr. loading().
  • opytovací tvar - Metódou sa prevažne pýtame na nejakú hodnotu, než aby sme chceli vykonať nejakú akciu (napr. getRank() alebo isDisabled() pre hodnotu typu boolean). Už vieme, že takýmto metódam hovoríme gettery.
  • V prípade viacerých slov ich vo väčšine jazykov pomenovávame podľa camelCase, v Pythone podľa snake_case. VC# začínajú metódy veľkým písmenom.

Metódy pomenovávame podľa toho, čo robia! Vyhýbame sa neurčitým názvom ako work(), action(), run() apod.

Ukážme si príklady:

  • ✗ Špatně

    public void printing(Employee employee) {
public boolean getEnabled() {
private void data() {
public void work() {

    ✔ Správně

    public void printInfo(Employee employee) {
public boolean isEnabled() {
private void generateData() {
public void importBackup() {

  • ✗ Špatně

    public void Printing(Employee employee)
public bool GetEnabled()
private void Data()
public void Work()

    ✔ Správně

    public void PrintInfo(Employee employee)
public bool IsEnabled()
private void GenerateData()
public void ImportBackup()

  • ✗ Špatně

    private:
    void data() {

public:
    void printing(Employee employee) {
    bool getEnabled() {
    void work() {

    ✔ Správně

    private:
    void generateData() {

public:
    void printInfo(Employee employee) {
    bool isEnabled() {
    void importBackup() {

  • ✗ Špatně

    def printing(employee):
def get_enabled():
def _data():
def work():

    ✔ Správně

    def print_info(employee):
def is_enabled():
def _generate_data():
def import_backup():

  • ✗ Špatně

    func printing(employee: Employee) {
func getEnabled() -> Bool {
private func data() {
func work() {

    ✔ Správně

    func printInfo(employee: Employee) {
func isEnabled() -> Bool {
private func generateData() {
func importBackup() {

  • ✗ Špatně

    public function printing(Employee $employee): void {
public function getEnabled(): bool {
private function data(): void {
public function work(): void {

    ✔ Správně

    public function printInfo(Employee $employee): void {
public function isEnabled(): bool {
private function generateData(): void {
public function importBackup(): void {

  • ✗ Špatně

    printing(employee) {
getEnabled() {
_data() {
work() {

    ✔ Správně

    printInfo(employee) {
isEnabled() {
_generateData() {
importBackup() {

Parametre metód

Parameter metódy je premenná a preto pre ich názov platia tie isté pravidlá, ako pre premenné a atribúty (napríklad nikdy nepomenujeme parameter param 🙂). Je tu však jedna dôležitá vec na uváženie a to je použitie dvojitej negácie. Ukážme si posledný príklad:

  • ✗ Špatně

    public void importData(boolean disableForeignKeys) {

importData(false);

    ✔ Správně

    public void importData(boolean enableForeignKeys) {

importData(true);

  • ✗ Špatně

    public void ImportData(bool disableForeignKeys = false)

    ✔ Správně

    public void ImportData(bool enableForeignKeys = true)

  • ✗ Špatně

    public:
    void importData(bool disableForeignKeys = false) {

    ✔ Správně

    public:
    void importData(bool enableForeignKeys = true) {

  • ✗ Špatně

    def import_data(disable_foreign_keys = False):

    ✔ Správně

    def import_data(enable_foreign_keys = True):

  • ✗ Špatně

    func importData(disableForeignKeys: Bool = false) {

    ✔ Správně

    func importData(enableForeignKeys: Bool = true) {

  • ✗ Špatně

    public function importData(bool $disableForeignKeys = false): void {

    ✔ Správně

    public function importData(bool $enableForeignKeys = true): void {

  • ✗ Špatně

    importData(disableForeignKeys = false) {

    ✔ Správně

    importData(enableForeignKeys = true) {
Kto z vás na prvú dobrú dokáže povedať, či sú v prvom variante bez uvedenia parametra (pre Javu s odovzdaním false) cudzie kľúče povolené? Všetko je zas o ľudskom mozgu, ktorý nie je zvyknutý fungovať pod dvojakou negáciou. Volíme teda skôr druhý variant.

V budúcej lekcii, Najčastejšie chyby programátorov - Podmienky , si ukážeme najčastejšie chyby začiatočníkov, napríklad ohľadom pomenovania kolekcií, boolean výrazov a DRY.


 

Predchádzajúci článok
Najčastejšie chyby programátorov - Vieš pomenovať premenné?
Všetky články v sekcii
Best practices pre návrh softvéru
Preskočiť článok
(neodporúčame)
Najčastejšie chyby programátorov - Podmienky
Článok pre vás napísal David Hartinger
Avatar
Užívateľské hodnotenie:
Ešte nikto nehodnotil, buď prvý!
David je zakladatelem ITnetwork a programování se profesionálně věnuje 15 let. Má rád Nirvanu, nemovitosti a svobodu podnikání.
Unicorn university David sa informačné technológie naučil na Unicorn University - prestížnej súkromnej vysokej škole IT a ekonómie.
Aktivity