相关疑难解决方法(0)

超越简单承诺的任何事情通常让我感到困惑.在这种情况下,我需要在N个对象上连续进行2次异步调用.首先,我需要从磁盘加载文件,然后将该文件上载到邮件服务器.我更愿意一起完成这两个动作,但是我已经通过先完成所有读操作然后再次上传所有内容来实现它.下面的代码有效,但我不禁想到它可以做得更好.有一点我不明白为什么when.all不拒绝.我对文档的解释似乎暗示,如果其中一个承诺拒绝,那么.all将拒绝.为了测试错误,我已经注释掉了较低的分辨率.没有错误,事情似乎工作得很好并且有意义.

mail_sendOne({
  from: 'greg@', 
  to: 'wilma@', 
  subject: 'F&B data', 
  attachments: [
    {name: 'fred.html', path: '/fred.html'}, 
    {name: 'barney.html', path: '/barney.html'}
  ]
})
.done(
  function(res) {
    console.log(res)
  },
  function(err) {
    console.log('error ', err);
  }
)  

function mail_sendOne(kwargs) {
  var d = when.defer();
  var promises = [], uploadIDs = [], errs = [];

  // loop through each attachment
  for (var f=0,att; f < kwargs.attachments.length; f++) {
    att = kwargs.attachments[f];

    // read the attachment from disk  
    promises.push(readFile(att.path)
    .then(
      function(content) {
        // upload attachment to …

代码:js:

angular.module('starter.services', ['ngResource'])
.factory('GetMainMenu',['$http','$q','$cacheFactory',function($http,$q,$cacheFactory) {
            var methodStr = 'JSONP';
            var urlStr = 'http://localhost/bd/wp-admin/admin-ajax.php';
            var ptStr = {action:'bd_get_main_menus',callback:'JSON_CALLBACK'};

            return {
                getMainMenuItems: function(){
                    var deferred = $q.defer();

                  $http.jsonp(urlStr,{params: ptStr})
                        .success(function (data, status) {

                            deferred.resolve(data);

                            return deferred.promise;
                        })
                        .error(function (data, status) {

                            deferred.reject(data);

                            return deferred.promise;

                        });
                }
            }

        }])

angular.module('starter.controllers', [])
.controller('AppCtrl', function($scope, $ionicModal, $timeout, $http,GetMainMenu) {
    GetMainMenu.getMainMenuItems().then(
      function(data){
        $scope.mainMenus = data;
      });
});

运行结果:

TypeError:无法在调用时读取未定义的属性'then'(ht .../www/js/controllers.js:42:33)(ht .../www/lib/ionic/js/ionic.bundle. JS:11994:17)...

这些代码哪里错了？

我希望履行一些其他承诺的承诺.关键是我真的希望在第一个承诺完成后立即获得(仍在等待的)第二个承诺.不幸的是,一旦两个承诺都得到满足,我似乎只能获得第二个承诺的分辨率值.

这是我想到的用例:

var picker = pickFile();

picker.then(  // Wait for the user to pick a file.
    function(downloadProgress) {
        // The user picked a file. The file may not be available just yet (e.g.,
        // if it has to be downloaded over the network) but we can already ask
        // the user some more questions while the file is being obtained in the
        // background.

        ...do some more user interaction...

        return downloadProgress;
    }
).then( // Wait for the download …

我正在构建表单验证并学习promises我决定使用promise模式实现异步验证函数:

var validateAjax = function(value) {
    return new Promise(function(resolve, reject) {
        $.ajax('data.json', {data: {value: value}}).success(function(data, status, xhr) {
            if (data.valid) {
                resolve(xhr)
            }
            else {
                reject(data.message)
            }
        }).error(function(xhr, textStatus) {
            reject(textStatus)
        })
    })
}

//...
var validators = [validateAjax];
$('body').delegate('.validate', 'keyup', function() {
    var value = $('#the-input').val();
    var results = validators.map(function(validator) {
        return validator(input)
    });

    var allResolved = Promise.all(results).then(function() {
        //...
    }).catch(function() {
        //...
    })
});

这似乎工作正常,输入被验证为用户类型(代码简化不会太长,例如缺少keyup后的超时等等).

现在我想知道如果前一个keyup事件的验证仍在进行中,如何终止ajax请求.是否可能以某种方式检测承诺在哪种状态并且可能拒绝来自外部的承诺？

我正在使用一个节点库，它允许发出简单的 http 请求并返回一个承诺 - 这很好用，因为它允许并行创建多个请求，然后我稍后使用Promise.all(). 但是，http 请求只返回一个字符串，我需要知道有关每个请求的一些额外标识信息。所以我认为这样做的一种方法是从请求承诺中链接一些东西并将该信息添加进去。 这是我到目前为止的代码，显示了一个这样的请求被添加到我稍后将收集的承诺数组中：

var promises = [];
promises.push(new Promise(function(resolve, reject){
    ReqPromise('http://some.domain.com/getresult.php')
    .then(function(reqResult) {
        resolve({
            source: 'identifier',
            value: reqResult
        });
    });
}));

这就是我在解决这个承诺时得到的回报：

{
    source: 'identifier'
    value: 1.2.3.4
}

这是“标记”承诺结果的理想方式吗？或者我对承诺有什么误解，这意味着我不需要像上面那样创建额外的承诺？请注意，这ReqPromise是在一个外部库中，因此很难让它接受额外的参数并返回它们。

上下文

我正在和Angular合作.我有一个名为UserService的服务,用于处理登录,身份验证和用户数据请求.

该GET方法需要检查用户是否有一个有效的(未过期)认证使得之前令牌get请求.因此,如果有,则发出请求,如果没有,请求令牌然后发出请求.

问题

此get方法需要隐藏其复杂请求.它必须只返回一个Promise,因为它只发出一个请求.

所以,一个用法的例子:

UserService
    .get()
    .then(data => { ... })
    .catch(error => { ... })

错误的解决方案

检查令牌是否已过期.如果是,则返回刷新令牌的请求,然后生成并返回get请求.如果不是,只需创建并返回get请求.如下:

function get() {
    if (isTokenExpired(token))
        return $http
            .post(url + '/refreshtoken', 'token=' + refreshToken)
            .then(response => {
                token = response.data.token
                return $http.get(url + '?token=' + token)
            })
            .catch(response => { ... })
    else
        return $http.get(url + '?token=' + token)
}

但它正在回复我将要处理的承诺:

UserService
    .get()
    .then(request => {
        request // THAT …

所以我有一个承诺,从服务器收集数据,但一次只收集50个响应.我收集了250份回复.

我可以像下面一样汇总承诺

new Promise((resolve, reject) => {
    resolve(getResults.get())
    })
    .then((results) => {
    totalResults.concat(results)
    return getResults.get()
    })
    .then((results) => {
    totalResults.concat(results)
    return getResults.get()
    }).then((results) => {
     totalResults.concat(results)
    return getResults.get()
    })

在这种情况下,我只需要250个结果,所以这似乎是一个可管理的解决方案,但是有一种方法可以在一个循环中汇总promise.所以我运行一个循环5次,每次运行下一个承诺.

对不起,我是承诺的新手,如果这是回调,这就是我要做的.

我有承诺的以下功能:

const ajaxRequest = (url) => {
  return new Promise(function(resolve, reject) {
    axios.get(url)
      .then((response) => {
        //console.log(response);
        resolve(response);
      })
      .catch((error) => {
        //console.log(error);
        reject();
      });
  });
}


const xmlParser = (xml) => {
  let { data } = xml;
  return new Promise(function(resolve, reject) {
    let parser = new DOMParser();
    let xmlDoc = parser.parseFromString(data,"text/xml");

    if (xmlDoc.getElementsByTagName("AdTitle").length > 0) {
      let string = xmlDoc.getElementsByTagName("AdTitle")[0].childNodes[0].nodeValue;
      resolve(string);
    } else {
      reject();
    }
  });
}

我正在尝试为JSON数组中的每个对象应用这些函数:

const array = [{"id": 1, "url": "www.link1.com"}, {"id": 1, …

我是承诺并使用rsvp实现的新手.

我想异步读取文件列表,然后只有在读取了所有文件后才进入另一个任务.

我已经有了基本结构来读取一个文件,并链接到下一个任务:

var loadFile = function (path) {
    return new rsvp.Promise(function (resolve, reject) {
        fs.readFile (path, 'utf8', function (error, data) {
            if (error) {
                reject(error);
            }
            resolve(data);
        });
    });
};

loadFile('src/index.txt').then(function (data) {
    console.log(data);
    return nextTask(data);
}).then(function (output) {
    //do something with output
}).catch(function (error) {
    console.log(error);
});

我想做这样的事情:

loadFile(['src/index.txt', 'src/extra.txt', 'src/another.txt']).then( ...

我在文档中看到过承诺和承诺的数组,但我不知道哪个是最相关的,或者如何使用它们.我需要在上面的问题的上下文中使用它们的一个例子来理解它们.

'use strict';

Promise.resolve(() => 'John')
  .then((args) => {
    console.log(args);
    throw new Error('ops')
  })
  .catch((ex) => {
    console.log(ex)
  })
  .then(() => {
    throw new Error('ups')
    console.log('Doe')
  })

我认为console.log(args);应该输出'John',但是当我运行此代码时,输​​出是[ [Function] ]

所以我很困惑.