NSObject子类的无参数Failable初始值设定项

Question

I'd like to provide a failable initializer to an NSObject subclass for the initialization without parameters. My overall goal is to return nil this class is initialized on an OS version less than 8.0.

My attempt at this is below:

class MyObject: NSObject {
    override init?() {
        super.init()
        if floor(NSFoundationVersionNumber) <= NSFoundationVersionNumber_iOS_7_1 {
            return nil
        }

    }
}

However this code results in the following compiler error.

Failable initializer 'init()' cannot override a non-failable initializer

Is it possible to override init() to provide a failable implementation in a subclass? Or is there a better way to achieve this goal?

Answer 1

As you are subclassing NSObject, you cannot have a failable no-parameter initialiser as NSObject's no parameter initialiser is not failable.

You could create a class factory method that returns an instance or nil depending on the iOS version

Answer 2

Given that:

You can override a failable initializer with a nonfailable initializer but not the other way around.

and

A failable initializer can also delegate to a nonfailable initializer. Use this approach if you need to add a potential failure state to an existing initialization process that does not otherwise fail.

(excerpts from Failable Initializers )

and taking into account that NSObject does not have a parameterless failable initializer, then no, you cannot override a non failable initializer with a failable initializer.

The only option I see is to create an initializer with a dummy parameter, like:

class MyObject: NSObject {
    init?(_ ignore: Bool) {
        super.init()
        if floor(NSFoundationVersionNumber) <= NSFoundationVersionNumber_iOS_7_1 {
            return nil
        }
    }
}

and then using it as:

var myObj = MyObject(true)

or

var myObj = MyObject(false)

More interestingly, assigning a default value to the dummy parameter seems to do the job pretty well:

class MyObject: NSObject {
    init?(_ ignore: Bool = false) {
        super.init()
        if floor(NSFoundationVersionNumber) <= NSFoundationVersionNumber_iOS_7_1 {
            return nil
        }
    }
}

var myObj = MyObject()

Answer 3

If you don't want to pass a 'dummy' argument, you could pass an inout error. That way, you can avoid polluting the code with dummy parameters and know more about why initialization failed (if it matters).

final class FailableFoo: NSObject {
    let foo: String

    enum FailableFooInitializationError: LocalizedError {
        case somethingWentWrong
    }

    required init?(error: inout Error?) {
        foo = "Foo"
        let somethingWentWrong = true
        if somethingWentWrong {
            error = FailableFooInitializationError.somethingWentWrong
            return nil
        } else {
            super.init()
        }
    }
}

final class Bar: NSObject {
    let foo: FailibleFoo?

    override init() {
        var fooInitializationError: Error? = nil
        foo = FailableFoo(error: &fooInitializationError)
        if let fooInitializationError = fooInitializationError {
            // handle init error
        }
        super.init()
    }
}