Question

（第一篇文章）

通常我能在这里或其他地方找到答案，但这次没有运气=（

问题：在Swift中，如何通过作为函数参数提供的实现类型过滤协议类型的数组？

protocol Aprotocol {
   var number:Int { get set }
}

class Aclass: Aprotocol {
    var number = 1
}

class AnotherClass: Aprotocol {
    var number = 1
}

var array:[Aprotocol] = [ Aclass(), AnotherClass(), Aclass() ]

func foo (parameter:Aprotocol) -> Int {
    return array.filter({ /* p in p.self == parameter.self  */ }).count
}

var bar:Aprotocol = // Aclass() or AnotherClass()

var result:Int = foo(bar) // should return 2 or 1, depending on bar type

也许这根本不是正确的做法？

谢谢！

Answer 1

非常简单：

return array.filter({ parameter.number == $0.number }).count

Answer 2

这是我认为你想要的：

return array.filter { (element: Aprotocol) -> Bool in
    element.dynamicType == parameter.dynamicType
}.count

但是我推荐这个，它做同样的事情，但是没有无用的Aclass()实例，它在顶部的答案中传递。这种方式也更快：

func foo <T: Aprotocol>(type: T.Type) -> Int {
    return array.filter { (element: Aprotocol) -> Bool in
        element.dynamicType == type
    }.count
}

var result:Int = foo(Aclass)

dynamicType将返回实例的类型

Answer 3

Kametrixoms解决方案有效（如果你使用“是T”而不是“== type”）但在我的情况下，因为我不知道哪个实现类会调用它，所以必须使用这个解决方案：

protocol Aprotocol: AnyObject {
    var number:Int { get set }
}

class func foo(parameter: AnyObject) -> Int {    
    return array.filter ({ (element: Aprotocol) -> Bool in
    object_getClassName(element) == object_getClassName(parameter)
  }).count
}

Swift：通过比较类型过滤协议数组

3 个答案: