Identity operators (=== and !==) in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using identity operator?

Consider the following Swift code. What will be printed to the console?

Swift

class Person {}

let personA = Person()
let personB = personA
let personC = Person()

if personA === personB {
    print("Same instance")
} else {
    print("Different instances")
}

if personA === personC {
    print("Same instance")
} else {
    print("Different instances")
}

A Same instance\nDifferent instances

B Different instances\nDifferent instances

C Same instance\nSame instance

D Different instances\nSame instance

💡 Hint

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

personB is assigned from personA, so both point to the same object. personC is a new instance, so it is different.

❓ Predict Output

intermediate

What does this code print when using !== operator?

Look at this Swift code. What will be the output?

Swift

class Box {}

let box1 = Box()
let box2 = Box()

if box1 !== box2 {
    print("Boxes are not the same instance")
} else {
    print("Boxes are the same instance")
}

A Boxes are the same instance

B Boxes are not the same instance

C Compilation error

D Runtime error

💡 Hint

!== means the two references do not point to the same object.

box1 and box2 are two different instances, so !== returns true and prints the first message.

🧠 Conceptual

advanced

Which statement about === and !== in Swift is true?

Choose the correct statement about the identity operators === and !== in Swift.

A They check if two variables refer to the exact same instance in memory.

B They compare the values of two variables for equality.

C They can be used to compare structs and enums for identity.

D They are used to compare two variables for type equality.

💡 Hint

Think about what identity means in terms of objects and memory.

=== and !== check if two references point to the same object instance, not just equal values.

❓ Predict Output

advanced

What is the output of this Swift code with optional references and identity check?

Analyze this Swift code and determine what it prints.

Swift

class Animal {}

let animal1: Animal? = Animal()
let animal2: Animal? = animal1
let animal3: Animal? = nil

if animal1 === animal2 {
    print("animal1 and animal2 are identical")
} else {
    print("animal1 and animal2 are not identical")
}

if animal1 !== animal3 {
    print("animal1 and animal3 are not identical")
} else {
    print("animal1 and animal3 are identical")
}

A animal1 and animal2 are identical\nanimal1 and animal3 are identical

B animal1 and animal2 are not identical\nanimal1 and animal3 are identical

C animal1 and animal2 are identical\nanimal1 and animal3 are not identical

D animal1 and animal2 are not identical\nanimal1 and animal3 are not identical

💡 Hint

Optional references can be compared with identity operators; nil is a special case.

animal1 and animal2 point to the same instance, so === is true. animal3 is nil, so !== with animal1 is true.

🧠 Conceptual

expert

Why can't identity operators === and !== be used with Swift value types like structs?

Select the best explanation for why === and !== cannot be applied to structs or enums in Swift.

A Because identity operators are only for comparing primitive types like Int and String.

B Because structs and enums are stored in the heap, making identity checks meaningless.

C Because Swift does not allow any comparison operators on structs or enums.

D Because structs and enums do not have identity; they are copied when assigned, so no single instance exists.

💡 Hint

Think about how value types behave differently from reference types.

Value types like structs and enums are copied on assignment, so each variable has its own copy without shared identity.