New to Swift and saw code from Standford open course of Swift programming as below:
if pending != nil {
acccumulator = pending!.binaryFunction(pending!.firstOperand,acccumulator)
pending = nil
}
As I learn about unwrapping, pending, in this case, is ensured not to be nil inside if block, then why should I use ! to unwrap pending while using it?
Because the if check has no bearing on the code inside the block. In this example, you should instead use a let, like so:
if let nonNilPending = pending {
acccumulator = nonNilPending.binaryFunction(nonNilPending.firstOperand,acccumulator)
pending = nil
}
That way you avoid the force-unwraps.
Even though you know that pending is not nil, its type remains optional. The compiler does not treat it differently in various contexts (i.e. inside and outside if) so you have to use ! operator in both places.
Swift does offer you a mechanism to check for nil and unwrap in a single go with an if let construct, which presents a convenient alternative to forced unwrapping.
Because even if you're in that if block, the compiler doesn't know that the variable is "unwrapped". On top of that, using the force unwrap is a bad idea. You would be better off unwrapping the variable in an if conditional and then using the constant you set it to. For example:
if let unwrappedPending = pending {
accumulator = unwrappedPending.binaryFunction(...)
pending = nil
}
By setting the optional pending to the constant, you're conditionally unwrapping it. Then you can use the constant with the security of knowing that the constant is not nil and you don't have to use !
