无法保证可以使用外部功能

Question

I'm trying to wrap my head around the javascript promises since I need them in a project I'm working on. I've tried several things but never got it to work.

Here's the problem:

I have a function that connects to a server via websockets, grabs certain infos and delivers them as an object. As this is async, I need to wait until this process has finished to go on with the infos I got.

This is the global function for getting the infos:

function getInfos(par1, par2) {

    // Open Websocket connection, ask for infos and wait for Answer/Message.

    OnMessage: function (aEvent, aToken) {
        if (aToken == "JustAString") {

            // Does this work this way? I need to get the "aToken" to the "MyCalltoServer" Function that called this mess here
            return aToken;

           // Tried this to resolve the promise created in the other script.
            resolve(MyCallToServer);
        }
    }
}

This is how I tried to create a promise with my existing getInfos function.

var promiseResolve, promiseReject;

var MyCallToServer = new Promise(function(resolve, reject){

promiseResolve = resolve;
promiseReject = reject;

getInfos(par1,par2);


});

MyCallToServer.then(function(){
    console.log("done");
    console.log(aToken);
})

Long story short - it doesn't work at all. Any help is greatly appreciated. The thing is I can't change the construction of the getInfos function since it's way to complex already (300 cases for different answers). So I thought maybe there's a way to include the promise resolving in it?

Any Help is greatly appreciated !!!

Answer 1

Not certain why OnMessage is within getInfos or why the syntax is

OnMessage: function (aEvent, aToken) {}

You can return a Promise from getInfos() call, pass aToken to resolve() , include error handling function passed to .catch()

function getInfos(par1, par2) {

  // Open Websocket connection, ask for infos and wait for Answer/Message.
  return new Promise(function(resolve, reject) {
    function OnMessage(aEvent, aToken) {
        if (aToken == "JustAString") {
            resolve(aToken);
        }
    };
    OnMessage()
  })
}

function MyCallToServer(par1, par1) {
  return getInfos(par1, par2)
}

function handleMyCallToServer(aToken) {
  console.log("done");
  console.log(aToken);
}

function handleMyCallToServerErroir(err) {
  console.log("error");
  console.err(err);
}

MyCallToServer(1, 2)
.then(handleMyCallToServer)
.catch(handleMyCallToServerError)

Answer 2

Promises can't be reused. Creating a global promise variable to be resolved/rejected from a parameterized function that can be called multiple times is tantamount to setting up non-reentrant, asynchronous code. Do not go there.

A classic way to provide asynchronous data is to use a call back function taking two parameters, one of which is set according to the final result of the operation:

 function getInfos( par1, par2, callBack) {

     //  in asynchronous code that successfully delivers dataObject 

          callBack( false, dataObject); // valid data
          return; // from asynchronous service code

     //  in asynchronous code that detected an error

          callBack( error) // no valid data
          return; // from asynchronous service code

  }

which is called with a callback function patterned on:

  function callBack( err, data) {
      if( err) {
      //   the bad news
      }
      if( data) {
      // the good news.
      }
  }

Alternatively you can promisify getInfos by returning a pending promise that is resolved or rejected after network operations have taken place. This can be achieved by placing all the code (for getInfos ) in an ES6 promise executor function which is called synchronously during promise construction:

function getInfos( par1, par2) {
    return new Promise( function(resolve, reject) {
        // initiate getInfos things with supplied par1, par2 values

        // in asynchronous code that successfully created dataObject

             resolve( dataObject);
             return; // from asynchronous service code

        // in asynchronous code that failed
             reject( new Error( "error text");
             return; // from asynchronous service code
    });
}

Some libraries provide both mechanisms by always returning a promise (which need not be used) besides conditionally calling a callback if one is provided. I would suggest simply promisifying getInfos in this case.

---

Edit. The code in comment replicates a JQuery "deferred" object with a variety of deconstructed promise object components and variables. This is a kludge I do not recommend pursuing.

A simpler solution is to first modify getInfos to return a promise then replace

 $(document).ready(function() { var promiseResolve, promiseReject; var FunctionThatCallsServerFunction = new Promise(function(resolve, reject) { promiseResolve = resolve; promiseReject = reject; getInfos(par1,par2); }); FunctionThatCallsServerFunction.then(function() { console.log("done"); // aToken should be received from the ServerFunction console.log(aToken); }) }) 

with

 $(document).ready( function() { getInfos( par1, par2) .then(function( aToken) { console.log("done"); console.log(aToken); }) .catch( function( err) { console.log("An error occurred: "); console.log( err); }); }) 

which uses the promise returned by getInfos directly. Notice that

• the value used to fulfill a promise is passed as the argument value to a fulfillment handler supplied with .then , and
• generally include a catch clause to avoid "unhandled promise rejection" exceptions being thrown by Promise software in the event of an error.