Identity comparison (===) in Swift - Mini Project: Build & Apply

Identity comparison (===) in Swift

📖 Scenario: Imagine you have two boxes that can hold toys. Sometimes, you want to check if both boxes are actually the same box, not just two boxes with the same toys.

🎯 Goal: You will create two class instances representing boxes and use identity comparison === to check if they are the exact same box.

📋 What You'll Learn

Create a class called Box with a property toy of type String

Create two variables box1 and box2 as instances of Box

Create a third variable box3 that points to the same instance as box1

Use identity comparison === to check if box1 and box2 are the same instance

Use identity comparison === to check if box1 and box3 are the same instance

Print the results of both comparisons

💡 Why This Matters

🌍 Real World

Identity comparison helps when you want to know if two variables refer to the exact same object, like checking if two references point to the same user profile in an app.

💼 Career

Understanding identity comparison is important for Swift developers working with classes, memory management, and reference types to avoid bugs and write efficient code.

1

Create the Box class and two instances

Create a class called Box with a property toy of type String. Then create two variables called box1 and box2 as instances of Box with toys "Car" and "Car" respectively.

Swift

class Box {
    var toy: String
    init(toy: String) {
        self.toy = toy
    }
}

// Create box1 and box2 instances below

Hint

Define the class with a property and initializer. Then create two instances with the same toy name.

2

Create a third variable pointing to the first instance

Create a variable called box3 and assign it to the same instance as box1.

Swift

class Box {
    var toy: String
    init(toy: String) {
        self.toy = toy
    }
}

let box1 = Box(toy: "Car")
let box2 = Box(toy: "Car")

// Create box3 pointing to box1 below

Hint

Assign box3 to box1 to make them point to the same box.

3

Compare box1 and box2 using identity comparison

Use identity comparison === to check if box1 and box2 are the same instance. Store the result in a variable called sameBox1and2.

Swift

class Box {
    var toy: String
    init(toy: String) {
        self.toy = toy
    }
}

let box1 = Box(toy: "Car")
let box2 = Box(toy: "Car")
let box3 = box1

// Compare box1 and box2 using === below

Hint

Use === to compare if two variables point to the same instance.

4

Compare box1 and box3 and print results

Use identity comparison === to check if box1 and box3 are the same instance. Store the result in a variable called sameBox1and3. Then print both sameBox1and2 and sameBox1and3.

Swift

class Box {
    var toy: String
    init(toy: String) {
        self.toy = toy
    }
}

let box1 = Box(toy: "Car")
let box2 = Box(toy: "Car")
let box3 = box1

let sameBox1and2 = box1 === box2

// Compare box1 and box3 using === and print results below

Hint

Compare box1 and box3 with === and print both results to see which boxes are the same.

Practice

1. What does the === operator check in Swift?

easy

A. If two variables refer to the exact same object instance

B. If two variables have the same value

C. If two variables are of the same type

D. If two variables are both nil

Solution

1. Step 1: Understand the purpose of ===

   The === operator in Swift is used to check if two references point to the exact same object in memory.

2. Step 2: Differentiate from value equality

   Unlike ==, which checks if values are equal, === checks identity, meaning the same instance.

3. Final Answer:

   If two variables refer to the exact same object instance -> Option A

4. Quick Check:

   Identity comparison = If two variables refer to the exact same object instance [OK]

Hint: Remember: === means same object, not just equal value [OK]

Common Mistakes:

• Confusing === with == for value equality
• Thinking === checks type equality
• Assuming === works with structs or enums

2. Which of the following is the correct syntax to check if two class instances a and b are identical in Swift?

easy

A. if a === b { }

B. if a == b { }

C. if a = b { }

D. if a is b { }

Solution

1. Step 1: Recall identity operator syntax

   In Swift, the identity operator to check if two references point to the same object is ===.

2. Step 2: Identify correct usage

   The correct syntax is if a === b { }. The other options are either value equality, assignment, or invalid syntax.

3. Final Answer:

   if a === b { } -> Option A

4. Quick Check:

   Identity check syntax = if a === b { } [OK]

Hint: Use three equals signs (===) for identity check [OK]

Common Mistakes:

• Using == instead of === for identity
• Using single = which is assignment
• Typing invalid operators like ===

3. Consider the following Swift code:

class Person {}

let p1 = Person()
let p2 = p1
let p3 = Person()

print(p1 === p2)
print(p1 === p3)

What will be the output?

medium

A. false\nfalse

B. false\ntrue

C. true\ntrue

D. true\nfalse

Solution

1. Step 1: Analyze object references

   Variable p2 is assigned to p1, so both point to the same object. p3 is a new instance.

2. Step 2: Evaluate identity comparisons

   p1 === p2 is true because they are the same instance. p1 === p3 is false because they are different instances.

3. Final Answer:

   true\nfalse -> Option D

4. Quick Check:

   Same instance = true, different instance = false [OK]

Hint: Same variable means true; new instance means false [OK]

Common Mistakes:

• Assuming different variables always mean false
• Confusing === with == and expecting value equality
• Ignoring that p2 points to p1's instance

4. The following Swift code gives a compile error. What is the problem?

class Car {}

let car1 = Car()
let car2 = Car()

if car1 == car2 {
    print("Same car")
}

medium

A. Cannot create instances of class Car

B. Missing parentheses in if statement

C. Cannot use == to compare class instances without Equatable conformance

D. Using === instead of ==

Solution

1. Step 1: Understand == operator requirements

   By default, class instances cannot be compared with == unless the class conforms to Equatable.

2. Step 2: Identify the error cause

   The code tries to use == without Car conforming to Equatable, causing a compile error.

3. Final Answer:

   Cannot use == to compare class instances without Equatable conformance -> Option C

4. Quick Check:

   == needs Equatable for classes [OK]

Hint: Use === for identity or add Equatable for == [OK]

Common Mistakes:

• Thinking === causes error here
• Assuming == works automatically for classes
• Ignoring Equatable protocol requirement

5. You have a cache dictionary storing class instances by keys. You want to check if a newly created instance newObj is already stored in the cache by identity. Which Swift code correctly checks this?

class Data {}

var cache: [String: Data] = [:]
let newObj = Data()

// Check if newObj is already in cache by identity

hard

A. if cache.values.contains(newObj) { print("Found") }

B. if cache.values.contains(where: { $0 === newObj }) { print("Found") }

C. if cache.keys.contains(where: { $0 === newObj }) { print("Found") }

D. if cache.values.contains(where: { $0 == newObj }) { print("Found") }

Solution

1. Step 1: Understand identity check in collections

   To check if an instance exists by identity, use === inside a closure with contains(where:).

2. Step 2: Analyze options

   if cache.values.contains(where: { $0 === newObj }) { print("Found") } correctly uses cache.values.contains(where: { $0 === newObj }). if cache.values.contains(newObj) { print("Found") } uses contains without identity check, which requires Equatable. if cache.keys.contains(where: { $0 === newObj }) { print("Found") } incorrectly checks keys (strings) with identity. if cache.values.contains(where: { $0 == newObj }) { print("Found") } uses == which needs Equatable.

3. Final Answer:

   if cache.values.contains(where: { $0 === newObj }) { print("Found") } -> Option B

4. Quick Check:

   Use contains(where:) with === for identity [OK]

Hint: Use contains(where:) and === to check identity in collections [OK]

Common Mistakes:

• Using contains without where and identity check
• Checking keys instead of values
• Using == without Equatable conformance