承诺中的决心究竟做了什么？

Question

I am starting to learn about promises in Javascript and I am still not getting my head around it. The code below is mostly real code. I have placed several debugger statements so the program stops and I can understand how the flow works and inspect some variables. I have read some blog posts about promises and I still can't understand everything. This is from an app which uses AngularJS and q library.

Few questions:
1- What does deferred.Resolve() do exactly? What is it doing with response.data? When I inspected the 'deferred' object and its 'promise' object, I couldn't see any trace for response.data.

2- When I resumed execution after debugger #1, I thought the http post statement would run but execution jumped to the return statement. I guess that's where the promise jumped in and the post will happen in the future?

3- How do I know when the post will happen when the function returns? The caller will get the return promise, what is the caller expected to do with it?

this.GetData = function() 
  {
    var data = blahblah;
    var deferred = this.$q.defer();
    debugger;  //1
    this.$http.post(someurl, data,
               {
                  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
                              handleErrors: false
                           })
                            .then(function(response) {
                                debugger; //2
                               (domesomething...)
                               deferred.resolve(response.data);
                            },
                             function(error) {
                              (logerror...)
                              deferred.reject(error);

                });
                debugger; //3
                return deferred.promise;
    };

Answer 1

It's appropriate to use q.defer() (an explicit creation of a promise) when wrapping callback style code, "promisifying"...

this.timeoutWithAPromise = function(msec) {
  let defer = q.defer();
  setTimeout(() => defer.resolve(), msec);
  return defer.promise;
};

The foregoing says: "Create a promise and return it right away. That promise will be fulfilled when msec has passed.

Question 1: resolve() fulfills the promise, calling whatever function that's been set with then() , passing it whatever parameter was passed to resolve.

Question 2: You're right, the async operation is begun and a promise for it's completion is returned right away.

Question 3a: The post will begin (or the timeout will commence in my eg) on another thread as soon as that invocation is made. It will continue concurrently with execution on this calling thread, until it completes, which you understand from Question 1, is done by resolving the promise, invoking it's then() .

Question 3b: What is the caller to do with a returned promise? Attach a block to it that you wish to run upon completion, possibly additional async actions. Taking my example...

let self = this;
self.timeoutWithAPromise(1000).then(()=> {
    console.log('1000msec have passed');
    return self.timeoutWithAPromise(1000);
}).then(()=> {
    console.log('now, another 1000msec have passed');
    // ...

Rewriting your example, realizing that $http already conforms to promises...

var data = blahblah;
let headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
let config = { headers: headers, handleErrors: false };
let httpPromise = this.$http.post(someurl, data, config).then((response)=> {
    console.log('got a response. tell our caller about it');
    return response.data;
}).catch((error)=>
    console.log('got an error.  either handle it here or throw it');
    throw error;
});
// this is important:  return the httpPromise so callers can chain off of it
return httpPromise;

Now a caller can say:

let promiseToDoEvenMore = this.GetData().then((data)=> {
    console.log(data);
    return this.GetMoreData();  // etc.
});
return promiseToDoEvenMore;   // and so on