Obtenez de l'état Angulaire différé?

Mise à jour:

En raison de la refonte de $q c'est maintenant possible, bien que non documenté:

promise.$$state.status === 0 //pending
promise.$$state.status === 1 //resolved
promise.$$state.status === 2 //rejected

Original:

Contrairement à la plupart des promesse bibliothèques (Bluebird,Q, lorsque, RSVP, etc), $q ne pas exposer synchrone de l'inspection de l'API.

Il n'y a pas de façon de le réaliser à partir de l'extérieur.

Vous devez appeler .then sur la promesse et le code de cette fonction à exécuter lorsque la promesse remplit.

Mis à jour à:

Malheureusement, cela ne semble pas comme son possible avec $q. Vous devez mettre ce code à l'intérieur de votre then méthode.

myPromise()
.then(function() {
    //everything in here resolved
},
function() {
    //everything in here rejected
},
function() {
    //everything in here pending (with progress back)
});

Autres:

C'est pour le Q de la bibliothèque ne angulaire du $q mais similaires.

Angulaire est inspiré par le Q bibliothèque, découvrez la source, n'est pas aussi effrayant. https://github.com/kriskowal/q/blob/v1/q.js

Vous pouvez utiliser myPromise.inspect().state il y a ['pending', 'rejected', 'fulfilled']

Vous avez aussi:

myPromise.isFulfilled();
myPromise.isPending();
myPromise.isRejected();

Découvrez ce JSfiddle et ouvrir la console pour connecté résultats.
http://jsfiddle.net/S6LzP/

Plus granulaire, en Regardant les defer fonction sur la ligne de 488:

function defer() {
//if "messages" is an "Array", that indicates that the promise has not yet
//been resolved.  If it is "undefined", it has been resolved.  Each
//element of the messages array is itself an array of complete arguments to
//forward to the resolved promise.  We coerce the resolution value to a
//promise using the `resolve` function because it handles both fully
//non-thenable values and other thenables gracefully.
var messages = [], progressListeners = [], resolvedPromise;
var deferred = object_create(defer.prototype);
var promise = object_create(Promise.prototype);
promise.promiseDispatch = function (resolve, op, operands) {
var args = array_slice(arguments);
if (messages) {
messages.push(args);
if (op === "when" && operands[1]) { //progress operand
progressListeners.push(operands[1]);
}
} else {
nextTick(function () {
resolvedPromise.promiseDispatch.apply(resolvedPromise, args);
});
}
};
//XXX deprecated
promise.valueOf = function () {
if (messages) {
return promise;
}
var nearerValue = nearer(resolvedPromise);
if (isPromise(nearerValue)) {
resolvedPromise = nearerValue; //shorten chain
}
return nearerValue;
};
promise.inspect = function () {
if (!resolvedPromise) {
return { state: "pending" };
}
return resolvedPromise.inspect();
};
if (Q.longStackSupport && hasStacks) {
try {
throw new Error();
} catch (e) {
//NOTE: don't try to use `Error.captureStackTrace` or transfer the
//accessor around; that causes memory leaks as per GH-111. Just
//reify the stack trace as a string ASAP.
//
//At the same time, cut off the first line; it's always just
//"[object Promise]\n", as per the `toString`.
promise.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
}
}
//NOTE: we do the checks for `resolvedPromise` in each method, instead of
//consolidating them into `become`, since otherwise we'd create new
//promises with the lines `become(whatever(value))`. See e.g. GH-252.
function become(newPromise) {
resolvedPromise = newPromise;
promise.source = newPromise;
array_reduce(messages, function (undefined, message) {
nextTick(function () {
newPromise.promiseDispatch.apply(newPromise, message);
});
}, void 0);
messages = void 0;
progressListeners = void 0;
}
deferred.promise = promise;
deferred.resolve = function (value) {
if (resolvedPromise) {
return;
}
become(Q(value));
};
deferred.fulfill = function (value) {
if (resolvedPromise) {
return;
}
become(fulfill(value));
};
deferred.reject = function (reason) {
if (resolvedPromise) {
return;
}
become(reject(reason));
};
deferred.notify = function (progress) {
if (resolvedPromise) {
return;
}
array_reduce(progressListeners, function (undefined, progressListener) {
nextTick(function () {
progressListener(progress);
});
}, void 0);
};
return deferred;
}

Surtout notamment la méthode et à très bas deferred.notify.

Exemple d'utilisation:

function requestOkText(url) {
var request = new XMLHttpRequest();
var deferred = Q.defer();
request.open("GET", url, true);
request.onload = onload;
request.onerror = onerror;
request.onprogress = onprogress;
request.send();
function onload() {
if (request.status === 200) {
deferred.resolve(request.responseText);
} else {
deferred.reject(new Error("Status code was " + request.status));
}
}
function onerror() {
deferred.reject(new Error("Can't XHR " + JSON.stringify(url)));
}
function onprogress(event) {
deferred.notify(event.loaded / event.total);
}
return deferred.promise;
}
requestOkText("http://localhost:3000")
.then(function (responseText) {
//If the HTTP response returns 200 OK, log the response text.
console.log(responseText);
}, function (error) {
//If there's an error or a non-200 status code, log the error.
console.error(error);
}, function (progress) {
//Log the progress as it comes in.
console.log("Request progress: " + Math.round(progress * 100) + "%");
});