• I have read a lot of technical posts about "promise" in the past few days. I am dazzled by them, and I have only a little knowledge of them and roughly understand their functions.

• Let’s talk about the problem first. Ajax is used most in the project. There is a very unpleasant problem "multiple ajax dependency requests". Assume: R1 > R2( r1_result ) > R3( r2_result ),
  The most trouble-free way is to synchronize everything. The result is a terrible experience. Once the page freezes and the loading stops, the disgusting thing about using asynchronous operations is the layer after layer of callbacks, and more in the future. Depends on the operation.

• Life is about tossing, so I went back to the first paragraph and read through various things, and saw a certain brother analyzing the principle of promise. Here is the code from this brother, http://malcolmyu. github.io/ma...

function Promise(fn) {
  var state = 'pending';
  var value;
  var deferred = null;

  function resolve(newValue) {
    if(newValue && typeof newValue.then === 'function') {
      newValue.then(resolve, reject);
      return;
    }
    state = 'resolved';
    value = newValue;

    if(deferred) {
      handle(deferred);
    }
  }

  function reject(reason) {
    state = 'rejected';
    value = reason;

    if(deferred) {
      handle(deferred);
    }
  }

  function handle(handler) {
    if(state === 'pending') {
      deferred = handler;
      return;
    }

    var handlerCallback;

    if(state === 'resolved') {
      handlerCallback = handler.onResolved;
    } else {
      handlerCallback = handler.onRejected;
    }

    if(!handlerCallback) {
      if(state === 'resolved') {
        handler.resolve(value);
      } else {
        handler.reject(value);
      }

      return;
    }

    var ret = handlerCallback(value);
    handler.resolve(ret);
  }

  this.then = function(onResolved, onRejected) {
    return new Promise(function(resolve, reject) {
      handle({
        onResolved: onResolved,
        onRejected: onRejected,
        resolve: resolve,
        reject: reject
      });
    });
  };

  fn(resolve, reject);
}

• After reading it, I couldn't help but wonder again, then( function(){ do... } ), isn't this a callback? Could it be that the meaning of the tossing is to use syntax sugar (I don't believe it).

• Existence is reasonable, so in the end, how to use promises reasonably and how to operate the ajax process more elegantly? By the way, how do you feel about using ( axios \ fetch.js )?