Administrace komentářů

Z vaší odpovědi jsem se dozvěděl, že je dobré dodržovat štábní kulturu, s čímž souhlasím. Nicméně nemám pocit, že by vysvětlovala, jak může pravidlo jediného výstupního bodu zpřehledňovat kód.

Abychom se bavili o něčem konkrétním – primitivní funkce pro kopírování souborů bude s několika výstupními body vypadat nějak takhle:

void copy(source, target) {
  if (!file_exists(source)) {
    throw "Zdrojový soubor neexistuje.";
  }
  if (!is_dir(source)) {
    throw "Zdroj nemůže být adresář.";
  }
  if (!is_readable(source)) {
    throw "Zdrojový soubor nelze číst.";
  }
  if (!is_dir(target)) {
    throw "Cíl nemůže být adresář.";
  }

  parent = parent_dir(target);
  if (!file_exists(parent)) {
    throw "Neexistuje adresář pro cílový soubor.";
  }
  if (exists(target)) {
    throw "Cílový soubor již existuje.";
  }
  if (!is_writable(parent)) {
    throw "Do cílového adresáře nelze zapisovat.";
  }
  if (get_free_space(parent) < get_file_size(source)) {
    throw "V cílovém adresáři není dost volného místa.";
  }

  buffer, offset;
  do {
    buffer = read(source, offset, size(buffer));
    write(target, offset, buffer);
    offset += size(buffer);
  } while(size(buffer) > 0);
}

Když to přepíšu na jediný výstupní bod, dostanu:

void copy(source, target) {
  error = null;
  if (file_exists(source)) {
    if (is_dir(source)) {
      if (is_readable(source)) {
        parent = parent_dir(target);
        if (file_exists(parent)) {
          if (is_dir(target)) {
            if (is_writable(parent)) {
              if (!exists(target)) {
                if (get_free_space(parent) >= get_file_size(source)) {
                  buffer, offset;
                  do {
                    buffer = read(source, offset, size(buffer));
                    write(target, offset, buffer);
                    offset += size(buffer);
                  } while(size(buffer) > 0);
                } else {
                  error = "V cílovém adresáři není dost volného místa.";
                }
              } else {
                error = "Cílový soubor již existuje.";
              }
            } else {
              error = "Do cílového adresáře nelze zapisovat.";
            }
          } else {
            error = "Cíl nemůže být adresář.";
          }
      } else {
          error = "Neexistuje adresář pro cílový soubor.";
        }
      } else {
        error = "Zdrojový soubor nelze číst.";
      }
    } else {
      error = "Zdroj nemůže být adresář.";
    }
  } else {
    error = "Zdrojový soubor neexistuje.";
  }
  throw error;
}

Pro mne je tedy ten druhý kód daleko nepřehlednější, a porušuje například jednu velmi dobrou zásadu omezující počet vnoření bloků. Nebo jak byste ten kód přepsal na jediný výstupní bod bez těch vnořených ifů? Počet vnoření by se samozřejmě dal zredukovat sloučením několika testů do jednoho a vytknutím do samostatné funkce, ale to neřeší princip problému.

Možná je rozdíl v programování triviálních funkcí přímo nad procesorem, kde máte jasně definované podmínky běhu, a pokud se náhodou dostanete mimo ně, zastavíte procesor a nějaký watchdog rozsvítí červenou kontrolku, že je všechno špatně (a mimochodem reset procesoru podle mne je výstupní bod, je to obdoba vyhození výjimky ve vyšších programovacích jazycích a způsob, jakým se ukončí provádění dané funkce). A v programování pro počítače, tablety, mobily, televize apod., kde uživatel pracuje přímo s programem, podmínky jsou velmi různorodé a každý očekává, že se z nečekaných situací dokáže program zotavit.