Weak self and unowned self patterns in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift closure using weak self?

Consider the following Swift code snippet. What will be printed when start() is called?

Swift

class MyClass {
    var value = 10
    func start() {
        DispatchQueue.global().asyncAfter(deadline: .now() + 1) { [weak self] in
            guard let self = self else {
                print("self is nil")
                return
            }
            print("Value is \(self.value)")
        }
    }
}

var obj: MyClass? = MyClass()
obj?.start()
obj = nil
sleep(2)

A Runtime crash due to unwrapped nil

B self is nil

C Compilation error due to weak self usage

D Value is 10

💡 Hint

Think about what happens to obj before the closure runs.

The closure captures self weakly. Since obj is set to nil before the closure executes, self inside the closure is nil. So the guard fails and prints "self is nil".

❓ Predict Output

intermediate

What happens if you use unowned self but self is nil?

What will happen when the following Swift code runs?

Swift

class MyClass {
    var value = 5
    func start() {
        DispatchQueue.global().asyncAfter(deadline: .now() + 1) { [unowned self] in
            print("Value is \(self.value)")
        }
    }
}

var obj: MyClass? = MyClass()
obj?.start()
obj = nil
sleep(2)

A Runtime crash due to accessing deallocated self

B Prints "Value is 0"

C Prints "Value is 5"

D Compilation error due to unowned self usage

💡 Hint

Consider what happens when self is accessed after being deallocated.

Using unowned self means the closure assumes self will be alive. But obj is set to nil before the closure runs, so self is deallocated. Accessing it causes a runtime crash.

🔧 Debug

advanced

Identify the cause of a retain cycle in this Swift code

Why does the following Swift code cause a memory leak?

Swift

class ViewController {
    var closure: (() -> Void)?
    func setup() {
        closure = {
            print("Value is \(self)")
        }
    }
}

var vc: ViewController? = ViewController()
vc?.setup()
vc = nil

A Closure is not assigned properly causing nil reference

B Closure captures self weakly causing early deallocation

C Closure captures self strongly causing retain cycle

D No retain cycle, memory is freed correctly

💡 Hint

Think about how closures capture variables by default in Swift.

The closure captures self strongly by default. Since self holds the closure and the closure holds self, neither is released, causing a retain cycle and memory leak.

📝 Syntax

advanced

Which option correctly uses weak self in a closure?

Choose the correct syntax to capture self weakly inside a closure.

Swift

class Example {
    func doWork() {
        DispatchQueue.global().async {
            // capture self weakly here
        }
    }
}

A DispatchQueue.global().async { weak self in print(self?.description) }

B DispatchQueue.global().async { [weak self:] in print(self?.description) }

C DispatchQueue.global().async { [weak self] print(self?.description) }

D DispatchQueue.global().async { [weak self] in print(self?.description) }

💡 Hint

Remember the syntax for capture lists in Swift closures.

The correct syntax uses square brackets with weak self followed by in. Option D matches this. Options A, B, and C have syntax errors.

🚀 Application

expert

How many items are in the dictionary after this Swift code runs?

Consider this Swift code. How many items remain in dict after the code runs?

Swift

class MyObject {}

var dict = [String: MyObject]()

func test() {
    let obj1 = MyObject()
    let obj2 = MyObject()
    dict["one"] = obj1
    dict["two"] = obj2
}

test()
dict.removeValue(forKey: "one")

print(dict.count)

A 1

B 2

C 0

D Compilation error due to weak references

💡 Hint

Think about how dictionary keys and values behave when you remove an entry.

After adding two items, the code removes the key "one". So only the key "two" remains. The dictionary count is 1.