Promise result and its processing into two separate files

Question

In my script I need to make a XMLrequest, get the response from the server (if resolved), parse it and place the parsed result in a variable.

Only later, with this variable I can do lot of stuff.

So basically, I am trying to separate the creation of such parser object from the rest of my code, in order to:

• place the above process into a function in an external script which I can call whenever I need.
• not having all my code within a .then() method
• organize my code into logical files each devoted to a specific task

So I came up with this piece of code (just a sample) to explain my needs. As I am fairly new to asyncronous programming, would it be fine to do like so, given that the response should be very fast to resovle (or to reject) in my case?

If it's ok, I would then put this inside a separate file to be able to import it and call testing() (or whatever the name will be) from anywhere I need.

function delay(input) {
    return new Promise(function(resolve, reject) {
        // some async operation here
        setTimeout(function() {
            // resolve the promise with some value
            resolve(input + 10);
        }, 500);
    });
}

function testing() {delay(5).then(result => {return document.write(result)})};

testing();

EDIT

Ok, so I think I hit the problem thanks to the answer of @DrewReese and the links in the comments.

I am trying to solve this situation: the code above was misleading to understand my point, but I guess tere's no really simple solution. Look at this code (it's basically the same as the one above, except fot the last three lines):

function delay(input) {
    return new Promise(function(resolve, reject) {
        // some async operation here
        setTimeout(function() {
            // resolve the promise with some value
            resolve(input + 10);
        }, 500);
    });
}

function testing() {delay(5).then(result => {return result})};

var test = testing();
document.write(test);

So in this case, I know when I am defining test the output is 'undefined' because the Promise in testing() has not yet resolved.

The problem I'm trying to solve is: is there (if any) a way to define test only when the Promise is resolved without wrapping it in a then() and maybe outputting something different when it's not resolved (like "LOADING...").

I don't know basically if it is possible to check if a variable has a Promise pending and outputting two different values: when it's waiting and when it's resolved/rejected.

Hopefully I was clear enough, otherwise I'll test more and come back with another question if needed.

Answer 1

The whole point of promises (promise chains) is to escape from "nesting hell" by flattening your "chain", so yes, when your promise chain is resolving blocks of code, it is returning a promise which is then-able. I hope this helps illustrate:

someAsyncHttpRequest(parameter) // <- Returns Promise
    .then(result => {
        // do something with result data, i.e. extract response data, 
        //  mutate it, save it, do something else based on value
        ...
        // You can even return a Promise
        return Promise.resolve(mutatedData);
    })
    .then(newData => {  // <- mutadedData passed as parameter
        // do new stuff with new data, etc... even reject
        let rejectData = processNewData(newData);
        return Promise.reject(rejectData);
    })
    .catch(err => {
        console.log('Any caught promise rejection no matter where it came from:', err);
    })
    .finally(() => {// You can even run this code no matter what});

If you need to use any variable values you set within the chain, then you need to make the outer function async and await on the resolution of the promise chain:

asyncFunction = async (parameter) => {
    let asyncValue;

    await someAsyncHttpRequest(parameter)
        .then(result => {
            ...
            asyncValue = someValue;
            ...
        });
    // safe to use asyncValue now
};

So for you:

function delay(input) {
    return new Promise(function(resolve, reject) {
        // some async operation here
        setTimeout(function() {
            // resolve the promise with some value
            resolve(input + 10);
        }, 500);
    });
}

**async** function testing() { // Declare this an asynchronous function
    let value = **await** delay(5); // Now you can await the resolution of the Promise
    console.log(value); // Outputs resolved value 15!
    return value; // Just returns resolved Promise
}

var test = testing();

console.log(test); 
/** Outputs the Promise!
   Promise {<pending>}
     __proto__:Promise
     [[PromiseStatus]]:"resolved"
     [[PromiseValue]]:15
*/

test.then(console.log)); // Outputs returned resolved value, 15