We've got the status code printing out but that isn't much good.

We need to dig into the body of the response.

In order to get the body.

We need to read it in from the response.

Let's jump back into the documentation and see how we can do that.

The response object has a data event that gets emitted

when a piece of data comes in.

Let's try this out in our code and

log out what's happens when this event is triggered.

Let's run it and see what we have.

You may be expecting the data handler to run once after all

the data from the body comes in, but it's not it's run several times.

With only fragments of the body.

It's also not a string.

It's a buffer, a common data type emitted by the node network and file events.

When something is sent over a network like the Internet, is not sent in one go.

It sent in packets of information, many programming languages or frameworks,

wait until all data is transmitted before you can do anything.

However node JS uses streams to implement its non-blocking features.

So your application is free to do other things, whilst is waiting for

more data to be transferred.

To convert a buffer into a string call the toString method on the buffer.

We're not worried about buffers right now.

Just know that you can change them into strings easily with a toString method.

We can construct the body of the response by concatenating

each piece of data to the end of a variable body.

Let's create a body variable, which will have an empty string initially,

then we can add the chunks of data as they come in.

But how do we know when it ends.

It's not clear on the documentation page.

But whenever you see the data events in Node.js.

They'll be an end event.

When reading data off a hard disk or

off a network connection with node.JS APIs, they all comply to the same pattern.

They emit a data event, and a chunk of data comes in.

And then it emits an end event when it's completed reading the data in.

Let's implement the end handler now on the response.

Let's implement the end handler by writing response on, and the end event.

Next our event handler or callback will just print out the body using console.log.

Now that we have the full body, how do you make it into something usable?

Right now the body is just a string not an object.

If you're ever unsure of the type of an object you can use the type of keyword.

When we run this, we see that's the body of the response and then its type string.

Next we'll make this into an object by parsing the string