Let's continue to build on our example to make this a tiny bit more complicated and

a bit more realistic.

In the notes section of this video,

I've included a link to an updated sample of this JSON.

Paste that in, in place of this existing string literal.

So I've added a new key to the dictionary,

named candidates, that includes information about

other search results candidate that are not the best book listed above.

The difference here is that when you query the key candidates,

the value is an array, which then contains several dictionaries,

each of which represents a valid book and an author instance.

While this seems complicated, there's a lot going on here,

we have an array, nested dictionaries, and then further nested dictionaries.

We can actually model this in our type without much additional work.

So going back to the type, let's add a stored property, and

I'm in the search result type.

Let's add a stored property to define this.

Again, the key to properly doing this is understanding that our best bet

is matching the JSON structure as closely as possible.

We already know that if we have a nested dictionary containing book and author

data, the book type and then the author type can handle that decoding itself.

So we don't need to worry about that part.

The only new thing here is that the three dictionaries are inside an array, so

we need to model it as an array of books.

So here we'll say let candidates is in array of Book types, okay?

So again, back to CodingKeys, we need to add an enum member to the keys types.

So here, we'll say case candidates.

And then, in the init method, instead of asking the decoder to decode this into

a single instance of book, we'll specify an array of books.

So self.candidates = try innerContainer.decode,

array of Book.self, forKey.candidates.

If this seems weird, remember that an array of Book is a valid type.

So we're not doing anything wildly different here.

We can inspect this new property, so let's go down here.

And I'll say result.candidates.count.

And we should have a value of 3.

Look at that, done.

You'll often run into arrays containing dictionaries worth of information.

When you do, now you know that an implementation allowing for

the decoder to do much of the work, takes only a few lines of code.

Now a little bit of extra as to what's going on behind the scenes.

So when you call try innerContainer.decode Book.self,

what the decoder does is it creates an unkeyed container, right?

There are no keys in an array, just index values.

So it would be something like calling try

innerContainer.nestedUnkeyedContainer forKey.candidates.

And then, it would iterate through all of those, and

we'll look at how that happens in the future.

But it would iterate through all of those and for each key value pair or

rather no key value pairs.

But for each dictionary at each index value,

it's going to hand it off to the book type which will decode it and

come back eventually with an array result, okay?

What else?

So the encoding bit is also handled automatically for us.

Once we go in here, we just have to write one line of code.

We'll say try innerContainer.encode candidates, forKey: .candidates.

And again here, it's going to create a nested unkeyed container.

And if you look at our JSON string down here in the console, the dictionaries.

So we have the candidates key right at the top here, and

you'll notice that there's an array at the top, and then each value is a dictionary.

You can encounter information encoded in a combination of dictionaries and

arrays in many ways.

But as I mentioned earlier, the important part is modeling it just as the JSON is.

And you shouldn't have much difficulty parsing it.

For example, let's go back up to the top here, and we'll extract this candidates.

Where are we are?

Okay, so, over here, grab everything from the candidates key,

the key-value pair, all the way to the bottom where the array ends.

And then at the very end, we'll just put this in its own JSON string here.

So let candidatesJson =, remember

multi-line string literal, paste it inside.

We don't need to format this properly, and

we'll say .data using utf8 string encoding, okay.

Now if we wanted to parse this blob of JSON into an array of books,

without worrying about nested keyed containers and unkeyed containers.

Again, the way here, so notice here that we sort of have a wrapper key, right?

So the information is an array of books, which is the value.

And then we have a key to get to that, and if we wanted to decode this directly,

again a combination of a dictionary and an array of dictionaries,

we would say let candidates = try decoder.decode.

Again, remember is to modeling it exactly like the JSON is,

which is a dictionary with a key as a String.

And the value is an array of books.

And then on that entire type, we'll call .self, using candidatesJson.

I made a typo.

Let's see.

This is not using, I always get this key wrong, it's from.

Okay, and when we do that, what did I do wrong?

I've not copy pasted this JSON directly.

I'm pretty sure, okay, Enter, and I missed a closing dictionary brace, or did I?

And I missed the opening, right.

You need to start with an opening brace for a dictionary, then a key.

Okay, and when you do that, you'll see here that we have a dictionary

that has a key candidates and then an array of books in there.

The type here is string to an array of books .self.

So it's important to get that part right.

Resemble the JSON as much as possible.

Okay, let's wrap it up here.

In the next video, we'll look at what happens when data is potentially missing.