Swift about?? Operator something interesting

Swift’s syntax is secure and robust, but also has many very flexible features, such as?? Operators are one of them. For those of you who already know it, and for those of you who don’t know it, here’s a list of interesting discussions about this operator.

?? Operator description

Before we go any further, let’s understand what this operator does. This operator is related to Optional. Let’s look at an example:

var a:Int? print(a ?? 2) / / 2Copy the code

?? It has an Optional value on the left and a normal value on the right, and what it does is, if the Optional value on the left is nil, it returns the normal value on the right, and if the Optional value on the left is not nil, Returns the unpacked value of Optional on the left.

For example, in our example, the value of variable A is nil, so the print statement will print the default value 2.

In that example, if you don’t use…? Operator, then this is the logic:

print(a == nil ? 2 : a) 
 Copy the code

Let’s see…? Operator definition:

func ?? (optional: T? , @autoclosure defaultValue: () throws -> T) -> TCopy the code

To simplify it, this is:

func ?? (optional: T? , defaultValue: () throws -> T) -> TCopy the code

It accepts an Optional value of type T, a plain value of type T as the default, and returns an unpacked value of type T. The final return value is determined by whether the first argument is null.

?? Some discussion of operators

?? The operator makes it easier to handle Optional. But there are a few hiccups, as discussed in Swift’s official mailing group. Take this code for example:

func test(x: ((String) -> String)? = nil) {

    let qf = { (p:String) -> String in return "tt" }

    let fn = x ?? qf
    fn("tt")

}Copy the code

The test function takes another parameter of type Optional, and inside it calls?? The operator determines whether the function x passed in is nil, and if so, replaces it with another function inside, qf.

At first glance, such code should be fine,?? Is the variable type to the left of ((String) -> String)? And the variable on the right is of type (String) -> String. Operator definition.

But this paragraph is right about…? The use of the operator gave an error at actual compile time. We must declare qf as Optional to use:

let qf:((String) -> String)? = { (p:String) -> String in return "tt" }
    let fn = (x ?? qf)!
    fn("tt")Copy the code

This compiles, but does not comply with?? The operator is defined. This time both sides are Optional, and the return value of the expression is Optional.

At this time about?? In a recent discussion in the Swift email group, the last reply stated that this was a Swift bug that will be fixed in Swift 3.0.

var a:Int?
print(a ?? "test")
Copy the code

let x = a ?? "test"
Copy the code

let x = a ?? NSDate()
Copy the code