@shieldshawk

original source : https://developer.apple.com/swift/blog/?id=23

The as! Operator

Prior to Swift 1.2, the as operator could be used to carry out two different kinds of conversion, depending on the type of expression being converted and the type it was being converted to:

Guaranteed conversion of a value of one type to another, whose success can be verified by the Swift compiler. For example, upcasting (i.e., converting from a class to one of its superclasses) or specifying the type of a literal expression, (e.g., 1 as Float).

Forced conversion of one value to another, whose safety cannot be guaranteed by the Swift compiler and which may cause a runtime trap. For example downcasting, converting from a class to one of its subclasses.

Swift 1.2 separates the notions of guaranteed conversion and forced conversion into two distinct operators. Guaranteed conversion is still performed with the asoperator, but forced conversion now uses the as! operator. The ! is meant to indicate that the conversion may fail. This way, you know at a glance which conversions may cause the program to crash.

The following example illustrates the change:

class Animal {} class Dog: Animal {} let a: Animal = Dog() a as Dog // now raises the error:  "'Animal is not convertible to 'Dog'; // ... did you mean to use 'as!' to force downcast?" a as! Dog // forced downcast is allowed let d = Dog() d as Animal // upcast succeeds

Note the analogy between the expression postfix operators ! and ? and the conversion operators as! and as?:

class Animal {} class Cat: Animal {} class Dog: Animal { var name = "Spot" } let dog: Dog? = nil dog?.name // evaluates to nil dog!.name // triggers a runtime error let animal: Animal = Cat() animal as? Dog // evaluates to nil animal as! Dog // triggers a runtime error

original source : https://stackoverflow.com/questions/25708649/downcasting-optionals-in-swift-as-type-or-as-type/25710162

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

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).

Contrast that to:

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

anyways, 

AWESOME DAY :D finally got my learners.

First drive today and drove around in a Mercedes-Benz Brabus 500 <3 dream car as of right now. :D Got honked at, but at least I made it home safely with a frap from Starbucks LOL