Identity comparison (===) in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of identity comparison with class instances?

Consider the following Swift code. What will be printed when it runs?

Swift

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

let p1 = Person(name: "Alice")
let p2 = Person(name: "Alice")
let p3 = p1

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

A false\ntrue

B true\nfalse

C false\nfalse

D true\ntrue

💡 Hint

Remember that === checks if two references point to the exact same object in memory.

The operator === checks if two variables refer to the same instance.

Here, p1 and p2 are two different instances with the same content, so p1 === p2 is false.

p3 is assigned to p1, so both refer to the same instance, making p1 === p3 true.

🧠 Conceptual

intermediate

Which statement about === in Swift is true?

Choose the correct statement about the identity operator === in Swift.

A <code>===</code> compares the values of two structs.

B <code>===</code> checks if two strings have the same characters.

C <code>===</code> can be used to compare two integers.

D <code>===</code> compares if two class instances are the same object.

💡 Hint

Think about what kinds of types === works with in Swift.

The identity operator === only works with class instances (reference types) to check if they point to the same object.

It does not work with value types like structs, integers, or strings.

🔧 Debug

advanced

Why does this code cause a compile error?

Examine the code below. Why does the line with if a === b cause a compile error?

Swift

struct Point {
    var x: Int
    var y: Int
}

let a = Point(x: 1, y: 2)
let b = Point(x: 1, y: 2)

if a === b {
    print("Same")
} else {
    print("Different")
}

A Because <code>Point</code> does not implement the Equatable protocol.

B Because <code>a</code> and <code>b</code> are constants, not variables.

C Because <code>===</code> cannot be used with structs, only with class instances.

D Because <code>===</code> requires both operands to be optional types.

💡 Hint

Recall the difference between value types and reference types in Swift.

The identity operator === only works with reference types (classes).

Structs are value types, so you cannot use === with them.

❓ Predict Output

advanced

What is the output when comparing optional class instances with ===?

What will this Swift code print?

Swift

class Box {
    let value: Int
    init(_ value: Int) { self.value = value }
}

let box1: Box? = Box(10)
let box2: Box? = Box(10)
let box3: Box? = box1
let box4: Box? = nil

print(box1 === box2)
print(box1 === box3)
print(box1 === box4)

A false\ntrue\nfalse

B true\ntrue\nfalse

C false\nfalse\ntrue

D true\nfalse\nfalse

💡 Hint

Remember that === works with optionals by unwrapping them and comparing references.

box1 and box2 are different instances, so box1 === box2 is false.

box3 points to the same instance as box1, so box1 === box3 is true.

box4 is nil, so box1 === box4 is false.

🚀 Application

expert

How many unique instances are in this array?

Given the following Swift code, how many unique class instances does the array arr contain?

Swift

class Node {}

let n1 = Node()
let n2 = Node()
let n3 = n1
let n4 = n2
let n5 = Node()

let arr = [n1, n2, n3, n4, n5]

A 5

B 3

C 4

D 2

💡 Hint

Use identity comparison to find which variables point to the same instance.

n1 and n3 refer to the same instance.

n2 and n4 refer to the same instance.

n5 is a new instance.

So, the unique instances are: n1/n3, n2/n4, and n5 — total 3.