Identity operators (=== and !==) in Swift - Step-by-Step Execution

Concept Flow - Identity operators (=== and !==)

Create two objects

↓

Compare references with ===

↓

Same object

↓

Compare references with !==

↓

Different object

This flow shows how Swift checks if two variables point to the exact same object using === or !== operators.

Execution Sample

Swift

class Person {}
let a = Person()
let b = a
let c = Person()
print(a === b)
print(a !== c)

This code creates two Person objects and compares their references using identity operators.

Execution Table

Step	Action	Evaluation	Result
1	Create object a	a is a new Person instance	a points to Person#1
2	Assign b = a	b points to same instance as a	b points to Person#1
3	Create object c	c is a new Person instance	c points to Person#2
4	Evaluate a === b	Are a and b the same object?	true
5	Evaluate a !== c	Are a and c different objects?	true

💡 All comparisons done, program ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
a	nil	Person#1	Person#1	Person#1	Person#1
b	nil	nil	Person#1	Person#1	Person#1
c	nil	nil	nil	Person#2	Person#2

Key Moments - 2 Insights

Why does 'a === b' return true even though they are two variables?

Because both 'a' and 'b' point to the exact same object instance (Person#1), as shown in execution_table step 4.

Why does 'a !== c' return true even though both are Person objects?

Because 'a' and 'c' point to different instances (Person#1 vs Person#2), so their references are not identical (execution_table step 5).

Visual Quiz - 3 Questions

Look at the variable_tracker after Step 2. What object does variable 'b' point to?

A Person#1

B Person#2

C nil

D a new object

💡 Hint

Check the 'b' row in variable_tracker at 'After Step 2' column.

At which step does the program create a new Person object different from 'a'?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at execution_table step 3 where 'c' is created.

If we changed 'let b = a' to 'let b = Person()', what would 'a === b' evaluate to?

A true

B false

C nil

D error

💡 Hint

If 'b' points to a new object, 'a === b' is false because they are different instances.

Concept Snapshot

Identity operators in Swift:
- '===' checks if two variables point to the same object instance.
- '!==' checks if two variables point to different object instances.
- Used only with class instances (reference types).
- Returns a Bool: true or false.
- Does NOT compare object content, only identity.

Full Transcript

This visual execution trace shows how Swift's identity operators '===' and '!==' work. We create two Person objects and assign variables to them. Variable 'a' points to Person#1. Variable 'b' is assigned to 'a', so it points to the same object. Variable 'c' is a new Person instance, Person#2. When we check 'a === b', it returns true because both point to the same object. When we check 'a !== c', it returns true because they point to different objects. The variable tracker shows how each variable points to objects after each step. This helps beginners understand that identity operators compare references, not content.

Practice

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

easy

A. If two variables are of the same type

B. If two variables have the same value

C. If two variables refer to the exact same class instance

D. If two variables are both nil

Solution

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

   The === operator checks if two references point to the same object in memory.

2. Step 2: Differentiate from value equality

   Unlike ==, which checks value equality, === checks identity (same instance).

3. Final Answer:

   If two variables refer to the exact same class instance -> Option C

4. Quick Check:

   === checks identity [OK]

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

Common Mistakes:

• Confusing === with == for value equality
• Using === with structs or value types
• Thinking === checks type equality

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

easy

A. if a != b

B. if a !==== b

C. if a !=== b

D. if a !== b

Solution

1. Step 1: Identify the correct identity operator for inequality

   The operator to check if two references are NOT the same object is !==.

2. Step 2: Verify syntax correctness

   Options C and D have invalid operators. if a != b uses != which checks value inequality, not identity.

3. Final Answer:

   if a !== b -> Option D

4. Quick Check:

   Use !== for identity inequality [OK]

Hint: Use !== to check different objects, not != [OK]

Common Mistakes:

• Using != instead of !== for identity check
• Typing invalid operators like !=== or !====
• Confusing identity operators with value operators

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. true\nfalse

B. false\ntrue

C. true\ntrue

D. false\nfalse

Solution

1. Step 1: Analyze the references

   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 A

4. Quick Check:

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

Hint: === true if same object, false if different [OK]

Common Mistakes:

• Assuming p1 and p3 are same because same class
• Confusing value equality with identity
• Forgetting p2 points to p1's instance

4. The following Swift code produces an error. What is the problem?

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

let p1 = Point(x: 1, y: 2)
let p2 = Point(x: 1, y: 2)

if p1 === p2 {
  print("Same point")
}

medium

A. p1 and p2 are not initialized

B. Cannot use === with structs because they are value types

C. Missing parentheses in if condition

D. === operator requires optional types

Solution

1. Step 1: Identify the types used

   Point is a struct, which is a value type in Swift.

2. Step 2: Understand identity operator restrictions

   Identity operators === and !== only work with class instances (reference types), not value types like structs.

3. Final Answer:

   Cannot use === with structs because they are value types -> Option B

4. Quick Check:

   === only for class instances [OK]

Hint: Use === only with classes, not structs or enums [OK]

Common Mistakes:

• Trying to use === with value types
• Assuming structs have identity
• Ignoring compiler error message

5. You have a class Car and an array of Car instances. You want to find if a specific Car instance myCar is already in the array by identity (same object), not by value. Which Swift code correctly checks this?

hard

A. if cars.contains(where: { $0 === myCar }) { print("Found") }

B. if cars.contains(myCar) { print("Found") }

C. if cars.firstIndex(of: myCar) != nil { print("Found") }

D. if cars.filter({ $0 == myCar }).count > 0 { 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 cars.contains(where: { $0 === myCar }) { print("Found") } uses === correctly. Options B and C use == or of: which check value equality or require Equatable conformance. if cars.filter({ $0 == myCar }).count > 0 { print("Found") } uses == which is value equality.

3. Final Answer:

   if cars.contains(where: { $0 === myCar }) { print("Found") } -> Option A

4. Quick Check:

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

Hint: Use contains(where:) with === to check object identity [OK]

Common Mistakes:

• Using contains(myCar) which checks value equality
• Assuming == checks identity
• Not using closure for identity check