Using 'body' returned from Request

Question

I am using https://github.com/request/request.

The example that is given is:

const request = require('request');

request('http://www.google.com', function (error, response, body) {
   console.error('error:', error); // Print the error if one occurred
   console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
   console.log('body:', body); // Print the HTML for the Google homepage.
});

How can I use body elsewhere in my code? I want something like return body but nothing works. I can't use it anywhere!

You can certainly use it in that callback where you logged it to the console, have you considered using it there? — Kevin B, Nov 18 '19 at 22:21
I need it elsewhere - to assign it to a const so I can use it much later in the code. — Zuriar, Nov 18 '19 at 22:24
That is unfortunate. You'll have to re-organize your logic such that that isn't the case. — Kevin B, Nov 18 '19 at 22:24
It can't be done. The code outside of the callback (the code that initiated the request) will be done long before the callback runs. you can't make it wait for a response. — Kevin B, Nov 18 '19 at 22:26
Yes, however you'll have to use a .then callback to access the value, or await it in an async function. — Kevin B, Nov 18 '19 at 22:34

jfriend00 · Accepted Answer · 2019-11-19T00:36:59.173

You cannot directly return an asynchronous result from outside the request() callback. This is not unique to this particular function, but is how all asynchronous callbacks work in Javascript.

When you call request() it starts an asynchronous operation and turns it over to native code. The JS interpreter then goes about it's merry way executing the rest of your Javscript after this function call (not in the callback, but after that). So, you should be able to immediately see that the body result does not exist yet, but the rest of your Javascript is already executing.

Then, some indeterminate time later (depending upon how responsive the server is that you're contacting and how big the result is), when the JS interpreter has nothing else to do, the callback gets called and the body result is available.

So, the ONLY place in your code that you know the body result is good and is available is INSIDE that callback. So, the general way of programming with an asynchronous operation like this in Javascript is that you use the result inside the callback. Any code that needs to use that result gets put inside that callback or you can put the code in a separate function and call that function from inside the callback and pass the body result as an argument to the function.

If you wanted to wrap this request in a function and communicate back that result to the caller (which is not exactly what you show here, but another way to write the code), I'd suggest you first read How do I return the response from an asynchronous call? because it outlines the various ways you can communicate back the body result from your asynchronous operation (another callback or use promises).

To many newbie Javascript developers this seems somewhat heretical. What do you mean I can't just call a function, get the result and return it from the function? Well, that's the extra complication with Javascripts non-blocking, asynchronous I/O model that is entirely event driven. Once you get down the learning curve, you will find a huge number of advantages in the language that flow from this architectural model, but you will have to deal with this extra complication.

The language is evolving to make this type of programming simpler with the use of promises in async functions and then the use of await to "wait" on a promise. If you use the request-promise library instead of the request library (request-promise is derived from request), then you can deal with a promise as the return value and you have more options.

const rp = require('request-promise');

async getMeSomeData() {
    try {
        let body = await rp('http://www.google.com');
        console.log(body);

        // can put code here that uses body

        return body;         // becomes the resolved value of the returned promise

    } catch(err) {
        console.log(err);
        throw err;           // makes sure the returned promise is rejected
    }   
});

getMeSomeData().then(body => {
    // use the body here
}).catch(err => {
    // error here
});

Note: I showed possibly using the body value or err inside getMeSomeData() or at the caller. Usually, you would do one or the other, but I wanted to show both ways.

thank you so much for such a detailed answer! much appreciated. — Zuriar, Nov 19 '19 at 08:32

Using 'body' returned from Request

1 Answers1