JSON, also pronounced jason, stands for JavaScript Object Notation, and

is a lightweight data interchange format, that is the preferred means of

transmitting data in web service responses.

Why is it preferred?

Well, JSON is easy for us humans to read and write, and it's easy for machines

to parse and generate, and it's much more lightweight than it's predecessor XML.

This means that less data gets sent over the web, which is both faster and cheaper.

JSON data is made up of primitive data types, like integers, floating point

values, and strings, and can be represented by two types of structures.

First a collection of key-value pairs, and

in different languages this is most commonly realized as a dictionary or

hash table, and second, an ordered list of values.

These can be realized as an array or a list.

Because these two data structures are universal and have support in virtually

all the modern programming languages, it makes a lot of sense to use JSON

as a data format since it is interchangeable with different languages.

If the JSON data is an object, or

a dictionary, it begins with a left curly brace and ends with a right curly brace.

Each key in the key value pair is followed by a colon, and

key value pairs are separated by commas.

If, on the other hand, the object is an ordered collection of values, or an array,

it begins with a left bracket and

ends with a right bracket, with each value being separated by commas.

Now, within a given JSON structure you can encounter nested data, such that

an ordered list can contain a key value collection of information, and vice versa.

We've managed to get some data, but even though the darksky docs said that the data

would come back in the JSON format, this doesn't look like anything, right?

We just have a series of bytes here.

If we go back to the docs, and click on DOCS, and

then go to Response Format, okay, if I go up here, I think.

Yeah, so this is what we want to end up with, right?

So this is the example request, and this is an example response.

But how do we go from the data we have to JSON that looks like this?

Now to do that, we're going to use a class JSON serialization, which has

a class method, JSON object, that takes the data instance and converts it.

Now this conversion isn't always guaranteed to succeed, so

it is also a throwing one.

So we'll say, let json = try!,

forcing it again JSONSerialization.jsonObject

(with: weatherData, options: [ ] ).

Now, as we just saw, JSON can be structured either as a dictionary or

an array at the top level.

To account for this, jsonObject,

this method, returns a value of type any to work with.

So, what we need to do to get our dictionary,

because if we go back to the docs, we can see here that since this response,

the jsonObject begins with a curly brace, and then we have a set of keys and

values, we know that this in Swift, is going to be represented as a dictionary.

So over here what we need to do is, after asking the method to convert our data

object to JSON, we need to cast it to something more appropriate.

So we'll say as, actually you know what, we'll hold off from doing that.

Typically we need to cast the status either a dictionary or array, but

we'll just print that for now.

So print(json), and

you can see, that when you start typing it out, the type is represented as any.

Okay, now if we run this again, the console should pop up, and you will see

now that our data looks exactly like the sample response in the docs.

Where is it?

There we go.

Look at that, keys and values.

We're making some great progress.

You now know how to make a basic networking call, and

get some data from the web.

We could use this instance, this data instance, to populate

an instance of the current weather struct, and display information in our view, but

again there's a bunch of stuff we're doing that is not really the right way.

Why are we doing it this way then?

As always, watch on to find out.