Type casting with as, as?, as! in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using 'as?'?

Consider the following Swift code snippet. What will be printed?

Swift

class Animal {}
class Dog: Animal {}

let animal: Animal = Dog()
if let dog = animal as? Dog {
    print("Dog cast succeeded")
} else {
    print("Dog cast failed")
}

A Dog cast succeeded

B Dog cast failed

C Compile-time error

D Runtime crash

💡 Hint

Remember that 'as?' tries to cast safely and returns nil if it fails.

The variable animal actually holds a Dog instance. Using as? safely casts it to Dog, so the cast succeeds and prints "Dog cast succeeded".

❓ Predict Output

intermediate

What happens when using 'as!' to cast an incompatible type?

What is the result of running this Swift code?

Swift

class Animal {}
class Cat: Animal {}
class Dog: Animal {}

let animal: Animal = Cat()
let dog = animal as! Dog
print("Cast succeeded")

A Runtime crash with a fatal error

B Prints "Cast succeeded"

C Compile-time error

D Prints nothing

💡 Hint

Think about what happens when you force cast to a wrong type.

The variable animal holds a Cat instance. Forcing a cast to Dog with as! causes a runtime crash because the types are incompatible.

🧠 Conceptual

advanced

Which statement about 'as' casting is true?

Choose the correct statement about the as keyword in Swift.

A <code>as</code> can only be used to cast between unrelated types.

B <code>as</code> always performs a runtime check and returns an optional.

C <code>as</code> is used for upcasting and bridging between types without runtime checks.

D <code>as</code> is used to force cast and crashes if the cast fails.

💡 Hint

Think about when as can be used without optional or force casting.

as is used for upcasting (casting to a superclass or protocol) or bridging (e.g., between Swift and Objective-C types) and does not perform runtime checks. It never returns an optional or crashes.

❓ Predict Output

advanced

What is the output of this code using 'as?' with an array?

What will this Swift code print?

Swift

let mixedArray: [Any] = ["Hello", 42, 3.14]
if let stringArray = mixedArray as? [String] {
    print("String array: \(stringArray)")
} else {
    print("Cast to [String] failed")
}

A String array: ["Hello", "42", "3.14"]

B Cast to [String] failed

C Compile-time error

D String array: ["Hello"]

💡 Hint

Remember that as? requires all elements to be of the target type.

The array contains different types: String, Int, and Double. Casting the whole array to [String] fails because not all elements are strings, so the else branch runs.

🔧 Debug

expert

Why does this forced cast crash at runtime?

Examine the code below. Why does it crash at runtime?

Swift

class Vehicle {}
class Car: Vehicle {}
class Bike: Vehicle {}

let vehicle: Vehicle = Vehicle()
let car = vehicle as! Car
print("Car cast succeeded")

A Because <code>Car</code> is not a subclass of <code>Vehicle</code>.

B Because <code>as!</code> cannot be used with classes.

C Because <code>vehicle</code> is nil and cannot be cast.

D Because <code>vehicle</code> is not an instance of <code>Car</code>, so forced cast fails.

💡 Hint

Check the actual type of the instance stored in vehicle.

The variable vehicle holds an instance of Vehicle itself, not a subclass Car. Forced casting to Car fails at runtime causing a crash.

Practice

1. Which of the following statements correctly describes the use of as? in Swift?

easy

A. as? is used only for upcasting and always succeeds.

B. as? attempts a cast and returns an optional value.

C. as? forcefully casts and crashes if it fails.

D. as? converts any type to a string.

Solution

1. Step 1: Understand as? behavior

   as? tries to cast a value to a different type and returns an optional, which is nil if the cast fails.

2. Step 2: Compare with other casting operators

   as! force casts and crashes if it fails, while as is for guaranteed casts like upcasting.

3. Final Answer:

   as? attempts a cast and returns an optional value. -> Option B

4. Quick Check:

   as? = optional cast [OK]

Hint: Remember: as? returns optional, safe cast [OK]

Common Mistakes:

• Confusing as? with force cast as!
• Thinking as? always succeeds
• Using as? for guaranteed casts

2. Which of the following is the correct syntax to force cast a variable value to type String?

easy

A. let str = value as! String

B. let str = value as String!

C. let str = value as String?

D. let str = value as? String

Solution

1. Step 1: Identify force cast syntax

   Force casting uses as! to convert a value to a type, crashing if it fails.

2. Step 2: Check each option

   let str = value as! String uses as! correctly. let str = value as? String is safe cast, B and C are invalid syntax.

3. Final Answer:

   let str = value as! String -> Option A

4. Quick Check:

   Force cast = as! [OK]

Hint: Force cast uses as! with exclamation mark [OK]

Common Mistakes:

• Using as? when force cast is needed
• Writing invalid syntax like as String!
• Confusing optional cast with force cast

3. What will be the output of the following Swift code?

class Animal {}
class Dog: Animal {}

let animal: Animal = Dog()

if let dog = animal as? Dog {
    print("It's a dog")
} else {
    print("Not a dog")
}

medium

A. It's a dog

B. Not a dog

C. Compile-time error

D. Runtime crash

Solution

1. Step 1: Understand the class hierarchy and casting

   Dog is a subclass of Animal. The variable animal holds a Dog instance but typed as Animal.

2. Step 2: Use safe cast as? to check type

   The if let safely casts animal to Dog. Since animal is actually a Dog, cast succeeds.

3. Final Answer:

   It's a dog -> Option A

4. Quick Check:

   Safe cast success prints "It's a dog" [OK]

Hint: Safe cast with as? returns non-nil if type matches [OK]

Common Mistakes:

• Assuming cast fails because variable type is superclass
• Confusing as with as?
• Expecting runtime crash without force cast

4. Consider this Swift code snippet:

let value: Any = "Hello"
let number = value as! Int
print(number)

What is the issue with this code?

medium

A. It will print "Hello" as an Int.

B. It will safely return nil.

C. It will compile but print 0.

D. It will cause a runtime crash due to invalid force cast.

Solution

1. Step 1: Analyze the force cast operation

   The variable value holds a String "Hello" but is force cast to Int using as!.

2. Step 2: Understand force cast failure

   Since "Hello" cannot be cast to Int, the force cast crashes at runtime.

3. Final Answer:

   It will cause a runtime crash due to invalid force cast. -> Option D

4. Quick Check:

   Force cast invalid type = crash [OK]

Hint: Force cast wrong type crashes at runtime [OK]

Common Mistakes:

• Expecting print output instead of crash
• Thinking force cast returns nil on failure
• Confusing as! with safe cast as?

5. You have an array of Any containing mixed types: ["Swift", 42, 3.14, "Code"]. You want to create a new array containing only the strings by safely casting each element. Which code snippet correctly does this using as??

hard

A. let strings = mixedArray.filter { $0 as? String != nil }

B. let strings = mixedArray.map { $0 as! String }

C. let strings = mixedArray.compactMap { $0 as? String }

D. let strings = mixedArray.map { $0 as? String }

Solution

1. Step 1: Understand the goal and methods

   We want only strings from a mixed array, safely casting each element.

2. Step 2: Analyze each option

   let strings = mixedArray.compactMap { $0 as? String } uses compactMap with safe cast as?, which filters out nils and unwraps strings correctly. let strings = mixedArray.map { $0 as! String } force casts and may crash. let strings = mixedArray.filter { $0 as? String != nil } filters but keeps original types, not strings. let strings = mixedArray.map { $0 as? String } maps to optionals, resulting in array of optionals, not strings.

3. Final Answer:

   let strings = mixedArray.compactMap { $0 as? String } -> Option C

4. Quick Check:

   Safe cast + compactMap filters and unwraps [OK]

Hint: Use compactMap with as? to filter and unwrap safely [OK]

Common Mistakes:

• Using map with force cast causing crashes
• Using filter without unwrapping optionals
• Expecting map with as? to unwrap optionals