Swift Compare Two Structs: Understanding Equatable Protocol

When working with Swift, comparing two structs is a common scenario when you need to check if two objects of a custom type share the same properties and values. Understanding how to compare two structs effectively involves using the Equatable protocol, implementing custom comparison logic through static functions, and managing value types versus reference types.

This blog will walk you through the details of comparing structs in Swift, with real-world examples and code snippets.

Understanding Structs and Value Types in Swift

In Swift, a struct is a value type, meaning that each instance holds its own data, independent of other instances. Unlike classes, which are reference types, value types like structs ensure that when you copy an object, the copy has its unique values. This is crucial when comparing two structs, as each instance needs to be checked for equality based on the values it contains.

Value Types vs. Reference Types

In Swift, value types like structs differ fundamentally from reference types such as classes. When you assign or pass a struct, you are working with a copy of the data, while for a class, you are working with a reference to the original object. This difference means that with structs, any change to one instance doesn’t affect another. This makes comparing two structs straightforward since you are directly comparing values without concern for shared references.

The Equatable Protocol: Simplifying Struct Comparison

To compare two structs in Swift, you can make use of the Equatable protocol. Conforming to the Equatable protocol allows you to define equality between two objects using the == operator. In most cases, the compiler can automatically generate the necessary equality logic, but there are situations where you might need to implement it manually.

Using the Equatable Protocol

To make your struct conform to the Equatable protocol, add the Equatable conformance in the type definition:

Copy
1struct Person: Equatable {
2    var name: String
3    var age: Int
4}

In the above example, the Person struct conforms to Equatable, which means you can now compare two instances of Person using ==:

Copy
1let person1 = Person(name: "Alice", age: 30)
2let person2 = Person(name: "Alice", age: 30)
3let person3 = Person(name: "Bob", age: 25)
4
5print(person1 == person2) // Output: true
6print(person1 == person3) // Output: false

Here, the Equatable protocol allows the comparison of two Person objects based on their name and age properties.

Implementing Custom Comparison with Static Functions

While the Equatable protocol handles equality checks well in many cases, you might need to implement custom logic for more complex scenarios. This can be done by writing a static func that defines how two structs should be compared.

Example: Implementing a Static Comparison Function

Suppose you have a struct that represents a Rectangle with width and height properties. If you want to compare two rectangles but allow for a margin of error in their dimensions, you can write a custom static func:

Copy
1struct Rectangle {
2    var width: Double
3    var height: Double
4
5    static func areApproximatelyEqual(_ lhs: Rectangle, _ rhs: Rectangle, tolerance: Double) -> Bool {
6        return abs(lhs.width - rhs.width) < tolerance && abs(lhs.height - rhs.height) < tolerance
7    }
8}
9
10let rect1 = Rectangle(width: 10.0, height: 20.0)
11let rect2 = Rectangle(width: 10.1, height: 20.0)
12
13print(Rectangle.areApproximatelyEqual(rect1, rect2, tolerance: 0.2)) // Output: true

In this example, the areApproximatelyEqual function takes two Rectangle structs and compares their width and height values within a specified tolerance. This method offers flexibility beyond the default equality check provided by Equatable.

Comparing Two Structs Using Manually Implemented Equality

For cases where automatic conformance isn't suitable, you can manually implement the == operator. This is useful when the struct contains properties that need more specific comparison logic, such as ignoring certain fields during the comparison.

Example: Manually Implementing == Operator

Copy
1struct Car: Equatable {
2    var make: String
3    var model: String
4    var year: Int
5
6    static func ==(lhs: Car, rhs: Car) -> Bool {
7        return lhs.make == rhs.make && lhs.model == rhs.model
8    }
9}
10
11let car1 = Car(make: "Tesla", model: "Model S", year: 2020)
12let car2 = Car(make: "Tesla", model: "Model S", year: 2021)
13let car3 = Car(make: "Tesla", model: "Model 3", year: 2020)
14
15print(car1 == car2) // Output: true
16print(car1 == car3) // Output: false

In this Car example, the year property is ignored during comparison, focusing only on the make and model strings. By writing a custom == method, you have full control over how equality between two objects is determined.

Comparing Structs: Default Behavior vs. Custom Implementation

By default, Swift automatically generates equality checks for structs with Equatable conformance if all stored properties are also equatable. However, if you need custom behavior, implementing the == method or a static func is necessary. The choice between relying on default behavior and writing custom logic depends on the complexity of your data and the comparison needs.

Using Self in Custom Equality Checks

When implementing custom comparison methods inside a struct, you often use self to access the current instance's properties. For example:

Copy
1struct Point: Equatable {
2    var x: Double
3    var y: Double
4
5    static func ==(lhs: Self, rhs: Self) -> Bool {
6        return lhs.x == rhs.x && lhs.y == rhs.y
7    }
8}

Here, Self refers to the type itself, making the code more adaptable if the type definition changes in the future. Using self implements methods like == clear and concise.

Handling Different Values: A Practical Consideration

Sometimes, you might want to highlight differences between two structs rather than just checking if they are equal. This requires comparing each property and identifying where the differences lie.

Example: Finding Different Values Between Two Structs

Copy
1struct Employee {
2    var id: Int
3    var name: String
4    var department: String
5
6    func differentValues(comparedTo other: Employee) -> [String] {
7        var differences = [String]()
8        if self.name != other.name {
9            differences.append("Name differs: \(self.name) vs \(other.name)")
10        }
11        if self.department != other.department {
12            differences.append("Department differs: \(self.department) vs \(other.department)")
13        }
14        return differences
15    }
16}
17
18let emp1 = Employee(id: 1, name: "Alice", department: "HR")
19let emp2 = Employee(id: 1, name: "Alicia", department: "Finance")
20
21print(emp1.differentValues(comparedTo: emp2))
22// Output: ["Name differs: Alice vs Alicia", "Department differs: HR vs Finance"]

This method provides more context to the differences between two objects, which can help debug or display user-friendly notifications in a UI.

The Bottom Line!

When you need to compare two structs in Swift, understanding how to use the Equatable protocol, implement custom logic through static func, and handle different values gives you the flexibility to perform accurate comparisons. Whether you're dealing with simple equality checks or more complex scenarios requiring tolerance levels or custom rules, Swift's struct comparison capabilities make it straightforward to ensure that your data behaves as expected.