Downcasting optionals in Swift: as? Type, or as! T

Question

Given the following in Swift:

var optionalString: String?
let dict = NSDictionary()

What is the practical difference between the following two statements:

optionalString = dict.objectForKey("SomeKey") as? String

vs

optionalString = dict.objectForKey("SomeKey") as! String?

Answer 1

as? Types - means the down casting process is optional. The process can be successful or not(system will return nil if down casting fails).Any way will not crash if down casting fails.

as! Type? - Here the process of down casting should be successful (! indicates that) . The ending question mark indicates whether final result can be nil or not.

More info regarding "!" and "?"

Let us take 2 cases

1. Consider:

   let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as? UITableViewCell
   

   Here we don't know whether the result of down casting of cell with identifier "Cell" to UITableViewCell is success or not. If unsuccessful then it returns nil( so we avoid crash here). Here we can do as given below.

   if let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as? UITableViewCell {
       // If we reached here it means the down casting was successful
   }
   else {
       // unsuccessful down casting
   }
   

   So let us remember it like this - If ? it means we are not sure whether value is nil or not (question mark comes when we don't know things).

2. Contrast that to:

   let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as! UITableViewCell. 
   

   Here we tell the compiler that down casting should be successful. If it fails the system will crash. So we give ! when we are sure that value is non nil.

Answer 2

The practical difference is this:

var optionalString = dict["SomeKey"] as? String

optionalString will be a variable of type String?. If the underlying type is something other than a String this will harmlessly just assign nil to the optional.

var optionalString = dict["SomeKey"] as! String?

This says, I know this thing is a String?. This too will result in optionalString being of type String?, but it will crash if the underlying type is something else.

The first style is then used with if let to safely unwrap the optional:

if let string = dict["SomeKey"] as? String {
    // If I get here, I know that "SomeKey" is a valid key in the dictionary, I correctly
    // identified the type as String, and the value is now unwrapped and ready to use.  In
    // this case "string" has the type "String".
    print(string)
}

Answer 3

Maybe this code example will help someone grok the principle:

var dict = [Int:Any]()
dict[1] = 15

let x = dict[1] as? String
print(x) // nil because dict[1] is an Int

dict[2] = "Yo"

let z = dict[2] as! String?
print(z) // optional("Yo")
let zz = dict[1] as! String // crashes because a forced downcast fails


let m = dict[3] as! String?
print(m) // nil. the forced downcast succeeds, but dict[3] has no value

Answer 4

• as used for upcasting and type casting to bridged type
• as? used for safe casting, return nil if failed
• as! used to force casting, crash if failed

Note:

• as! can’t cast raw type to optional

Examples:

let rawString: AnyObject = "I love swift"
let optionalString: AnyObject? = "we love swift"
let nilString: AnyObject? = (nil as String?)

let rawInt: AnyObject = Int(3)
let optionalInt: AnyObject? = Int(3)
let nilInt: AnyObject? = (nil as Int?)

---

Example

var age: Int? = nil
var height: Int? = 180

By adding a ? immediately after the data type you tell the compiler that the variable might contain a number or not. Neat! Notice that it doesn’t really make sense to define Optional constants – you can set their value only once and therefore you would be able to say whether their value will be nil or not.

When we should use "?" and when "!"

let’s say we have UIKit based simple app. we have some code in our view controller and wants to present a new view controller on top of it. and we need to decide to push the new view on screen using navigation controller.

As we know every ViewController instance has a property navigation controller. If you are building a navigation controller based app this property of your app’s master view controller is set automatically and you can use it to push or pop view controllers. If you use a single app project template – there won’t be a navigation controller created automatically for you, so your app’s default view controller will not have anything stored in the navigationController property.

I’m sure you already guessed that this is exactly a case for an Optional datatype. If you check UIViewController you will see that the property is defined as:

var navigationController: UINavigationController? { get }

So let’s go back to our use case. If you know for a fact that your view controller will always have a navigation controller you can go ahead and force unwrap it:

controller.navigationController!.pushViewController(myViewController, animated: true)

When you put a ! behind the property name you tell the compiler I don’t care that this property is optional, I know that when this code executes there always will be a value store so treat this Optional like a normal datatype. Well isn’t that nice? What would happen though if there isn’t a navigation controller to your view controller? If you suggestion that there always will be a value stored in navigationController was wrong? Your app will crash. Simple and ugly as that.

So, use ! only if you are 101% sure that this is safe.

How about if you aren’t sure that there always will be a navigation controller? Then you can use ? instead of a !:

controller.navigationController?.pushViewController(myViewController, animated: true)

What the ? behind the property name tells the compiler is I don’t know whether this property contains nil or a value, so: if it has value use it, and oterwise just consider the whole expression nil. Effectively the ? allows you to use that property just in the case there is a navigation controller. No if checks of any kind or castings of any sort. This syntax is perfect when you don’t care whether you have a navigation controller or not, and want to do something only if there is.

Huge thanks to Fantageek

Answer 5

The first is a "conditional cast" (look under "type-casting operators" in the documentation I've linked). If the cast succeeds, the value of the expression is wrapped in an optional and returned, otherwise the value returned is nil.

The second means that optionalString could be a string object or it might be nil.

More information found in this related question.

Answer 6

It may be easiest to remember the pattern for these operators in Swift as: ! implies "this might trap," while ? indicates "this might be nil."

refer to: https://developer.apple.com/swift/blog/?id=23