Type Casting

Welcome back to Beginner Swift!

Master Swift in One Minute 🏃

Type Casting

Working with Different Types Safely

Today, we'll explore type casting in Swift and learn how to work with different types safely.

Understanding Type Casting

Type casting in Swift is used to check the type of an instance or to treat that instance as a different superclass or subclass from somewhere else in its class hierarchy.

Using as? and as!

Swift provides two ways to perform type casting:

• Optional Casting (as?): This returns an optional value and is used when the type cast might fail.

• Forced Casting (as!): This forces the cast and crashes if the cast fails. Use it only when you're sure the cast will succeed.

Optional Casting

Here's an example of using optional casting:

import UIKit

// Define a base class

class Animal {
  var name: String
  
  init(name: String) {
    self.name = name
  }
}

// Define a subclass

class Dog: Animal {
  func bark() {
    print("Woof!")
  }
}

// Create an array of animals

let animals: [Animal] = [Dog(name: "Rex"), Animal(name: "Generic Animal")]

// Loop through the animals and try to cast each one to a Dog

for animal in animals {
  if let dog = animal as? Dog {
    print("\(dog.name) is a dog.")
    dog.bark()
  } else {
    print("\(animal.name) is not a dog.")
  }
}

// Output:
// Rex is a dog.
// Woof!
// Generic Animal is not a dog.

In this example, we use optional casting (as?) to safely check if each Animal instance in the array is actually a Dog.

Forced Casting

Here's an example of using forced casting:

import UIKit

// Define a base class

class Animal {
  var name: String
  
  init(name: String) {
    self.name = name
  }
}

// Define a subclass

class Dog: Animal {
  func bark() {
    print("Woof!")
  }
}

// Create an instance of Dog

let myDog: Animal = Dog(name: "Buddy")

// Forced cast to Dog

let dog = myDog as! Dog
dog.bark() // Output: Woof!

// Attempting to force cast to a wrong type will crash the program

// let wrongCast = myDog as! Cat // Error: Crash at runtime if Cat is not a valid cast

In this example, we use forced casting (as!) to cast an Animal instance to a Dog.

In general, we want to safely unwrap optional values in Swift, not forcefully unwrap them.

There are very few occasions where we forcefully unwrap values.

Use forced casting only when you're sure about the type!

Type Checking with is

The is operator checks whether an instance is of a certain subclass type.

Here's an example:

import UIKit

// Define a base class

class Animal {
  var name: String
  
  init(name: String) {
    self.name = name
  }
}

// Define a subclass

class Dog: Animal {
  func bark() {
    print("Woof!")
  }
}

// Create an instance of Dog

let myDog: Animal = Dog(name: "Buddy")

// Use the is operator to check the type

if myDog is Dog {
  print("\(myDog.name) is a dog.")
} else {
  print("\(myDog.name) is not a dog.")
}

// Output: Buddy is a dog.

💡 Tip: Use optional casting (as?) to safely cast types and avoid runtime crashes. Use forced casting (as!) only when you're sure the cast will succeed.

🏌️ Pro Tip: Use the is operator to check type compatibility before attempting a cast, making your code safer and more predictable.

👀 Peek: Tomorrow, we'll explore optionals in Swift and learn advanced techniques for handling optional values.

That's all for now 👋!

David