相关疑难解决方法(0)

我知道这不在a的范围内,Array.map但是我想等到上一个项目完成其承诺之后再开始下一个项目.碰巧我需要等待前一个条目保存在数据库中才能向前移动.

const statsPromise = stats.map((item) => {
    return playersApi.getOrAddPlayer(item, clubInfo, year); //I need these to wait until previous has finished its promise.
});

Promise.all(statsPromise)
.then((teamData) => {
  ..//
});

playersApi.getOrAddPlayer 返回一个 new Promise

编辑

阅读更多内容,显示playerApi.getOrAddPlayer似乎很重要

getOrAddPlayer: function (item, clubInfo, year) {
    return new Promise((resolve, reject) => {

        var playerName = item.name.split(' '),
            fname = playerName[0].caps(),
            sname = playerName[1].caps();

                Players.find({
                    fname: fname,
                    sname: sname,
                }).exec()
                .then(function(playerDetails, err){
                    if(err) reject(err);
                    var savePlayer = new Players();
                    //stuff
                    savePlayer.save()
                    .then(function(data, err){
                        if(err) …

我想在一个方法中等待,直到承诺返回.

public loginOffline(username: string, password: string) {
    return this.database.getItem('currentUser', 'login').then(data => {
        this.userLogin = data;
        console.log(username + ' ' + this.userLogin.username + ' ' + password + ' ' + this.userLogin.password);
        if (username === this.userLogin.username && password === this.userLogin.password) {
            return true;
        } else {
            return false;
        }
    }).catch(err => {
        return false;
    });

}

/********* call the method and descide what to do **************/
if (loginOffline('myname', 'mypassword'){
    // Do something.....
} else {
    // Do something else .....
} …

我已经看了几个关于promises递归的问题,并对如何正确实现它们感到困惑:

• javascript中的递归Promise
• AngularJS,承诺具有递归功能
• 链接承诺递归
• Javascript递归承诺

我把一个简单的例子(见下文)放在一起 - 这只是一个例子,所以我可以理解如何使用promises工作进行递归,而不是代表我正在工作的代码.

Net-net,我想要解决的承诺,但根据节点上的输出,它无法解决.有关如何解决问题的任何见解？

var i = 0;

var countToTen = function() { 
    return new Promise(function(resolve, reject) {
        if (i < 10) {
            i++;
            console.log("i is now: " + i);
            return countToTen();
        }
        else {
            resolve(i);
        }
    });
}

countToTen().then(console.log("i ended up at: " + i));

和控制台上的输出:

> countToTen().then(console.log("i ended up at: " + i));
i is now: 1
i is now: 2
i is now: 3
i is now: 4
i is now: 5 …

我是 node.js 环境的新手。我阅读了很多有关实现 Promise 并将它们链接在一起的资料。我试图避免反模式实现，但我不知道如何做到这一点。

系统中有一个用户注册流程。首先，我检查用户名。如果数据库中没有使用此用户名的用户，我将创建一个用户模型并将其保存到数据库中。

您能看到我的内联评论吗？

应用程序.js

RegisterUser("existUser","123").then(user=>{
    //send response, etc
}).catch(er => {
    console.log(er);
    //log error,send proper response, etc
    // Should I catch error here or inner scope where RegisterUser implemented ?
});

用户服务.js

function RegisterUser(username, password) {
    return new Promise((resolve, reject) => {
        GetUser(username) 
            .then(user=>{
                if(user)reject(new Error("User Exists"));
                else{
                    resolve(SaveUser(username,password))// Is that ugly?
                                                        //what if I have one more repository logic here ?
                                                        //callback train... 
                }
            }) 
            .then(user => {
                resolve(user);//If I do not want to resolve …

我的Angular 5项目中有一个服务，其中包含一些配置状态：

@Injectable
export class FooService {

    isIncognito: boolean = null;

    constructor() {

        // I want Angular to wait for this to resolve (i.e. until `isIncognito != null`):
        FooService.isIncognitoWindow()
            .then( isIncognito => {

                this.isIncognito= isIncognito;
            } );
    }


    private static isIncognitoWindow(): Promise<boolean> {
    // /sf/ask/203655721/
    // https://developer.mozilla.org/en-US/docs/Web/API/LocalFileSystem

        return new Promise<boolean>( ( resolve, reject ) => {

            let rfs = window['requestFileSystem'] || window['webkitRequestFileSystem'];
            if( !rfs ) {
                console.warn( "window.RequestFileSystem not found." );
                resolve( false );
            }

            const typeTemporary = 0;
            const …

在我的vanilla js项目中,我有一系列承诺:

API.POST({link to login endpoint}, "email=foo&pass=bar")
.then(() => User.initiate(API))
.then(() => console.log(User.name || 'wat'));

除了请求类型之外,API对象的POST和GET方法看起来都相同:

GET (url, params = null) {
    console.log("GET start");
    return new Promise((resolve,reject) => {
        this._request('GET', url, params)
        .then(result => resolve(result));
    });
}

POST (url, params = null) {
    return new Promise((resolve,reject) => {
        this._request('POST', url, params)
        .then(result => resolve(result));
    });
}

...以及负责发送请求的_request方法:

_request (type, url, params = null) {
    return new Promise((resolve, reject) => {
        var xhr = new XMLHttpRequest();
        xhr.responseType = 'json';
        xhr.open(type,url,true);
        xhr.withCredentials …

首先,我必须提到我已经在stackoverflow中查看了很多问题,但很多问题都没有回答我的问题.更不用说很多甚至没有答案.

如何实现以下功能,确保完成functionB()后执行functionA()？

注意:我不想将我的异步函数转换为,new Promise(resolve=>{...})
因为我必须转换someServiceThatMakesHTTPCall()调用堆栈中的以及任何其他异步函数,这是一个很大的改变.

  function functionThatCannotHaveAsyncKeyword() {
      functionA()
        .then(async function() {
            await functionB();
        })
        .then(function() {
            console.log('last');
        });
  }

  async function functionA() {
      console.log('first');
      await someServiceThatMakesHTTPCall();
  }

  async function functionB() {
      console.log('second');
      await someServiceThatMakesHTTPCall();
  }

我在这样的循环中调用异步函数（例如上传文件列表）：

return new Promise(async function(resolve, reject) { 
  for (let i = 0; i < list.length; i++) {
    let response = await myAsyncFunction();
    if (response.ok === false) {
      resolve({error: "Something goes wrong"});
      // break; - is this required?
    }
  }
}
async function myAsyncFunction() {
  return new Promise(async function(resolve, reject) {
     resolve code....
  }
}

如果在一个也在承诺中的循环中，我调用resolve()将循环继续迭代，否则它将停止在那里。
基本上，如果我在此之前解决，我需要break;循环调用吗？

努力让promise在promjs服务提供商中正常工作我已经阅读了文档以及大量的例子(这里,这里和这里),我想我的语法很好(虽然显然有些不对劲)

app模块和控制器看起来像

var myApp = angular.module('myApp', []);

myApp.controller('Controller_1', ['$scope', 'Service_1', function($scope, Service_1) {

    var myName = "Ben";

    Service_1.slowService(myName)
        .then(Service_1.fastService(name));

    $scope.myName = myName;
}]);

服务(具有慢速功能)看起来像这样:

myApp.service('Service_1', function($q) {
    this.slowService = function (name) {
        var deferred = $q.defer();
        console.log('Start of slowService:', name, Date.now());

        setTimeout(function() {
            console.log('setTimeout name:', name, Date.now());

            if(name){
                name = 'Hello, ' + name + " is learning Angularjs";
                alert(name); 
                    console.log('name:', name);
                deferred.resolve(name);
            } else {
                deferred.reject('No name supplied !'); …

我有一个函数数组,其中每个函数promise从ajax调用返回.

var promises = [];
if (form.$valid) { 
  Object.keys($scope.Model.Data.FormFiles).forEach(function (key) {
    var file = $scope.Model.Data.FormFiles[key];

    function uploadFile(){
        var deferred = $q.defer();
        var upload = Upload.upload({
            url: "/api/ir/funnelApi/UploadFile",
            data: { file: file }
        });

        upload.then(function (response) {                           
                // do something
                deferred.resolve(response.statusText);
            }, function (error) {
                deferred.reject(error.data);
            }, function (evt) {

        });             
        return deferred.promise;
    }       

    promises.push(uploadFile);
  });   
}

我想要做的是,如果所有文件都已成功上传,那么做一些事情.

$q.all(promises).then(function (responses) {                    
   // do something
}, function (errors) {
   // if any of the file upload fails, it should come …