Question

我有一个在不同位置嵌套File个实例的对象。我想以递归方式遍历该对象，检查对象是否为instanceof File，使用promise从实例创建数据URL，并仅在所有promise都已解析时解析promise。

我有一个返回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），并且只用base64字符串替换File实例。

我也知道Promise.all，但不确定如何在此背景下使用它。

如何将convertPhotosToBase64作为在所有文件转换为base64字符串时解析的承诺返回？

Answer 1

让我们先简化一下你的功能，减少所有这些条件的重复：

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是异步的并返回一个promise。这意味着整个convertPhotosToBase64将需要变为异步并始终返回一个promise。鉴于四个明显不同的案例，这实际上比听起来更简单：

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;
    });

Answer 2

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

解析嵌套在对象内的任何数量的promise

2 个答案: