Try! for forced unwrap in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using try!?

Consider this Swift code that uses try! to force unwrap a throwing function. What will it print?

Swift

enum FileError: Error {
    case fileNotFound
}

func readFile(_ name: String) throws -> String {
    if name == "exists.txt" {
        return "File content"
    } else {
        throw FileError.fileNotFound
    }
}

let content = try! readFile("exists.txt")
print(content)

A nil

B Compilation error

C Runtime error: fileNotFound

D File content

💡 Hint

try! forces the function to succeed or crash if it throws.

The function readFile returns "File content" for "exists.txt" and throws an error otherwise. Using try! means the program expects no error. Since the file exists, it prints the content.

❓ Predict Output

intermediate

What happens when try! unwraps a throwing function that fails?

What is the result of running this Swift code?

Swift

enum ParseError: Error {
    case invalidFormat
}

func parseNumber(_ str: String) throws -> Int {
    guard let num = Int(str) else {
        throw ParseError.invalidFormat
    }
    return num
}

let number = try! parseNumber("abc")
print(number)

A Runtime crash with invalidFormat error

B Compilation error

C Prints nil

D Prints 0

💡 Hint

try! crashes if the function throws an error.

The string "abc" cannot be converted to an Int, so parseNumber throws invalidFormat. Using try! causes a runtime crash when an error is thrown.

🧠 Conceptual

advanced

Why is using try! risky in Swift?

Which of the following best explains the risk of using try! in Swift?

A It can cause runtime crashes if the throwing function actually throws an error.

B It always catches errors and handles them silently.

C It converts errors into optional values automatically.

D It prevents the function from throwing any errors.

💡 Hint

Think about what happens if the function throws an error when using try!.

try! forces the program to assume no error will occur. If an error does happen, the program crashes immediately. It does not catch or handle errors.

❓ Predict Output

advanced

What is the output of this Swift code with try! and do-catch?

What will this Swift code print?

Swift

enum NetworkError: Error {
    case disconnected
}

func fetchData() throws -> String {
    throw NetworkError.disconnected
}

var result = ""
do {
    result = try fetchData()
} catch {
    result = "Error caught"
}

print(try! fetchData())

A Error caught

B Runtime crash with disconnected error

C Compilation error

D Empty string

💡 Hint

The do-catch block handles the error, but try! outside does not.

The do-catch block catches the error and sets result to "Error caught" but does not print it. The print(try! fetchData()) line forces a crash because fetchData() throws and try! does not handle errors.

🔧 Debug

expert

Identify the line causing a runtime crash with try! in this Swift code

Which line causes a runtime crash when running this Swift code?

Swift

enum DataError: Error {
    case missingData
}

func loadData(_ key: String) throws -> String {
    if key == "valid" {
        return "Data loaded"
    } else {
        throw DataError.missingData
    }
}

let a = try! loadData("valid")
let b = try! loadData("invalid")
print(a)
print(b)

A print(a)

B let a = try! loadData("valid")

C let b = try! loadData("invalid")

D print(b)

💡 Hint

One call uses a key that causes an error to be thrown.

The call loadData("invalid") throws missingData. Using try! on this line causes a runtime crash. The other lines run fine.