[MUSIC]

Hi, my name is Pasan, and

I'm an iOS Instructor at Treehouse.

In this series, we're going to take a look at serialization and

deserialization, or the encoding and decoding of data in Swift.

Much of what we do as Swift developers, whether it's moving iOS apps or

writing server-side code, is taking data that's constructed in a specific format,

say, JSON or a PLIST, and converting that to Swift objects.

In the past,

we've achieved this by leaning on foundation types like NSJSONSerialization,

which took in some JSON data and returned a foundation object.

While this got the job done, it wasn't ideal.

The class was not built with Swift in mind.

We would still use error prone methods,

like using stringly typed keys to parse the resulting object.

We had optionally cast inspect values, and we had

to coelest several points of failure, something coherent at the call site.

None of this felt at home in the type-safe world of Swift.

And this was evident by the fact that there was an explosion of third-party

JSON parsing libraries, each with their own set of custom operators.

In Swift 4 the core team added a language feature to handle this.

And that is what we are here to talk about.

So without any further ado, let's dive right into the Codable protocol.

Swift's attempt at solving this problem is by means of a protocol, or

rather a set of protocols.

So let's see how this works.

I have here a playground filed with some starter code.

And I'd like you to go to the notes section of this video, and

grab the same file using the download link provided.

Now, if you already went ahead and created your own playground to begin with, and

you just want to get the code and paste it in, there are links for that as well.

So in the playground,

make sure you're starting on this playground page named A Quick Peek.

There may be more than one playground page.

So if you have one of those files, just go to the navigator area by clicking this

icon, and then navigating to A Quick Peek.

So in here we have some simple sample JSON to start with,

defined as a multi-line string literal.

This isn't actually how JSON would be transmitted in a networking response, so

right after we have some code that's converting the string literal to a data

object using the UTF-8 string encoding.

This JSON represents some information about a particular employee

in some database.

Now, in a code base, we won't be working with string or data instances.

And instead we would have a model that represents this.

So we have one right here.

Now, our goal is to get the information, encapsulate it in this JSON response,

which is currently represented as an instance of the data type,

as an instant of the model.

And we can do this in three easy steps.

So step one, we're going to make our model conform to the Codable protocol.

There should be no additional work to do beyond that, and

we'll get into the why later.

Now, step two, and that's all we need to do with the model.

Step two, we need a decoder to handle decoding the JSON, parsing it,

and assigning values to the stored properties in our model.

Foundation now includes, as a Swift 4, new built-in decoder types.

So let's create an instance of JSON decoder.

Now that we have a decoder,

we can ask it to give us an instance of our model using the JSON provided.

So I'll say, let employee = try decoder.decode.Employee.self, from: json.

And just like that, we have an employee instance.

There are two important things to note here.

One is that this is a throwing operation.

For now we're ignoring this by using the forced version of the try.

Second, when we decode, we simply indicate what type we want to decode to.

So over here the type I want to decode to is employee, but

I don't pass in an instance because that's what we want.

Instead I pass in the type by saying Employee.self.

And that's all we need to do.

So in the results area, you can see that we have a valid employee instance.

And we can also inspect properties on the return instance.

So we can say employee.name.

Let me switch that, this is lowercase.

And you'll see that in the results area,

this matches up to the JSON data that we had defined earlier.

So let me scroll up a bit, so it says Employee name Pasan, id 1,

and that's what we have here.

Pretty easy?

Of course, there is a good amount of magic going on here.

So over the next few videos, let's break this simple example down.