Javascript 为什么可以'；我不能在一个坚定的承诺上使用它吗？

我有一个函数，它的工作是检查许多文件（使用数组中的值作为文件名的构建块），并使用

reduce

下载它们。到目前为止，这更像是一种黑客行为，但是

承诺
逻辑应该可以工作。但事实并非如此

这是我的密码：

function import_demo_files(data) {
    /**
     * Make a local copy of the passed data.
     */
    let request_data = $.extend({}, data);

    const get_number_of_files_1 = Promise.resolve({
        'data' : {
            'number_of_files' : 2
        }
    });

    return new Promise((resolve, reject) => {
        let import_files = get_number_of_files_1.then(function(response) {
            new Array(response.data.number_of_files).fill(request_data.step_name).reduce((previous_promise, next_step_identifier) => {
                let file_counter = 1;

                return previous_promise.then((response) => {
                    if( response !== undefined ) {
                        if('finished_import' in response.data && response.data.finished_import === true || response.success === false) {
                            return import_files;
                        }
                    }
                    const recursively_install_step_file = () => import_demo_file({
                        demo_handle: request_data.demo_handle,
                        'step_name': request_data.step_name,
                        'file_counter': file_counter

                    }).call().then(function(response) {
                        file_counter++;

                        if('file_counter' in response.data && 'needs_resume' in response.data) {
                            if(response.data.needs_resume === true) {
                                file_counter = response.data.file_counter;
                            }
                        }
                        return response.data.keep_importing_more_files === true ? recursively_install_step_file() : response
                    });
                    return recursively_install_step_file();
                }).catch(function(error) {
                    reject(error);
                });
            }, Promise.resolve())
        }).catch(function(error) {
            reject(error);
        });
        resolve(import_files);
    });
}

现在，当我这样做的时候：

const import_call = import_demo_files({ 'demo_handle' : 'demo-2', 'step_name' : 'post' });
console.log(import_call);

console.log
告诉我，
import\u call
实际上是一个承诺，它已经解决了。我非常喜欢
return
允许我跳出承诺链的方式，但我不知道如何在那里正确解析我的承诺链，所以很明显，它在没有解析时被标记为已解析

我想做
import\u调用（…
但这到目前为止还不起作用，它在实际执行之前在这里执行这段代码，因为
import\u demo\u文件中处理不当
还原中的异步递归并不是最简单的事情，而且，如果每次迭代在递归的基础上，每一次迭代都是相同的

reduce/recurse模式更易于理解，将以下内容作为外部成员拉出：

1. the `recursively_install_step_file()` function
1. the `new Array(...).fill(...)`, as `starterArray`
1. the object passed repeatedly to `import_demo_file()`, as `importOptions`)

这种方法不需要变量
file\u计数器
，因为
导入操作。file\u计数器
可以直接更新

function import_demo_files(data) {
    // outer members
    let request_data = $.extend({}, data);
    const importOptions = {
        'demo_handle': request_data.demo_handle,
        'step_name': request_data.step_name,
        'file_counter': 1
    };
    const starterArray = new Array(2).fill(request_data.step_name);
    function recursively_install_step_file() {
        return import_demo_file(importOptions).then((res) => {
            if('file_counter' in res.data && 'needs_resume' in res.data && res.data.needs_resume) {
                importOptions.file_counter = res.data.file_counter; // should = be += ?
            } else {
                importOptions.file_counter++;
            }
            return res.data.keep_importing_more_files ? recursively_install_step_file() : res;
        });
    }

    // the reduce/recurse pattern
    return starterArray.reduce((previous_promise, next_step_identifier) => { // next_step_identifier is not used?
        let importOptions.file_counter = 1; // reset to 1 at each stage of the reduction?
        return previous_promise.then(response => {
            if(response && ('finished_import' in response.data && response.data.finished_import || !response.success)) {
                return response;
            } else {
                return recursively_install_step_file(); // execution will drop through to here on first iteration of the reduction
            }
        });
    }, Promise.resolve());
}

可能不是100%正确，但总体模式应该是正确的。准备好做一些工作。
该承诺将立即解决，因为
resolve（）
回调处理程序是在任何异步之外调用的。基本上
新承诺（（resolve，reject）=>{let import_files=/*some promise exp*/；resolve（import_files）；}）
实际上看起来像是一个承诺，返回一个承诺。看起来你可以做
import_调用。然后（request=>request）。然后（…
我认为你是对的@WilliamLohan，但这看起来不是一个黑客行为吗？我正在试图找到这个不起作用的根本原因。我相信问题在于新数组的行（response.data.number of_files）.fill…您希望返回的结果是：return new Array（response.data.number of_files）.fill…@Alvaro Ccatamayo是对的，在传递给
get_number of_files\u 1的回调中没有return语句。然后（…）
所以它就像一个“火与忘”一样承诺立即解决未定义的
难以置信且更简洁。我盲目地遵循“用JS方式编写”当我需要清楚地看到发生了什么，这很有帮助。但我仍然不明白为什么会这样。有机会解释一下吗？我选择这个答案是因为它有效，我可以看出它在易读性方面有多好，但请为我的原始问题添加一些解释，我将永远感激。@cool面食，原始代码哈It’有很多问题，我承认我已经放弃了去理解所描述的行为。我现在非常忙，但等事情平息下来后，我会看看我是否能回到这个问题上来。在最初的代码中，主要的事情似乎是在
之前的承诺中。然后（（响应）{…}）
，
响应
已测试但未返回。重复使用成员名称
响应
没有帮助。请注意，在我的版本中，一个
响应
完全消失，为清楚起见，另一个已更改为
res
。