Simplifying nested if in swift - swift

Question

My app has a class called MyDevice that I use to communicate with hardware. This hardware is optionnal, so is the instance variable:
var theDevice:MyDevice = nil
Then, in the app, I have to initialize the device (for communication) then perform a self test to check its availability and readiness to perform. If this fails, the device is either not available / reachable / is malfunctionning.
Here is my overly complicated code. I am looking how to simplify it.
if let device = self.theDevice
{
device.initDevice()
if (!device.selfTest())
{
self.theDevice = nil;
}
}
I tried to combine all tests with && in the if statement, but it fails.
The issue is that I have 12 of them for various devices at the beginning of a function. It takes a lot of space and is dirty. How can I combine these statements in Swift ?

Answer 1

You can use ? optional chaining, and combine if case let pattern matching and where statement
theDevice?.initDevice()
if case let selfTest? = theDevice?.selfTest() where !selfTest{
theDevice = nil
}
But I would prefer if let optional unwrapping for readability.

Answer 2

You could improve this by making initDevice return self, then you could do the following:
if case let selfTest? = theDevice?.initDevice().selfTest() where !selfTest {
theDevice = nil
}
Another option may be to make initDevice perform the selfTest and return it.
All of this assumes that the initDevice is your code, or you can edit in one way or another.
If it is not editable, you can always make an extension and make a new method in that:
extension TheDeviceClass {
func initAndTest() -> Bool {
initDevice()
return selfTest()
}
}
and then call it using something like this:
if case let selfTest? = theDevice?.initAndTest() where !selfTest {
theDevice = nil
}
But this might make it more complicated than you would want. If you use this code a lot, consider putting it in another method.

Answer 3

I think you should change your MyDevice implementation to make your code less redundant, by defining a failable initializer and do all the checks inside it. Thus if the initialization fails you will get a nil and can just assign it to the relevant property of the other class, and don't even need the method that checks the 12 devices.
class MyDevice {
func selfTest() -> Bool {
// test
return testresult
}
func initDevice() {
// initialization
}
init?() {
self.initDevice()
if !self.selfTest() {
return nil
}
}
}
If you don't like to change your code too much, you may just define a closure to reduce these redundant code, like this (it still looks ugly so I DO NOT recommend you to do this.):
class SomeClassThatHasTwelveDevices {
var theDeviceOne: MyDevice?
var theDeviceTwo: MyDevice?
var theDeviceThree: MyDevice?
var theDeviceFour: MyDevice?
var theDeviceFive: MyDevice?
var theDeviceSix: MyDevice?
var theDeviceSeven: MyDevice?
var theDeviceEight: MyDevice?
var theDeviceNine: MyDevice?
var theDeviceTen: MyDevice?
var theDeviceEleven: MyDevice?
var theDeviceTwelve: MyDevice?
func someMethodThatChecksAllDevices() {
let check: (inout MyDevice?) -> Void = { deviceRef in
if let device = deviceRef {
device.initDevice()
if !device.selfTest() {
deviceRef = nil
}
}
}
check(&theDeviceOne)
check(&theDeviceTwo)
check(&theDeviceThree)
check(&theDeviceFour)
check(&theDeviceFive)
check(&theDeviceSix)
check(&theDeviceSeven)
check(&theDeviceEight)
check(&theDeviceNine)
check(&theDeviceTen)
check(&theDeviceEleven)
check(&theDeviceTwelve)
}
}