Question

我有一个协议，符合类和一个简单函数的类。

protocol Outputable {
    static func output()
}

class Foo: Outputable {
    static func output() {
        print("output")
    }
}

class Bar {
    func eat(_ object: AnyObject?) {
        if let object = object, let objectType = type(of: object) as? Outputable.Type {
            objectType.output()
        }
    }
}

let foo = Foo()
let bar = Bar()
var fooOptional: Foo?
bar.eat(foo) // prints 'output'
bar.eat(fooOptional) // print nothing

有没有办法将一些可选类型传递为nil但符合Outputable协议并在eat函数内调用协议的静态函数？即使它没有，我仍在传递一种类型，这就是我应该在里面吃的所有东西，对吧？

使其更清晰。我知道为什么最后一行没有打印。但有没有办法调整eat来打印'输出'字符串？

Answer 1

您可以扩展Optional以符合您的协议。

protocol Outputable {

    func output()

}

extension Optional: Outputable {

    func output() {
        switch self {
        case .some(let object):
            print("I have an object: \(object)")
        case .none:
            print("I'm nil")
        }
    }

}

class Foo { }

class Bar {

    func eat(_ object: AnyObject?) {
        if let object = object as? Outputable {
            object.output()
        }
    }

}

var foo: Foo?
let bar = Bar()
bar.eat(foo)  // prints "I'm nil"

Answer 2

您可以实现的目标之一就是使用泛型并在类型上调用您的方法：

func eat<T: Outputable>(_ object: T?) {
    T.output()
}

这适用于Foo和Foo?

Answer 3

在

处设一个断点

if let object = object, let objectType = type(of: object) as? Outputable.Type {
    objectType.output()
}

您将意识到objectType.output()未被调用。只有右手边的物体不是零，if let才能成功。在你的情况下哪个是零。

Answer 4

如果你改写了测试，那么为什么它不起作用的逻辑变得更加清晰。

class Bar {
    func eat(_ object: AnyObject?) {
        if let object = object {
            if let objectType = type(of: object) as? Outputable.Type {
                objectType.output()
            } else {
                print("Mismatch on type")
            }
        } else {
            print("No object provided")
        }
    }
}

节目：

输出
没有提供对象

在可选类型上调用静态函数

4 个答案: