解决嵌套在对象内部的任何数字承诺

Question

我有一个对象，在多个位置嵌套了 File 个实例。我想递归地遍历对象，检查对象是否是 instanceof File，使用承诺从实例创建数据 url，并且仅当所有承诺都已完成时才解决承诺已解决。

我有一个现有函数，它 return 是一个 Promise 并在文件中的数据 URL 准备就绪时解析。

export const parsePhoto = (file) => {
    return new Promise((resolve, reject) => {
        const reader = new FileReader();

        try {
            reader.readAsDataURL(file);

            reader.onloadend = () => {
                return resolve(reader.result);
            }
        } catch(e) {
            console.warn('Could not upload photo', e.target);
        }
    })
}

我有一个函数可以递归地在对象中查找 File。

export const convertPhotosToBase64 = (values) => {
    if (!values) return values;

    const converted = Object.keys(values).reduce((acc, key) => {
        if (values[key] instanceof File) {
            // Do something here
            acc[key] = parsePhoto(values[key]);
        }

        if (isArray(values[key])) {
            acc[key] = values[key].map(value => {
                if (typeof value === 'object' && !isArray(value)) {
                    return convertPhotosToBase64(value);
                }

                return value;
            })
        }

        // Recurse if object
        if (typeof values[key] === 'object' && !isArray(values[key])) {
            acc[key] = convertPhotosToBase64(values[key]);
        }

        return acc;
    }, values);

    return converted;
}

我想保留传递的对象的现有结构 (values)，并且仅将 File 实例替换为 base64 字符串。

我也知道 Promise.all 但不确定如何在这种情况下使用它。

当所有文件都已转换为 base64 字符串时，我如何 return convertPhotosToBase64 作为解析的承诺？

Answer 1

Promise.all 做你想做的事。在这种情况下使用它的最简单方法是在函数底部执行 return Promise.all(converted)，这将 return 一个特殊的承诺，在参数中的所有承诺都已解决之前不会解决。

Answer 2

让我们先稍微简化一下您的函数，以减少所有这些条件的重复：

export function convertPhotosToBase64(value) {
    if (typeof value !== 'object') return value;

    if (value instanceof File) return parsePhoto(value);

    if (isArray(value)) return value.map(convertPhotosToBase64);

    return Object.keys(value).reduce((acc, key) => {
        acc[key] = convertPhotosToBase64(value[key]);
        return acc;
    }, {});
}

现在，parsePhoto 是异步的，return 是一个承诺。这意味着整个 convertPhotosToBase64 将需要变得异步并且始终 return 一个承诺。考虑到四种明显不同的情况，这实际上比听起来简单：

export function convertPhotosToBase64(value) {
    // wrap value
    if (typeof value !== 'object') return Promise.resolve(value);

    // already a promise
    if (value instanceof File) return parsePhoto(value);

    // map creates all the promises in parallel, use `Promise.all` to await them
    if (isArray(value)) return Promise.all(value.map(convertPhotosToBase64));

    // chain one after the other
    return Object.keys(value).reduce((accP, key) =>
        accP.then(acc =>
            convertPhotosToBase64(value[key]).then(res => {
                acc[key] = res;
                return acc;
            })
        )
    , Promise.resolve({}));
}

如果您可以并行执行所有操作（不仅是数组），您还可以将最后一种情况简化为

    return Object.keys(value).reduce((accP, key) =>
        Promise.all([accP, convertPhotosToBase64(value[key])]).then([acc, res] => {
            acc[key] = res;
            return acc;
        })
    , Promise.resolve({}));

或者更好

    const keys = Object.keys(value);
    return Promise.all(keys.map(key => convertPhotosToBase64(value[key])).then(results => {
        const acc = {};
        for (const [key, i] of keys.entries())
            acc[key] = results[i];
        return acc;
    });

解决嵌套在对象内部的任何数字承诺

Resolve any number promises nested inside of an object

javascript

traversal

object

filereader

promise