> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Swift Type Cast The `as` operator in Swift is a type casting operator used to evaluate an expression and cast its value to a specified type, perform type coercion, or match types within patterns. It operates at both compile-time and runtime depending on its variant, facilitating upcasting, downcasting, literal disambiguation, and type bridging within class hierarchies or protocol conformances. Swift provides three distinct variants of the type casting operator, alongside specialized behavior in pattern matching contexts. ## 1. Unconditional Cast (`as`) The base `as` operator performs a compile-time cast. It is strictly used when the compiler can statically guarantee the cast will succeed, or to explicitly define the type of a literal. This applies to: * **Upcasting:** Casting a subclass instance to one of its superclasses. * **Type Coercion / Literal Disambiguation:** Forcing the compiler to infer a specific type for a literal or expression that could otherwise be inferred as multiple types. * **Protocol Abstraction:** Casting a concrete type to a protocol it explicitly conforms to. * **Type Bridging:** Converting between bridged Objective-C and Swift Foundation types. ```swift theme={"dark"} import Foundation class Animal {} class Dog: Animal {} // Upcasting let specificDog = Dog() let genericAnimal = specificDog as Animal // Type Coercion / Literal Disambiguation let floatingPointValue = 10 as Float let emptyStringArray = [] as [String] // Type Bridging let swiftString = "Bridged" let nsString = swiftString as NSString ``` *Return type:* The exact target type (Non-optional). ## 2. Conditional Downcast (`as?`) The `as?` operator performs a runtime cast. It is used for downcasting—attempting to cast a superclass reference to a subclass type, or an `Any`/`AnyObject` reference to a specific concrete type. Because downcasting can fail if the underlying instance in memory is not of the target type, this operator wraps the result in an `Optional`. ```swift theme={"dark"} class Vehicle {} class Car: Vehicle {} let unknownVehicle: Vehicle = Car() let specificCar = unknownVehicle as? Car ``` *Return type:* `Optional`. Evaluates to `nil` if the runtime type of the expression is not compatible with the target type. ## 3. Forced Downcast (`as!`) The `as!` operator performs a forced runtime cast. It is structurally identical to `as?` but implicitly force-unwraps the resulting optional. It instructs the compiler to bypass safety checks under the developer's assertion that the underlying instance is strictly of the target type. ```swift theme={"dark"} class Shape {} class Circle: Shape {} let unknownShape: Shape = Circle() let specificCircle = unknownShape as! Circle ``` *Return type:* The exact target type (Non-optional). If the runtime type of the expression is not compatible with the target type, the program will trigger a fatal runtime error (trap) and crash. ## Pattern Matching The `as` operator is also utilized within pattern matching contexts, such as `switch` statements or `catch` blocks, to check the type of an expression and bind it to a constant or variable of that type in a single operation. ```swift theme={"dark"} let unknownItem: Any = "Swift Documentation" switch unknownItem { case let text as String: print(text.uppercased()) case let number as Int: print(number + 1) default: break } ``` ## Operator Precedence and Associativity The `as`, `as?`, and `as!` operators belong to the **Casting Precedence** group (`CastingPrecedence`). * **Associativity:** None. * **Precedence:** They have strictly *higher* precedence than the nil-coalescing operator (`??`), comparison operators (`==`, `!=`), and assignment operators (`=`). They have *lower* precedence than range formation operators (`...`, `..<`) and arithmetic operators (`+`, `*`).

Tired of Poor Swift Skills? Fix That With Deep Grasping! Learn More