Forem: Jaume Viñas Navas

Parsing JSON with Swift 5

Jaume Viñas Navas — Thu, 03 Oct 2019 10:51:47 +0000

There are great libraries out there that help you parse JSON data, but it is great to see how Swift 5 implements a fully-native solution to make your data types encodable and decodable for compatibility with JSON.

There are three new protocols in the Swift standard library that define an standardized approach to data encoding and decoding. These new protocols are Encodable, Decodable and Codable

Encoding and Decoding

The easiest way to encode or decode a type is to use standard properties that are already Codable, which can be types like String, Int, Double, Data, Date and URL.

Let’s consider a User structure that stores the name, the username and the phone number of a user.

We can make it automatically decodable and encodable by conforming to the Codable protocol, which is a type alias of Encodable and Decodable.

We can also use custom types that also conform to the Codable protocol, and use built-in types such as Array, Dictionary and Optional whenever they contain codable types.

Let’s add to the previous example a list of devices that the user owns. It is represented by an Array of Device. The Device stores the name and the manufacturer of a device.

We can now deserialize a JSON document into our User instance, and serialize that instance back into a JSON document.

Encode or Decode Exclusively

In some cases, you may not need to decode and encode the same type. For example, you may only need to read data and decode them into an instance, or you just need to make API calls and there is no need to decode the response containing the same type.

You can achieve that by conforming Encodable and Decodable protocols. The example below shows how the User structure only encode data:

Custom Key Names

It is often the case that we parse JSON documents with properties that doesn’t match our property names. In that case, we need to define custom key names in order to parse these properties into our instances.

In order to define the custom list of key names we need to define an enumeration named CodingKeys which conforms to the CodingKeys protocol. The names of the enumeration cases should match the names you’ve given to the corresponding properties in your type.

Let’s update the property phoneNumber of our User structure, which is defined in the JSON document using snake-case style. The enumeration CodingKeys provide the phoneNumber alternative key specified by a String as the raw-value type for the CodingKeys enumeration.

If you find this post helpful, please recommend it for others to read.

Swift Enumerations (Part 3)

Jaume Viñas Navas — Mon, 30 Sep 2019 07:01:52 +0000

Swift enumerations are a first-class types in their own right, that means they can adopt many features traditionally supported only by classes. In this chapter we will cover how enumeration can define custom initializers to provide an initial case value, and how they can be extended and conform to protocols.

Remember to read the first chapters (Part 1 and Part 2) if you missed them or you want to refresh the basic concepts of Swift enums.

Protocols

A protocol defines an interface of methods, properties and other requirements that can be adopted by a class, structure or enumeration. Any type that satisfies the requirement of a protocol must provide an implementation of those requirements.

For demonstration purposes we use the LayerActions enumeration declared in the previous chapter, which defines a set of actions that users can execute in order to modify a layer in a design tool. To execute and describe each action we declare the protocol Taskable, which defines a method to execute a task and a description property that defines the task to be executed.

As you can see, the enumeration now conforms to the protocol requirements in the enumeration by implementing the method execute() and the computed property description.

Extensions

An extension adds new functionality to an existing class, structure, enumeration or protocol type. You can use an extension to add computed properties, define methods, define initializers, or make the existing type conform to a protocol among others.

In our case, we will extend the LayerActions enumeration to conform the protocol Taskable and make it easier to read, understand and maintain the code.

We can add as many extensions as we want, for instance, we can extend the previous enumeration in order to implement a different protocol. Here’s an example that extends the enumeration twice to separate the implementation of protocols Taskable and Serializable.

Initializers

Enumerations with a raw-value type automatically receive an initializer that takes as a parameter a value of the raw value’s type. Here’s an example of an enumeration with a raw-value type that uses the initializer to create a new instance.

Initilizers return either an enumeration case or nil. As you can see in the following example, the variable q is of type Polygon? and the value returned by the raw initializer is nil.

You can also create custom initializers even if the enumeration is not a raw-value typed enumeration.

If you find this post helpful, please recommend it for others to read.

Swift Enumerations (Part 2)

Jaume Viñas Navas — Fri, 27 Sep 2019 09:26:44 +0000

In this new chapter we will cover more advanced features about Swift enumerations, remember to read the first chapter if you missed it or you want to refresh the basic concepts of Swift enums.

Associated Values

Enumeration cases have their own value and type, and sometimes it is useful to store additional data of other types alongside an enum case. Associated values are a fantastic way to achieve that by attaching custom information along with the case value, allowing this information to be different each time you use that enum case in your code.

Here’s an example of an enumeration that defines a set of actions that users can execute in order to modify a layer. A layer can be resized, rotated and filled with a color. The enum case resize has two associated values that define the new width and height values of the layer, the enum case rotate has one associated value which indicates the rotation degrees, and the enum case fill has one associated value that indicates the color of the layer.

The associated values can be accessed using a switch statement, and they can be extracted as constants (with the let prefix) or as variables (with the var prefix).

Methods

Enumerations in Swift are first-class types in their own right. They adopt many features traditionally supported only by classes, for example, instance methods to provide functionality related to the values the enumeration represents.

Methods on enumerations exist for every enum case. If you want to provide specific code for every enum case, you need a switch statement to determine each case.

Mutating Methods

By default, the properties of an enumeration cannot be modified from within its instance methods. However, if you need to modify your enumeration you can use mutating methods. Mutating methods for enumerations can set the implicit self parameter to be a different case from the same enumeration.

Here’s an example that defines an enumeration for a temperature alarm with two states, enabled and disabled. The enumeration changes its state when the temperature reaches an specific threshold.

Properties

Event though enumerations can’t have stored properties, they can have computed properties to provide additional information about the enumeration’s current value.

The example below modifies the Polygon enumeration in order to add a new property edges . This new property returns the number of edges of the enum case. The method description() has also been updated in order to use the new property.

If you find this post helpful, please recommend it for others to read. In the next chapter we will cover more advanced enumeration usages such as protocols, extensions, generics and custom initializers.

Swift Enumerations (Part 1)

Jaume Viñas Navas — Thu, 26 Sep 2019 09:57:28 +0000

An enumeration defines a custom data type for a set of related values. Swift enumerations are much more flexible and powerful than we got used to in other languages. Enumerations in Swift are first-class type in their own right, they support computed properties, instance methods, custom initializers, extensions and can conform to protocols.

Syntax

Swift enumerations are introduced with the enum keyword and writing their entire definition within a pair of braces. Here's an example that defines some different types of polygons:

Multiple cases can be arranged on a single line separated by comas:

You can match enumerations with various pattern matching constructs to retrieve the value of the enum, or act upon a specific case. Here's an example that prints the number of sides of the polygon for an specific case:

A switch declaration must be exhaustive when considering an enumeration's cases. If one of the cases of the enum is omitted in the switch declaration the code will not compile. If you don't need to provide a case for every enumeration case, you can provide a default case:

When a variable is initialized with one of the possible values of an enumeration, the type is automatically inferred. In the following example, the variable figure contains the enum value triangle and so it automatically infers its type, Polygon. We can then set it to a different Polygon value using dot syntax:

Raw Values

Enumerations can have a value assigned to each case. Swift supports Integer, Floating Point, String and Boolean types for the value of an enum. You can access to the value assigned to each enumeration case with the rawValue property.

Nested enums

Enums can be nested in order to specify sub types. To nest a type within another type you must declare its entire definition within the outer pair of braces.

Following the previous example, we can consider two new specific sub types for the triangle enum case. Triangles can be classified by various properties relating to their angles and sides. Here's an example that classifies triangles by their sides:

Nested types can be used outside its definitions context using the dot syntax. You must prefix its name with the name of the type it is nested within:

If you find this post helpful, please recommend it for others to read. In the next chapter we will cover more advanced features such as associated values, methods and properties.