Protocols 如何在Swift中将协议作为参数传递

在Objective-C中，我知道如何将

协议作为参数传递：

- (void)MyMethod:(Protocol *)myparameter

但是在Swift中没有更多的
协议
类型

如何在不知道哪个是参数的情况下将协议作为参数传递？
以下是我尝试过的：

@objc protocol Walker
{
    func walk()
}

@objc protocol Runner
{
    func run()
}

@objc class Zombie : Walker
{
    func walk () { println("Brains...") }
}

@objc class Survivor : Runner
{
    func run() { println("Aaaah, zombies!") }
}

func classesConformingToProtocol(proto:Protocol) -> AnyClass[]
{
    let availableClasses : AnyClass[] = [ Zombie.self, Survivor.self ]

    var conformingClasses = Array<AnyClass>()

    for myClass : AnyClass in availableClasses
    {
        if myClass.conformsToProtocol(proto)
        {
            conformingClasses.append(myClass)
        }
    }

    return conformingClasses
}

// This does not work
let walkers = classesConformingToProtocol(Walker.self)
let runners = classesConformingToProtocol(Runner.self)

@objc协议步行器
{
func walk（）
}
@objc协议运行程序
{
func run（）
}
@objc类僵尸：沃克
{
func walk（）{println（“大脑…”）}
}
@objc级幸存者：跑步者
{
func run（）{println（“啊，僵尸！”）}
}
func classesConformingToProtocol（proto:Protocol）->AnyClass[]
{
let availableClasses:AnyClass[]=[Zombie.self，Survivor.self]
var conformingClasses=Array（）
对于myClass:AvailableClass中的任何类
{
如果myClass.conformsToProtocol（proto）
{
conformingClasses.append（myClass）
}
}
返回符合条件的类
}
//这行不通
let walkers=classesConformingToProtocol（Walker.self）
let runners=classesConformingToProtocol（Runner.self）

我无法将Swift的
元类型
信息转换为
协议
对象。
今天找到了一种方法（Xcode 6.1）：

首先，协议必须标记为@objc，以便进行任何检查。
然后使用“if-let”转换检查一致性

@objc protocol MyProtocol {
    var protocolValue: Int { get set }
}

if let conformingObject = someObject as? MyProtocol {
   // conformingObject is now someObject cast to MyProtocol
   conformingObject.protocolValue = 3
}

在你的评论中，你说：

“我想创建一个方法，该方法返回实现所需协议的类类型的数组。”

您是否尝试过以下方法：

//notice the use of @objc here
@objc protocol AlertProtocol
{
    func getMyName()->String
}

class Class1 : AlertProtocol
{
     let name = "Object 1"
     func getMyName() -> String
    {
        return name
    }
}

class Class2 : AlertProtocol
{
    let name = "Object 2"
    func getMyName() -> String
    {
        return name
    }
}

//borrowing from and refactoring siLo's answer
func classesConformingToProtocol(proto:Protocol) -> [AnyClass]
{
    let availableClasses : [AnyClass] = [ Class1.self, Class2.self ]

    var conformingClasses = Array<AnyClass>()

    for myClass : AnyClass in availableClasses
    {
        if myClass.conforms(to: proto)
        {
            conformingClasses.append(myClass)
        }
    }

    return conformingClasses
}

完成这项工作的棘手部分是“@objc”，它将协议公开给objective c运行时，并允许我们将任何“协议类型”作为参数传递

可能在将来的某个时候，我们将能够以“纯”的Swift方式完成此操作。
在Swift 2.0中，我以前是这样使用它的：

classA.conformsToProtocol（XXXProtocol.self as！协议）

它不好用

查看
协议的定义：

// All methods of class Protocol are unavailable. 
// Use the functions in objc/runtime.h instead.

@available(iOS 2.0, *)
public class Protocol {
}

所有这些都不可用…我不知道在objc/runtime.h中应该使用哪一个

所以我必须使用这个方法：

if ClassA is protocol<XXXProtocol> {
    // do something
}

如果ClassA是协议{
//做点什么
}

目前，它可以工作…
如果您不允许使用
@objc
（例如，因为您的协议具有属性），我找到的唯一解决方案是使用闭包。然后，需要使用闭包来使用协议并返回值

protocol Proto { }
protocol Proto2 { }
class Foo: Proto { }
class Bar: Proto, Proto2 { }
class Baz: Proto2 { }
class Qux { }

func printConforms(classList: [AnyClass], protoCond: (AnyClass) -> Any?) {
    for i in classList {
        print(i, terminator: " -> ")
        if protoCond(i) != nil {
            print("is subscriber")
        } else {
            print("NOT IS subscriber")
        }
    }
}

let myClasses: [AnyClass] = [Foo.self, Bar.self, Baz.self, Qux.self]
printConforms(classList: myClasses, protoCond: { $0 as? Proto.Type })

更完整的示例：

编辑

另一个更好的解决方案是使用泛型，例如：

protocol Proto { }
class Foo: Proto { }
class Bar: Proto { }
class Baz { }

func filter<T>(classes: [AnyClass], byConformanceTo: T.Type) -> [AnyClass] {
    return classes.filter { $0 is T }
}

filter(classes: [Foo.self, Bar.self, Baz.self], byConformanceTo: Proto.Type.self)
// return [Foo.self, Bar.self]

协议协议{}
类Foo:Proto{}
类栏：Proto{}
类Baz{}
func过滤器（类：[AnyClass]，按符合：T.Type）->[AnyClass]{
return classes.filter{$0是T}
}
过滤器（类：[Foo.self，Bar.self，Baz.self]，按符合：Proto.Type.self）
//返回[Foo.self，Bar.self]
传递协议，或传递符合协议的对象？有一种
协议
类型，请参见NSObjectProtocol的Swift定义，它具有以下功能：
func conformsToProtocol（aProtocol:protocol！）->Bool
，您可以用同样的方式定义自己的方法。但我仍在试图找出如何将某些东西传递到这个方法中！谢谢Sam，我仍在努力理解如何调用
conformsToProtocol
方法！我的答案中的纯swift实现：请参见我的答案：也适用于类我想创建一个方法，返回实现所需协议的类类型数组。您知道如何将协议作为参数传递吗？特定协议，或任何协议类型？您对任何协议类型的含义是什么？我的想法是编写一个方法，将协议作为参数，并返回一个数组，其中包含我的项目中实现传入参数的协议的所有类。啊，您需要使用
AnyClass
参数，这是
class
和
protocols
的元数据类型。我会修改我的答案。这不完全是我问题的目的。我的问题是如何将协议类型传递给方法。不检查var是否符合协议。抱歉造成混淆。我真的在回答你上面的评论，你说“谢谢Sam，我仍在试图理解如何调用conformsToProtocol方法！”在Swift 3中，
conformsToProtocol（协议）
被替换为
conforms（to:AnyObject.Type）
protocol Proto { }
class Foo: Proto { }
class Bar: Proto { }
class Baz { }

func filter<T>(classes: [AnyClass], byConformanceTo: T.Type) -> [AnyClass] {
    return classes.filter { $0 is T }
}

filter(classes: [Foo.self, Bar.self, Baz.self], byConformanceTo: Proto.Type.self)
// return [Foo.self, Bar.self]