Typecasting in Swift: Tips&Tricks

Apple Docs

When you type cast you don’t change the type of the object you are dealing with. However, what you are doing is changing how you treat the object, and treat it as a different type.

Difficulty: Beginner | Easy | Normal | Challenging

Prerequisites — Any Swifty iDev can read this, who is either beginner or expert. A beginner will gain knowledge and expert will sharpen his or her knowledge by reading this series from start to finish.

What we’ll know from that article:

• TypeCasting Definition
• Types of typecasting
• To define a class hierarchy
• How to do type checking
• as? (Conditional Casting)
• as! (Forced Casting)
• is (Type Check)
• Tips and Tricks for using type casting

Let’s understand type-casting in the simplest way

Type casting in Swift is a way to check the type of an instance, and optionally downcast it to a different class or protocol type.

Upcasting and downcasting are the two types of typecasting offered by Swift. Upcasting, which is always safe, is the conversion of a subclass instance to its superclass. On the other hand, downcasting, which involves transforming an instance of a superclass to its subclass, is not necessarily secure. As a result, downcasting in Swift requires explicit typecasting syntax.

💡 we use types to represent different kinds of data such as Int, Double, String, UIButton and many more!

Swift offers the is and as operators for type checking and type casting in addition to upcasting and downcasting. The as operator tries to downcast an instance to a subclass type and returns an optional value, whereas the is operator returns true if an instance belongs to a specific subclass type

Types:

Swift type casting provides two operators:

• ‘is’: This operator is used to check the type of a value.
• ‘as’: This operator is used to cast the type value to a different type.

To Define a Class Hierarchy

Type casting is also used to check whether the instance type follows particular protocol conformance standard or not. It also checks hierarchy of classes, its subclasses and its instances to make it as a same hierarchy.

Example:

class Subjects {  
   var physics: String  
   init(physics: String) {  
      self.physics = physics  
   }  
}  
class Chemistry: Subjects {  
   var equations: String  
   init(physics: String, equations: String) {  
      self.equations = equations  
      super.init(physics: physics)  
   }  
}  
class Maths: Subjects {  
   var formulae: String  
   init(physics: String, formulae: String) {  
      self.formulae = formulae  
      super.init(physics: physics)  
   }  
}  
let sa = [ Chemistry(physics: "Mechanics", equations: "Hertz"),  
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")]  
let samplechem = Chemistry(physics: "Mechanics", equations: "Hertz")  
print("Instance physics is: \(samplechem.physics)")  
print("Instance equation is: \(samplechem.equations)")  
let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")  
print("Instance physics is: \(samplemaths.physics)")  
print("Instance formulae is: \(samplemaths.formulae)") 

Output:

Instance physics is: Mechanics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz

How to do Type Checking

The “is” operator is used to do type checking. It checks whether the instance belongs to particular subclass type and returns ‘true’ if it belongs otherwise returns ‘false’.

as? (Conditional Casting):

Use this when you are not sure if the downcast will succeed. It returns an optional value of the desired type, which will be nil if the downcast is not possible.

class Vehicle {
    func drive() {
        print("Driving a vehicle")
    }
}

class Car: Vehicle {
    func accelerate() {
        print("Accelerating the car")
    }
}

let vehicle: Vehicle = Car()

if let car = vehicle as? Car {
    car.accelerate()
} else {
    print("The vehicle is not a car")
}

as! (Forced Casting):

Use this when you are confident that the downcast will succeed. If the downcast is not possible, it will result in a runtime error.

let vehicle: Vehicle = Car()

let car = vehicle as! Car
car.accelerate() // If the downcast is unsuccessful, this will cause a runtime error.

is (Type Check):

Use this to check the type of an instance without performing a downcast. It returns a Boolean value.

let vehicle: Vehicle = Car()

if vehicle is Car {
    print("The vehicle is a car")
} else {
    print("The vehicle is not a car")
}

Here are some tips and tricks for using type casting in Swift:

1. When using as, the object being cast must be of the same type as the object it is being cast to. For example, you can’t cast a String to an Int.

2. When using as?, the object being cast can be of any type. The downcast will only succeed if the object is of the same type as the object it is being cast to.

3. You can use type casting to check the type of an object. For example, you can use the is operator to check if an object is of a certain type.

4. You can use type casting to convert an object to a different type. For example, you can use the as operator to convert a String to an Int.

5. You can use type casting to downcast an object to a subclass or subtype. For example, you can use the as? operator to downcast an object to a more specific type.

6. When downcasting, you should always use the as? operator, rather than the as operator. This is because downcasting can fail, and when it fails, the as operator will crash your program.

7. When downcasting, you should always check the downcast for success before using the downcasted object. This is because downcasting can fail, and if you try to use the downcasted object when it has failed, your program will crash.

8. You can use type casting to upcast an object to a superclass or supertype. For example, you can use the as operator to upcast an object to a more general type.

9. Upcasting always succeeds, so you don’t need to check the upcast for success.

10. Type casting is a powerful tool, but you should use it with care. Misuse of type casting can lead to unexpected results, or even crashes.

It’s important to use type casting carefully, especially when using forced casting (as!), as it can cause a runtime error if the downcast is not possible. Always prefer conditional casting (as?) when you're not certain about the type compatibility.

If you enjoyed reading this article, please share and give claps so others can find it👏🏻👏🏻👏🏻👏🏻👏🏻

You can also connect with me on📲

LinkedIn

You can have a look at my code from down below👇🏻

GitHub

Find it a good read?

If you have any comments, questions, or recommendations, feel free to post them in the comment section below💬

💁🏻‍♀️Happy coding!

Thanks😊

Follow Swiftfy for more updates!