Javascript Node.js承诺使用冰棒异步

我有一个函数，它使一个API调用返回一个承诺。 将此代码转换为对不同时间戳进行n次调用的最佳方法是什么。我想返回一个对象，其中包含由键timestamp存储的未聚合数据

此代码在i=1时运行，histData未定义

const getEthPriceHistorical= (toSymbol) => {
    var histData = {};
    var ts;
    for (let i = 1; i < 5; i++){
        ts =  new Date(new Date().getTime() - (24*i * 60 * 60 * 1000));

        if (typeof toSymbol === 'string') {
           toSymbol = toSymbol.toUpperCase();
        } else {
            toSymbol = 'USD,EUR,GBP,CHF,THB,AUD,INR';
        }
        ***** WHAT TO DO WITH THIS SINGLE PROMISE *****
        return popsicle.request({
           method: 'POST',
           url: 'https://min-api.cryptocompare.com/data/pricehistorical',

           query: {
            fsym: 'ETH',
            tsyms: toSymbol,
            timestamp: ts
           }
       })
         .use(popsicle.plugins.parse(['json']))
         .then(resp => resp.body)
         .then(data => {
            const symbols = Object.keys(data);
            histData.ts = data;
            console.log(ts, data);
        });
  }
  return histData;
}

const getethpricehistical=（toSymbol）=>{
var histData={}；
var-ts；
for（设i=1；i<5；i++）{
ts=新日期（new Date（）.getTime（）-（24*i*60*60*1000））；
if（typeof-toSymbol=='string'）{
toSymbol=toSymbol.toUpperCase（）；
}否则{
toSymbol='美元、欧元、英镑、瑞士法郎、泰铢、澳元、印度卢比'；
}
*****这个承诺怎么办*****
返回冰棒。请求({
方法：“POST”，
网址：'https://min-api.cryptocompare.com/data/pricehistorical',
查询：{
fsym：‘ETH’，
tsyms:toSymbol，
时间戳：ts
}
})
.use（冰棒.plugins.parse（['json']））
.然后（resp=>resp.body）
。然后（数据=>{
常量符号=对象键（数据）；
histData.ts=数据；
控制台日志（ts、数据）；
});
}
返回历史数据；
}

您的代码存在以下问题：

循环中的返回从函数返回——这就是循环只运行一次的原因

histData是该函数的局部变量，以异步方式填充。在这个函数外不可见，在这个函数内我看不到，你甚至不能确定它是未定义的

行

histData.ts=data

将更改每次迭代中的

ts

属性（如果有多个）-应该是

histData[ts]=data

希望在考虑到代码中的错误后，下面的代码是不言自明的

注意：

Array.from（{length:4}）

在索引0…3中创建一个包含四个未定义项的数组-因此时间戳使用

（i+1）

或者，可以选择最后8行左右

        .then(data => {
            const symbols = Object.keys(data);
            return {[ts]: data};
        });
    }))
    .then(results => results.reduce((result, item) => Object.assign(result, item), {}));
}

---

注：无论哪种方式，什么是

const symbols=Object.keys（数据）除了不起任何作用的冗余代码之外？
您的代码存在以下问题：

循环中的返回从函数返回——这就是循环只运行一次的原因
histData是该函数的局部变量，以异步方式填充。在这个函数外不可见，在这个函数内我看不到，你甚至不能确定它是未定义的
行
histData.ts=data
将更改每次迭代中的
ts
属性（如果有多个）-应该是
histData[ts]=data
希望在考虑到代码中的错误后，下面的代码是不言自明的

注意：
Array.from（{length:4}）
在索引0…3中创建一个包含四个未定义项的数组-因此时间戳使用
（i+1）

或者，可以选择最后8行左右

        .then(data => {
            const symbols = Object.keys(data);
            return {[ts]: data};
        });
    }))
    .then(results => results.reduce((result, item) => Object.assign(result, item), {}));
}

注：无论哪种方式，什么是
const symbols=Object.keys（数据）除了不起任何作用的冗余代码之外？
您可以像编写同步逻辑一样编写逻辑，并通过同步执行器运行它：

main.js：

var nsynjs = require('nsynjs');
var popsicle = require('popsicle');

var getEthPriceHistorical = function(popsicle, toSymbol) {
    var histData = {};
    var ts;
    for (var i = 1; i < 5; i++){
        ts =  new Date(new Date().getTime() - (24*i * 60 * 60 * 1000));

        if (typeof toSymbol === 'string') {
           toSymbol = toSymbol.toUpperCase();
        } else {
            toSymbol = 'USD,EUR,GBP,CHF,THB,AUD,INR';
        }
        var data = popsicle.request({
           method: 'POST',
           url: 'https://min-api.cryptocompare.com/data/pricehistorical',

           query: {
            fsym: 'ETH',
            tsyms: toSymbol,
            timestamp: ts
           }
       })
         .data.body;

       histData[ts] = JSON.parse(data);
       console.log(ts+", got: "+data);
  }
  return histData;
}

var ctx = nsynjs.run(getEthPriceHistorical,{},popsicle,null,function(histData){
    console.log('done: '+ JSON.stringify(histData));
});

var nsynjs=require（'nsynjs'）；
var冰棒=需要（“冰棒”）；
var getEthPriceHistorical=函数（冰棒，toSymbol）{
var histData={}；
var-ts；
对于（变量i=1；i<5；i++）{
ts=新日期（new Date（）.getTime（）-（24*i*60*60*1000））；
if（typeof-toSymbol=='string'）{
toSymbol=toSymbol.toUpperCase（）；
}否则{
toSymbol='美元、欧元、英镑、瑞士法郎、泰铢、澳元、印度卢比'；
}
变量数据=冰棒.request({
方法：“POST”，
网址：'https://min-api.cryptocompare.com/data/pricehistorical',
查询：{
fsym：‘ETH’，
tsyms:toSymbol，
时间戳：ts
}
})
.数据机构；
histData[ts]=JSON.parse（数据）；
日志（ts+），获取：“+数据”；
}
返回历史数据；
}
var ctx=nsynjs.run（getEthPriceHistorical，{}，冰棒，null，函数（histData）{
log（'done:'+JSON.stringify（histData））；
});

请在此处运行此代码：
您可以像编写同步逻辑一样编写逻辑，并通过同步执行器运行它：

main.js：

var nsynjs = require('nsynjs');
var popsicle = require('popsicle');

var getEthPriceHistorical = function(popsicle, toSymbol) {
    var histData = {};
    var ts;
    for (var i = 1; i < 5; i++){
        ts =  new Date(new Date().getTime() - (24*i * 60 * 60 * 1000));

        if (typeof toSymbol === 'string') {
           toSymbol = toSymbol.toUpperCase();
        } else {
            toSymbol = 'USD,EUR,GBP,CHF,THB,AUD,INR';
        }
        var data = popsicle.request({
           method: 'POST',
           url: 'https://min-api.cryptocompare.com/data/pricehistorical',

           query: {
            fsym: 'ETH',
            tsyms: toSymbol,
            timestamp: ts
           }
       })
         .data.body;

       histData[ts] = JSON.parse(data);
       console.log(ts+", got: "+data);
  }
  return histData;
}

var ctx = nsynjs.run(getEthPriceHistorical,{},popsicle,null,function(histData){
    console.log('done: '+ JSON.stringify(histData));
});

var nsynjs=require（'nsynjs'）；
var冰棒=需要（“冰棒”）；
var getEthPriceHistorical=函数（冰棒，toSymbol）{
var histData={}；
var-ts；
对于（变量i=1；i<5；i++）{
ts=新日期（new Date（）.getTime（）-（24*i*60*60*1000））；
if（typeof-toSymbol=='string'）{
toSymbol=toSymbol.toUpperCase（）；
}否则{
toSymbol='美元、欧元、英镑、瑞士法郎、泰铢、澳元、印度卢比'；
}
变量数据=冰棒.request({
方法：“POST”，
网址：'https://min-api.cryptocompare.com/data/pricehistorical',
查询：{
fsym：‘ETH’，
tsyms:toSymbol，
时间戳：ts
}
})
.数据机构；
histData[ts]=JSON.parse（数据）；
日志（ts+），获取：“+数据”；
}
返回历史数据；
}
var ctx=nsynjs.run（getEthPriceHistorical，{}，冰棒，null，函数（histData）{
log（'done:'+JSON.stringify（histData））；
});

请在此处运行此代码：
您知道for循环中的返回将从封闭函数中返回，因此循环将不会运行多个迭代，因此，
return histData
也不会执行，但这并不重要，因为即使您得到了该返回，代码的异步性质将确保histData在返回之前不会被填充。-您需要理解（以及了解如何处理循环）第三，一旦您了解了所有这些，这一行
histData.t