小编Ber*_*rgi的帖子

我正在使用Nodejs和Q来运行一系列异步函数.如果一个失败,我想运行另一个函数,然后再次启动序列.这是它的原样:

var promise = database.getUserCookies(user)
    .then(function (data){
        return proxy.search(data);
    })
        .fail(function (data) {
            if (data.rejected === 302) {
                var relogin = database.fetchAuth(data)
                    .then(function (data) {
                        return proxy.login(data)
                    })
                    .then(function (data){
                        return database.saveCookies(data);
                    })
                    .then(function (data){
                        //Restart the promise from the top.
                    })
            }
        })
    .then(function (data){
        return responser.search(data);
    })

我正在使用这样的承诺:

var restClient = {
    serveRequest: function(rUrl, type, body, rHeaders, rAsync, callback) {  
        var promise = jQuery.ajax({
           url: rUrl,
           type: type,
           data: body,
           headers: rHeaders,
           async: rAsync,
           contentType: "text/plain",
           dataType: "json"
        });

        promise.then(onSuccess, onError);   
    },
    onSuccess: function(data) {
        callback(data);
    },
    onError: function(msg) {
        console.log(msg.responseText);
    }
}

如何在promise.then onSuccess中传递参数(回调)？我想稍后在onSuccess方法中使用它.

我正在使用JS Bin,我刚刚开始学习Javascript.在本书中,我使用console.log(函数)显示输出.这没有任何显示,我被迫使用alert(函数)来查看输出.有没有其他方法可以在JS Bin中看到输出.另外,console.log输出的确切位置,cos命令提示符不显示任何内容.

我正在使用角度的决心,并希望链接两个承诺.解决这个问题的最佳方式是什么？从本质上讲,我想:

resolve: {
    my_two_lists: function() {
    return MyService.list().then(function(array1) {     
         return MyOtherService.list().then(function(array2) { 
               return new Promise(function(resolve, reject) { 
                    resolve(array1.concat(array2)); 
               }); 
          }); 
       });
    }
}

换句话说:我有2个服务,每个服务都有两个叫做"list"的方法,它们返回一个解析为list的promise.我想链接两个由此产生的承诺.

在使用 Javascript 承诺时，我遇到了这种奇怪的行为。考虑以下代码：

var Q = require('q');

var d1 = Q.defer();
var d2 = Q.defer();

compare(d1.promise, d2.promise);

d1.resolve(3);
d2.resolve(3);

function compare(a, b) {
 Q.all([a,b]).then(function(results) {
  console.log('a: ' + a + '   b: ' + b);
  var result =  (a == b)? 1: -1;
  console.log(result);

 });
}

当您运行此代码时，您会得到 -1。我意识到我没有评估到那时传递给匿名函数的结果变量（我应该这样做）。我的具体问题是：

如果您使用大于 (>) 或小于 (<) 运算符更改松散相等 (==) 运算符，并更改传递给 resolve() 的值，则代码会按预期工作。

所以奇怪的行为是 == 在承诺方面的行为与 < 或 > 不同。似乎小于 (<) 和大于 (>) 以某种方式具有等待承诺结果的特殊能力，而相等运算符 (==, ===) 则没有。

谁能解释这种行为？

var exec = require('child_process').exec
var cmd = 'C:\\Users\\Johnny Cash\\Desktop\\executeme.exe'

exec(cmd, function(e, stdout, stderr) {
  console.log(e);
  console.log(stdout);
  console.log(stderr);
});

"C:\ Users\Johnny"未被识别为内部或外部命令

这必须是有史以来最新的问题,但如何在窗户上使用空格来逃避这些路径呢？它在这个空间被切断了,我所做的一切(单人或双人事先逃脱)似乎都可以解决问题.是否exec()做了一些格式,我不知道的？

我一直在处理一个函数,它返回几个数据库表的所有值.我正在尝试主动采用稳定的es6功能,这似乎是箭头功能的好机会.我使用蓝鸟作为承诺和续集作为我的ORM(它返回蓝鸟承诺的数据库查询)

/**
 * This does not work on node v4.2.0
 */
'use strict';

const Promise = require('bluebird');
const models = require('../database');

const resource = {
    browse: function browse() {
        return Promise.join(
            () => models.table_one.findAll(),
            () => models.table_two.findAll(),
            () => models.table_three.findAll(),
            function(table_one, table_two, table_three) {
                const response = {
                    table_one,
                    table_two,
                    table_three,
                };

                return response;
            });
    },
};

module.exports = resource;

这不起作用

/**
 * But this does
 */
'use strict';

const Promise = require('bluebird');
const models = require('../database');

const resource = …

在继续我的Web应用程序之前,我想要多个方法完全加载.为此,我做了以下 -

      function getData(){
        var defer = $q.defer();
        $http.get("/echo/json/").success(function(data, status) {
            getData2();
            getData3();
            $timeout(function(){        
                 defer.resolve(data);
            }, 1000); 
        });
        return defer.promise;
      }

在这里,getData2()和getData3()也会执行ajax调用.所以我必须等待这些方法来完成调用,然后我必须返回main方法的承诺.

这很好,但给我性能问题.我可以用其他任何方式吗？

我正在尝试编写一些代码,这些代码在启动一些可能长时间运行的异步活动后返回ES6承诺.但是,我希望有可能取消该活动,所以我想用'取消'方法来增加我的承诺.

一个sscce说明了我想要做的是如下:

function TimerPromise(timeInterval) {
    var timer;

    var p = new Promise(
        function(resolve,reject) {
            timer = setTimeout(
                function() {
                    resolve(true);
                },
                timeInterval
            );
        }
    );

    p.cancel = function() {
        clearTimeout(timer);
    };

    console.log("p.cancel is ",p.cancel);

    return p;
}

var t = TimerPromise(2000).then(function(res) { console.log("Result is ",res); });

t.cancel();

在示例中,TimerPromise只设置一个计时器来模拟长时间运行的异步活动.

这是我在运行时得到的:

$ node test.js
p.cancel is  function () {
                timer.clearTimeout();
        }
/home/harmic/js/src/test.js:28
t.cancel();
  ^

TypeError: t.cancel is not a function
    at Object.<anonymous> (/home/harmic/js/src/test.js:28:3)
    at Module._compile (module.js:413:34)
    at Object.Module._extensions..js (module.js:422:10)
    at …

我遇到了一些具有以下内容的代码:

var game = {
    gameBoard: [0, 0, 0,
                   0, 0, 0,
                   0, 0, 0],
    user: 'X',
    yOn: '',
    newStep: function(){
        ...
    }
}

我很困惑,因为我从未见过:像之前那样使用过.我复制了代码并尝试通过添加=来改变它,无论哪里有一个:但我一直得到一个意外的标识符错误(我这样做是为了看看:是否与=相同,我猜不是).