Fatal编程技术网
  • javascript/
  • Javascript 我是否正确使用此承诺功能

Javascript 我是否正确使用此承诺功能

javascript node.js

Javascript 我是否正确使用此承诺功能,javascript,node.js,promise,es6-promise,Javascript,Node.js,Promise,Es6 Promise,我正在使用node从一个使用cheerio的url获取一些数据 const request=require('request'); const cheerio=require('cheerio'); const Promise = require('promise'); 函数getDataParms（parm1，parm2） 返回承诺对象 通过retrieveAllData（parm1，limit） 最终输出来自 var test2 = retrieveAllData('foo','2015'

我正在使用node从一个使用cheerio的url获取一些数据

const request=require('request');
const cheerio=require('cheerio');
const Promise = require('promise');
函数
getDataParms（parm1，parm2）
返回承诺对象

通过
retrieveAllData（parm1，limit）

最终输出来自

var test2 = retrieveAllData('foo','2015');
console.log(test2);
node script.js的输出

// [ Promise { _75: 0, _83: 0, _18: null, _38: null } ]
在某些地方，我没有正确使用promise方法，我也不知道在哪里。我需要一些有经验的眼睛来帮助我找出我做错了什么

守则：

const request=require('request');
const cheerio=require('cheerio');
const Promise = require('promise');

var dateVal = new Date();
var test2 = [];

function retrieveAllData(parm1, limit){
    var output = [];
    var intermediate;

    for (var j=1; j <= limit; j++){
        var objKey = parm1 + "_data";
        var results = {
            "data1": null,
            [objKey]: null
        };

        results.data1 = j;
        objKey = objKey + "_" + j;
        results[objKey] = getDataParms(parm1, j).then(function(value){
            //console.log(value);
            return value;
        });

        //console.log(results[objKey]);
        output.push(results[objKey]);
    }
    return output;
}

// Returns a Promise array
function getDataParms(parm1, parm2){
    var sourceURL = "http://website/source=" + material + "&parm1=" + parm1 + "&parm2=parm2";
    var parsedResults = [];
    var metadata = {
      record_parm2: time_period,
      record_no: null,
      record_date: null,
      col1: null,
      col2: null,
      col3: null
    };

    return new Promise(function(fulfill, reject){
            request(sourceURL, function(error,response,html){
              if (error){
                reject(error);
              } else if (!error && response.statusCode == 200){
                var $ = cheerio.load(html);
                $(".data tr").each(function(i, element){
                    metadata.record_no = i;
                        $(this).find("td").each(function(cellindex){
                          switch(cellindex){
                           case 0:
                                metadata.record_date = $(this).text();
                            break;
                           case 1:
                                metadata.col1 = parseFloat($(this).text());
                            break;
                           case 2:
                                metadata.col2 = parseFloat($(this).text());
                            break;
                           case 3:
                                metadata.col3 = parseFloat($(this).text());
                            break;
                          }
                      });   

                    parsedResults.push(metadata);
                });

                fulfill(parsedResults);
                }
        });
    });
}

var test2 = retrieveAllData('foo','2015');
console.log(test2);

const request=require（'request'）；
const cheerio=需要（“cheerio”）；
常量承诺=要求（“承诺”）；
var dateVal=新日期（）；
var test2=[]；
函数retrieveAllData（parm1，极限）{
var输出=[]；
var中间值；

对于（var j=1；j因为每个
getDataParms
调用都返回一个
Promise
，您应该等待所有这样的承诺首先用
Promise来解析。all
。另外，因为
getDataParms
返回一个
Promise
，所以使用
getDataParams
的
retrieveAllData
也应该返回一个
承诺
以便最终的
结果
在以后可用。您应该调用
retrieveAllData（…
），而不是
var test2=retrieveAllData（…
），然后在
retrieveAllData
调用中调用


function retrieveAllData(parm1, limit){
  // Create an array of Promises, with `j`'s values being 0 to `limit - 1`:
  const allPromises = Array.from(
    { length: limit },
    (_, j) => {
      // Make j start at 1 rather than 0:
      j++;
      const objKey = parm1 + "_data_" + j;
      // After getDataParms resolves, return an object with keys `data1` and `[objKey]`:
      return getDataParms(parm1, j)
        .then((parms) => ({
          data1: j,
          [objKey]: parms
        }));
    }
  );
  return Promise.all(allPromises);
}


然后用
消费它。然后
：


retrieveAllData('foo','2015')
  .then(test2 => {
    console.log(test2);
  });


为
循环使用
，而不是功能性的，将如下所示：


function retrieveAllData(parm1, limit){
  const allPromises = [];
  for (let year = 1990; year <= limit; year++) {
    const objKey = parm1 + "_data_" + year;
    allPromises.push(
      getDataParms(parm1, j)
      .then((parms) => ({
        data1: j,
        [objKey]: parms
      }))
    )
  }
  return Promise.all(allPromises);
}



函数检索AllData（parm1，限制）{
常量allPromises=[]；
对于（让年份=1990年；年份）({
数据1:j，
[objKey]：帕尔姆斯
}))
)
}
返回承诺。全部（所有承诺）；
}

因为每个
getDataParms
调用都返回一个
Promise
，所以您应该等待所有这样的承诺首先使用
Promise.all
解析。另外，因为
getDataParms
返回一个
Promise
，所以使用
getDataParams
的
retrieveAllData
也应该返回一个
Promise
以便最终的
结果
在以后可用。您应该调用
retrieveAllData
而不是
var test2=retrieveAllData（…
），然后调用


function retrieveAllData(parm1, limit){
  // Create an array of Promises, with `j`'s values being 0 to `limit - 1`:
  const allPromises = Array.from(
    { length: limit },
    (_, j) => {
      // Make j start at 1 rather than 0:
      j++;
      const objKey = parm1 + "_data_" + j;
      // After getDataParms resolves, return an object with keys `data1` and `[objKey]`:
      return getDataParms(parm1, j)
        .then((parms) => ({
          data1: j,
          [objKey]: parms
        }));
    }
  );
  return Promise.all(allPromises);
}


然后用
消费它。然后
：


retrieveAllData('foo','2015')
  .then(test2 => {
    console.log(test2);
  });


为
循环使用
，而不是功能性的，将如下所示：


function retrieveAllData(parm1, limit){
  const allPromises = [];
  for (let year = 1990; year <= limit; year++) {
    const objKey = parm1 + "_data_" + year;
    allPromises.push(
      getDataParms(parm1, j)
      .then((parms) => ({
        data1: j,
        [objKey]: parms
      }))
    )
  }
  return Promise.all(allPromises);
}



函数检索AllData（parm1，限制）{
常量allPromises=[]；
对于（让年份=1990年；年份）({
数据1:j，
[objKey]：帕尔姆斯
}))
)
}
返回承诺。全部（所有承诺）；
}

您需要使用
承诺。在您的情况下，以下示例可能会对您有所帮助


function retrieveAllData(parm1, limit) {
    var output = [];
    for (var j = 1; j <= limit; j++) {
        output.push(getDataParms(parm1, j));
    }
    return Promise.all(output);
}

var test2 = retrieveAllData('foo', '2015'); // this will return a promise
test2.then(function (result) {
    console.log(result);
})



函数检索AllData（parm1，限制）{
var输出=[]；

对于（var j=1；j您需要使用
Promise.all
在您的情况下，以下示例可能会对您有所帮助


function retrieveAllData(parm1, limit) {
    var output = [];
    for (var j = 1; j <= limit; j++) {
        output.push(getDataParms(parm1, j));
    }
    return Promise.all(output);
}

var test2 = retrieveAllData('foo', '2015'); // this will return a promise
test2.then(function (result) {
    console.log(result);
})



函数检索AllData（parm1，限制）{
var输出=[]；

对于（var j=1；j），他在寻找一个对象数组，比如
[{“data1”：null[objKey]：null}，…][/code>，而不是一个值数组no。您似乎跳过了我正在使用的代码的整个关键元素。他在寻找一个对象数组，比如
[{“data1”：null[objKey]：null}，…]
，不是一个值数组否。您似乎跳过了我正在使用的代码的整个关键元素。不，我不是什么？4.8.2不，我不是什么？4.8.2坦克，这是有道理的，但我还不了解函数的胖箭头形式。所以我用另一种方式来做，我现在更了解。在（\uj）中的目的是什么为什么j从1开始而不是从0开始呢？我很困惑。然后（（parms）=>（{data1:j[objKey]：parms}）；在函数表示法的另一种形式中是这样的。然后（function（parms）{return{data1:j[objKey]：parms}？在这种情况下，箭头函数的工作原理与普通函数完全相同（只是它们更简洁）
数组的第二个参数。从
回调是
map
函数，对于该函数，第一个值是正在迭代的元素的值（即
undefined
），第二个值是正在迭代的元素的索引（这是有意义的，保持一个值0到
limit-1
。因此，第一个参数被称为
，表示它不会被使用。我做
j++
是为了模仿你正在做的事情-你也从
开始（var j=1；j但如果可能的话，从0开始，不递增
j
会更好。是的，后跟值的箭头函数意味着隐式返回值。（不能单独使用大括号，因为这样会将其解释为块而不是对象文字）我不知道从1开始。应该从1900开始。我希望能够输入一个年份范围；或者是一个特定的开始年份和结束年份，或者是一个特定的结束年份。我不太了解数组中发生了什么。from（）谢谢，这是有道理的，但我还不理解函数的胖箭头形式。所以我现在用另一种方式来做，我现在更了解。为什么uin（j），j开始于1而不是0？我很困惑。然后（（parms）=>（{data1:j，[objKey]：parms}））；在函数表示法的另一种形式中是.then（function（parms）{return{data1:j[objKey]：parms}？在这种情况下，箭头函数的工作原理与普通函数完全相同（只是它们更简洁）
数组的第二个参数。从
回调是
map
函数，对于该函数，第一个值是正在迭代的元素的值（即
undefined
），第二个值是正在迭代的元素的索引（这是有意义的，保持一个值0到
limit-1
。因此，第一个参数被称为
。
，表示它将不被使用。我做了
j++