JavaScript - Restituire la promessa E/O richiamare la chiamata?

Question

vedo spesso in altri documenti popoli qualcosa di simile:

callback è facoltativa, se omesso restituisce una promessa.

Questo è quello che ho:

export function doSomeAsync(options, callback) { 

    const useCallback = (callback && typeof callback == 'function'); 

    const promise = new Promise((resolve, reject) => { 

     // --- do async stuff here --- 
     const check = (options.num === 1) ? true : false; 
     setTimeout(() => { 
      if (check) { 
       finish(true, "Number is 1"); 
      } else { 
       finish(false, new Error("Number is not 1")); 
      } 
     }, 1000); 
     // --------------------------- 

     function finish(ok, rtn) { 
      if (useCallback) { 
       if (ok) { 
        callback(null, rtn); 
       } else { 
        callback(rtn, null); 
       } 
      } else { 
       if (ok) { 
        resolve(rtn); 
       } else { 
        reject(rtn); 
       } 
      } 
     } 

    }); 

    return (useCallback) ? false : promise; 
} 

La funzione finish() solo evita un sacco di if... dichiarazioni sparsi.

Sto creando un oggetto promessa, sia che lo utilizzi o no.

test come questo:

doSomeAsync({ num: 1 }).then((result) => { 
    console.log('p result', result); 
}).catch((err) => { 
    console.log('p err', err); 
}); 

doSomeAsync({ num: 1 }, (err, result) => { 
    if (err) { 
     console.log('cb err', err); 
    } else { 
     console.log('cb result', result); 
    } 
}); 

Questo funziona, ma mi chiedo se questo è il modo migliore, o se altri hanno un'un'attuazione migliore e più succinta ..?

Answer 1

Questo potrebbe essere semplificata se semplicemente sempre usato la promessa, che si sta sempre creando in ogni caso:

export function doSomeAsync(options, callback) { 
    const promise = new Promise((resolve, reject) => { 
     const check = (options.num === 1) ? true : false; 
     setTimeout(() => { 
      if (check) { 
       resolve("Number is 1"); 
      } else { 
       reject(new Error("Number is not 1")); 
      } 
     }, 1000); 
    }); 

    if (callback && typeof callback == 'function') { 
     promise.then(callback.bind(null, null), callback); 
    } 

    return promise; 
} 

vostra funzione è sempre promettere-based, anche nel fatto che essa restituisce sempre una promessa. Il chiamante è semplicemente libero di ignorarlo. L'argomento del callback è semplicemente una "interfaccia fallback legacy" (o "interfaccia alternativa" se si preferisce) per usare quella promessa.