如何在函数中指定参数可以在Swift中为nil

Question

I know we need to define the parameter of function in Swift to be neither implicit unwrapped optional or optional, to make it non-nil. However I am not sure what is more conventional between implicit unwrapped optional or optional.

I am watching WWDC 2014 Swift interoperability in depth and a bit confused with two examples shown in the slides. Basically it is about whether we should use implicit optional or unwrap parameters when defining function.

---

Example from Video

Below is the screenshot from that WWDC 2014 Swift interoperability in depth (At 09:01) And the quote from the speaker is

You see again this is an implicit unwrapped optional, so that you can pass a nil block in here.

Notice here both url and completionHandler are implicit unwrapped optionals, and we can pass in nil into it. All good!

---

Example from Header file

However when I check UIKit UITableViewCell, I find most of the methods are defined with optional parameters, such as

    init(style: UITableViewCellStyle, reuseIdentifier: String?)

And basically it is suggesting those parameters can be nil too.

Seems like both ? and ! try to suggest the same thing (it can be nil ).

I understand that ? means we will wrap whatever value to optional value (even for nil), and ! means we will unwrap it if what is passed in is an optional value. But I am not sure whether we should use ! or ? . And which is conventional?

---

Update

Looks like the video from WWDC 2014 is not quite correct or out-dated . Screenshot from the video shows UIDocument header file, which was different from the current UIKit header. It looks like at that time, all of them were defined as ! . But now it is either ? or plain type.

WWDC 2014 Swift interoperability in depth (At 16:25)

Current header file

Answer 1

• ? is a shortcut for Optional<T> type
• ! is a shortcut for ImplicitlyUnwrappedOptional<T> type

Both types implement NilLiteralConvertible. This mean they have init(nilLiteral: ()) and can be initialized by Void . This could be syntatically-sugard in code by compiler into regular assignement of nil to a NilLiteralConvertible variable. Here are some code lines that from compiler standpoint mean the same:

 let sweetOptionalInt: Int? = nil
 let semiSweetOptionalInt: Optional<Int> = nil
 let unsweetenedOptionalInt: Optional<Int> = Optional<Int>(nilLiteral: Void)

The same is true for ImplicitlyUnwrappedOptional .

So both could be initialized by nil , but behaviors of these types are different:

• ImplicitlyUnwrappedOptional do unwrapping for you with an assumption when you do a call object is already provided (but could be nil before), so if it is not then application will crash with a runtime error.
• Optional will require you to provide information how to unwrap variables.

As for interoperability while ago Objective-C didn't have a way to express nullability of variables. This is why most of APIs was converted with ! that stands for "proceed further if you dare" Recently Apple introduced nullability annotations for Objective-C. Apple augumented their APIs with these annotations, so now it is easier and safer to use methods with an extra nullability guidance in Swift.

Answer 2

You aren't quite right. "!" is the "force unwrap" operator. It says "This is an optional, but I guarantee that when this code runs, it won't be nil." If you are wrong, you crash.

if you are writing a function that takes a parameter that can be legitimately nil, use "?", which makes it an Optional. Then in the code of your function, you have to handle the case where it is nil.