Check if TWO objects are nil in Swift, ios xcode - ios

Question

I want to compare two objects(of the same Class) and return what is NOT nil.
How do you write something like this in swift? :
func returnWhatIsNotNil(objA: SomeClass, objB: SomeClass) -> SomeClass {
if objA != nil && objB != nil { //error
//both are not nil
return nil
}
if objA == nil && objB != nil { // error
// objA is nil
return objB
}
if objA != nil && objB == nil { // error
// objB is nil
return objA
}
}
with one object,
if let x = objA {
//objA is not nil
}
would do the job, but I quiet don't know how I would do this with TWO objects.

Answer 1

class SomeObject {
}
func returnWhatIsNotNil(objA: SomeObject?, objB: SomeObject?) -> SomeObject? {
if let objA = objA where objB == nil {
return objA
}
if let objB = objB where objA == nil {
return objB
}
return nil
}

Answer 2

edit: sorry, misread your original question. if you want nil when both are non-nil, then here is a one-liner that does it: return objA.map { objB == nil ? $0 : nil } ?? objB. However, #LeoDabus’s version using if…let…where looks more readable to me.
pre-edit assuming you want the first when neither are nil:
You want to use the nil-coalescing operator, ??. So to return an optional from your function, you just need return objA ?? objB. Note, all your input and output types also have to be optional.
Ordinarily you use it to give a default value in case of nil, i.e. "foo".toInt() ?? 0 which unwraps the value if non-nil, or replaces it with the default if its nil.
But if the right-hand side is also an optional, it will return an optional, with the left one if it’s non-nil, else the right one, even if that one is nil.
let i: Int? = nil
let j: Int? = nil
let k: Int? = 42
if let num = i ?? j {
fatalError("won't execute")
}
if let num = j ?? k {
assert(num == 42, "k will be chosen")
}
else {
fatalError("this would run if all 3 were nil")
}
Also bear in mind you can chain ?? too:
let x = i ?? j ?? k ?? 0 // will result in an unwrapped 42

Answer 3

As a follow up to #LeoDabus' accepted answer, you can use a switch statement also:
class SomeObject {
}
func returnWhatIsNotNil(objA: SomeObject?, objB: SomeObject?) -> SomeObject? {
switch (objA, objB) {
case (let a, nil): return a
case (nil, let b): return b
default: return nil
}
}

Answer 4

As mentioned the nil coalescing operator ?? can be used.
Here is an implementation of your function, note you didn't define what would happen when both objA and objB were non-nil
func returnWhatIsNotNil(objA: SomeClass?, objB: SomeClass?) -> SomeClass? {
return objA ?? objB
}

Answer 5

Although, a literal translation of your code in Swift is possible, which is
func returnNotNil(num1: Int?, num2: Int?) -> Int?
{
if let x = num1 {
return x
}
else if let y = num2
{
return y
}
else
{
return nil
}
}
The problem here is, in Swift, we will have to keep the return type as optional - so once returned from the function, you will again have to check for returned value being not nil, and unwrap.
IMHO, a logical translation would be, (assuming that you don't mind returning either, when none of them are nil)
func returnNotNilOrAssert(num1: Int?, num2: Int?) -> Int
{
if let x = num1 {
return x
}
else if let y = num2
{
return y
}
else
{
assert(false, "Both nil")
}
}
Whether or not to assert, is probably an implementation choice that you would have to make. Another way would be, if you're absolutely sure, that one of them would be not nil, that you make the return type of the function "implicitly unwrapped". I know you wanna return nil when both are nil, but then having to check the returned value of this function which is supposed to check two values and return the one which is not nil, IMHO wasn't making much sense, thus I tried it this way.