¿Cómo escribe el mecanografiado Promise.all() en la matriz de valores resuelta? ¿Cómo puede mecanografiarse el tipo de cada elemento? Solo veo una T genérica en la firma de tipo de Promise.all(), pero ¿por qué puedo pasar promesas que se resuelven en diferentes tipos de valores?
Para elaborar, ¿por qué mi implementación de promiseAll arroja un error de tipo mecanografiado pero el integrado funciona como magia?
const promiseAll = function<T>(promises: Promise<T>[]): Promise<T[]> { const results: T[] = []; let completedCount = 0; return new Promise(function (resolve, reject) { promises.forEach(function(promise, index) { promise.then(function (value) { results[index] = value; completedCount += 1; if(completedCount === promises.length) { resolve(results); } }).catch(function (error) { reject(error); }); }); }); } const promise1 = new Promise<number>(resolve => setTimeout(() => { resolve(1) }, 500)); const promise2 = new Promise<string>(resolve => setTimeout(() => { resolve("a") }, 500)); async function main() { const [value1, value2] = await Promise.all([promise1, promise2]); const [myValue1, myValue2] = await promiseAll([promise1, promise2]); } main();TypeScript escribe Promise.all con 11 sobrecargas, pero este enfoque solo permite pasar un número finito de objetos PromiseLike con diferentes tipos. Una de las sobrecargas puede manejar una matriz de cualquier longitud llena de objetos PromiseLike tipificados de manera consistente, aunque. Aquí hay dos de las sobrecargas para un ejemplo:
Promise.all<T1, T2, T3, T4>(values: readonly [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<[T1, T2, T3, T4]> Promise.all<T>(values: readonly (T | PromiseLike<T>)[]): Promise<T[]> Las sobrecargas de Promise.all con argumentos tipeados de forma independiente parecen admitir solo hasta 9 elementos tipificados claramente en el argumento de values .
El código que ha proporcionado como ejemplo coincide bastante con la segunda sobrecarga anterior, pero tiene la misma limitación en el sentido de que solo funcionará si el tipo de cada Promise en la matriz que se pasa a Promise.all es el mismo.
Su ejemplo se compilaría si le dijera a TypeScript que estaba pasando una matriz de tipo Promise<number | string>[] a PromiseAll , porque entonces todas sus Promise s serían tratadas como si tuvieran el mismo tipo. Aunque, por supuesto, la matriz que obtendría sería del tipo (number | string)[] y no sabría qué elemento tenía qué tipo.