Promisifikace

„Promisifikace“ je dlouhý výraz pro jednoduchou transformaci. Je to převod funkce, která přijímá callback, na funkci, která vrací příslib.

Takové transformace jsou ve skutečném životě často požadovány, jelikož mnoho funkcí a knihoven je založeno na callbaccích. Přísliby jsou však vhodnější, takže promisifikace těchto funkcí dává smysl.

Pro lepší porozumění se podívejme na příklad.

Máme například funkci načtiSkript(zdroj, callback) z kapitoly Úvod: callbacky.

function načtiSkript(zdroj, callback) {
  let skript = document.createElement('script');
  skript.src = zdroj;

  skript.onload = () => callback(null, skript);
  skript.onerror = () => callback(new Error(`Chyba načítání skriptu pro ${zdroj}`));

  document.head.append(skript);
}

// použití:
// načtiSkript('path/script.js', (chyba, skript) => {...})

Tato funkce načte skript ze zadaného zdroje zdroj a pak volá callback(chyba) v případÄ› chyby nebo callback(null, skript) v případÄ› úspěšného načtení. To je Å¡iroce rozšířená úmluva pro používání callbacků, kterou jsme již vidÄ›li.

Promisifikujme tuto funkci.

VytvoÅ™me novou funkci načtiSkriptPříslibem(zdroj), která udÄ›lá totéž (načte skript), ale místo používání callbacků vrátí příslib.

Jinými slovy, pÅ™edáme do ní jenom zdroj (ne callback) a jako návratovou hodnotu obdržíme příslib, který se splní s hodnotou skript, bude-li načítání úspěšné, a jinak se zamítne s chybou.

Zde je:

let načtiSkriptPříslibem = function(zdroj) {
  return new Promise((splň, zamítni) => {
    načtiSkript(zdroj, (chyba, skript) => {
      if (chyba) zamítni(chyba);
      else splň(skript);
    });
  });
};

// použití:
// načtiSkriptPříslibem('path/script.js').then(...)

Jak vidíme, nová funkce je obalem okolo původní funkce načtiSkript. Zavolá ji a poskytne jí svůj vlastní callback, který se pÅ™evede na příslib splň/zamítni.

Nyní načtiSkriptPříslibem dobÅ™e zapadne do kódu založeného na příslibech. Máme-li radÄ›ji přísliby než callbacky (a brzy pro to uvidíme další důvody), použijeme místo původní funkce tuto.

V praxi můžeme potřebovat promisifikovat více než jednu funkci, takže dává smysl použít pomocnou funkci.

Nazveme ji promisifikuj(f): bude pÅ™ijímat funkci f, která má být promisifikována, a vrátí obalovou funkci.

function promisifikuj(f) {
  return function (...argumenty) { // vrátí obalovou funkci (*)
    return new Promise((splň, zamítni) => {
      function callback(chyba, výsledek) { // náš vlastní callback pro f (**)
        if (chyba) {
          zamítni(chyba);
        } else {
          splň(výsledek);
        }
      }

      argumenty.push(callback); // připojí náš vlastní callback na konec argumentů funkce f

      f.call(this, ...argumenty); // zavolá původní funkci
    });
  };
}

// použití:
let načtiSkriptPříslibem = promisifikuj(načtiSkript);
načtiSkriptPříslibem(...).then(...);

Kód může vypadat trochu složitÄ›, ale v zásadÄ› je to totéž, co jsme napsali výše, když jsme promisifikovali funkci načtiSkript.

Volání promisifikuj(f) vrátí obal okolo f (*). Tento obal vrátí příslib, pÅ™edá volání původní funkci f a výsledek zpracuje ve vlastním callbacku (**).

Zde funkce promisifikuj pÅ™edpokládá, že původní funkce očekává callback s právÄ› dvÄ›ma argumenty (chyba, výsledek). S tím se setkáváme nejčastÄ›ji. Náš vlastní callback je pÅ™esnÄ› ve správném formátu a funkce promisifikuj v takovém případÄ› funguje skvÄ›le.

Ale co když původní funkce f očekává callback s více argumenty callback(chyba, výsledek1, výsledek2, ...)?

Můžeme naÅ¡i pomocnou funkci vylepÅ¡it. VytvoÅ™me pokročilejší verzi promisifikuj.

• Když bude volána jako promisifikuj(f), mÄ›la by fungovat podobnÄ› jako uvedená verze.
• Když bude volána jako promisifikuj(f, true), mÄ›la by vrátit příslib, který se splní s polem výsledků callbacku. To je určeno právÄ› pro callbacky s mnoha argumenty.

// promisifikuj(f, true) pro získání pole výsledků
function promisifikuj(f, víceArgumentů = false) {
  return function (...argumenty) {
    return new Promise((splň, zamítni) => {
      function callback(chyba, ...výsledky) { // náš vlastní callback pro f
        if (chyba) {
          zamítni(chyba);
        } else {
          // je-li uvedeno víceArgumentů, splní se se všemi výsledky callbacku
          splň(víceArgumentů ? výsledky : výsledky[0]);
        }
      }

      argumenty.push(callback);

      f.call(this, ...argumenty);
    });
  };
}

// použití:
f = promisifikuj(f, true);
f(...).then(poleVýsledků => ..., chyba => ...);

Jak vidíte, je to v zásadÄ› totéž jako výše, ale splň se volá buď jen s jedním, nebo se vÅ¡emi argumenty, podle toho, zda je argument víceArgumentů pravdivý.

Pro exotičtÄ›jší formáty callbacků, napÅ™. takové, které vůbec neobsahují argument chyba: callback(výsledek), můžeme takové funkce promisifikovat ručnÄ› bez použití pomocné funkce.

Existují i moduly s trochu flexibilnÄ›jšími promisifikačními funkcemi, napÅ™. es6-promisify. V Node.js k tomu slouží zabudovaná funkce util.promisify.