Die Lösung eines latenten mit Winkel-s $q.wenn() mit ein Grund

Den Kern des Problems

Sie sind im Grunde versucht, zu konvertieren einer vorhandenen callback-API verspricht. In Eckigen $q.when ist für Versprechen aggregation, und für thenable assimilation (das heißt, Sie arbeiten mit einem anderen Versprechen, Bibliothek). Angst nicht, was Sie wollen, ist vollkommen machbar, ohne die cruft ein Handbuch latente jeder Zeit.

Latente Objekte, und das Versprechen Konstruktor

Traurig, mit Winkel-1.x sind Sie stecken mit der veralteten latente Schnittstelle, die nicht nur wie gesagt Sie ist hässlich, es ist auch unsicher (es ist riskant und wirft synchron).

Was Sie möchten, nennt das Versprechen Konstruktor, das ist es, was alle Implementierungen (Bluebird -, Q -, Wenn -, RSVP -, native verspricht, etc) wechseln zu da ist es schöner und sicherer.

Hier ist, wie Ihre Methode Aussehen würde, mit einheimischen verspricht:

var promise = new Promise(function(resolve,reject){
    notAPromise(
        function success(res) { resolve("Special reason") },
        function failure(res) { reject(new Error('failure')); } //Always reject
    )                                                          //with errors!
);

Können Sie replizieren diese Funktionalität in $q natürlich:

function resolver(handler){
    try {
        var d = $q.defer();
        handler(function(v){ d.resolve(v); }, function(r){ d.reject(r); });
        return d.promise;
    } catch (e) {
        return $q.reject(e); 
        //$exceptionHandler call might be useful here, since it's a throw
    }
}

Was würde Sie tun:

var promise = resolver(function(resolve,reject){
    notAPromise(function success(res){ resolve("Special reason"),
                function failure(res){ reject(new Error("failure")); })
});

promise.then(function(){

});

Eine automatische promisification Helfer

Natürlich, es ist gleichermaßen einfach zu schreiben ist eine automatische promisification Methode für Ihren konkreten Fall. Wenn Sie arbeiten mit einer Menge von APIs, die mit dem callback-Konvention fn(onSuccess, onError) Sie tun können:

function promisify(fn){
    return function promisified(){
         var args = Array(arguments.length + 2);
         for(var i = 0; i < arguments.length; i++){
             args.push(arguments[i]);
        }
        var d = $q.defer();
        args.push(function(r){ d.resolve(r); });
        args.push(function(r){ d.reject(r); });
        try{
            fn.call(this, args); //call with the arguments
        } catch (e){  //promise returning functions must NEVER sync throw
            return $q.reject(e);
            //$exceptionHandler call might be useful here, since it's a throw
        }
        return d.promise; //return a promise on the API.
    };
}

Damit würden Sie tun:

var aPromise = promisify(notAPromise);
var promise = aPromise.then(function(val){
    //access res here
    return "special reason";
}).catch(function(e){
    //access rejection value here
    return $q.reject(new Error("failure"));
});

Ist sogar ordentlicher