承诺循环。 如何检测哪个承诺现在返回结果？

Question

I think it's a common question, but for concreteness the situation is:
I use the mammoth module to convert docx files to html . The module returns a promise .
I have an array of files and when I use a loop to create a promise for every file I need to know what promise returns me a result (to know what file was processed).

for(var i=0;i<filesPaths.length;i++){
    mammoth.convertToHtml( {path: filesPaths[i]} )
        .then(function(result){
            filesHtml.push(result.value);
            //here I need to know the value of filesPaths[i]
        })
}

Answer 1

While writing the question, the answer became obvious (as is often the case :) ).
You can wrap the promise with a self invoked function and store any related info in local variable.

for(var i=0;i<filesPaths.length;i++){
   (function(){
     var fileName = filesPaths[i]; //or any other information related to promise
     mammoth.convertToHtml( {path: filesPaths[i]} )
        .then(function(result){
            filesHtml.push({
                text:result.value,
                fileName:fileName
                         });

        })
    })()
}

Answer 2

You can use .map() array method (which is much like your solution in terms of function calls, but a bit cleaner):

filesPaths.map(function(fileName, i){
  mammoth.convertToHtml({path: fileName})
    .then(/* ... */)
  ;
});
// Here filesHtml is empty and you don't know when will be filled!!

...which is dirty (see the comment at the end).

Or you can simply use Promise.all() to collect the results:

var P = Promise.all(
  filesPaths.map(function(fileName){
    return mammoth.convertToHtml({path: fileName});
  })
).then(function(resultArr){
  return Promise.all(resultArr.map(function(result, i){
    return {
      text: text.value,
      fileName: filesPaths[i],
    };
  }));
}).then(function(filesHtml){
  /* Here you know filesHtml is fully filled */
});

P.then(function(filesHtml){
  /* ...and here too */
});

This way, you also aren't messing things with global (or higher scope) variables.

Answer 3

To respond to your own answer with an alternative:

Creating functions in loops is not a great idea, it's a pretty good way to an unknown number of functions created. If you used a forEach loop you would get the same encapsulation in its callback function.

var arr = ['a', 'b', 'c'];

function prom(thing) {
    return Promise.resolve(thing);
}

for (var i = 0; i < arr.length; i++) {
    prom(arr[i]).then(function(val){ 
        console.log(`for: got val ${val} with arr[${i}]`);
    });
}   
// Logs:
// "for: got val a with arr[3]"
// "for: got val b with arr[3]"
// "for: got val c with arr[3]"

arr.forEach(function(val, index) {
    prom(val).then(function(val){ 
        console.log(`forEach: got val ${val} with arr[${index}]`);
    });      
});
// Logs:
// "forEach: got val a with arr[0]"
// "forEach: got val b with arr[1]"
// "forEach: got val c with arr[2]"