blocks|key|149726|text|您希望创建一个泛型类，其类型约束要求与其一起使用的类符合SomeProtocol，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|149727|class+SomeClass<T:+SomeProtocol>+{
++++typealias+ElementType+=+T
++++var+protocols+=+[ElementType]()

++++func+addElement(element:+ElementType)+{
++++++++self.protocols.append(element)
++++}

++++func+removeElement(element:+ElementType)+{
++++++++if+let+index+=+find(self.protocols,+element)+{
++++++++++++self.protocols.removeAtIndex(index)
++++++++}
++++}
}|code-block|syntax|javascript|149728|entityMap^0|S|C|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You want to create a generic class, with a type constraint that requires the classes used with it conform to <code>SomeProtocol</code>, like this:

<pre><code>class SomeClass&lt;T: SomeProtocol&gt; {
 typealias ElementType = T
 var protocols = [ElementType]()

 func addElement(element: ElementType) {
 self.protocols.append(element)
 }

 func removeElement(element: ElementType) {
 if let index = find(self.protocols, element) {
 self.protocols.removeAtIndex(index)
 }
 }
}
</code></pre>

blocks|key|149730|text|您遇到了Swift中协议的一个变体问题，目前还没有好的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|149731|另请参阅Extending+Array+to+check+if+it+is+sorted+in+Swift?，它包含关于如何解决它的建议，这些建议可能适合您的特定问题(您的问题非常通用，也许您可以使用这些答案找到解决方法)。|offset|length|149732|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/24602595/extending-array-to-check-if-it-is-sorted-in-swift^0|0|4|1E|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

You've hit a variant of a problem with protocols in Swift for which no good solution exists yet.

See also <a href="https://stackoverflow.com/questions/24602595/extending-array-to-check-if-it-is-sorted-in-swift">Extending Array to check if it is sorted in Swift?</a>, it contains suggestions on how to work around it that may be suitable for your specific problem (your question is very generic, maybe you can find a workaround using these answers).

blocks|key|2947207|text|我发现的有限的解决方案是将协议标记为仅类协议。这将允许您使用'===‘运算符比较对象。我知道这对structs等不起作用，但在我的例子中已经足够好了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2947208|protocol+SomeProtocol:+class+{
++++func+bla()
}

class+SomeClass+{

++++var+protocols+=+[SomeProtocol]()

++++func+addElement(element:+SomeProtocol)+{
++++++++self.protocols.append(element)
++++}

++++func+removeElement(element:+SomeProtocol)+{
++++++++for+i+in+0...protocols.count+{
++++++++++++if+protocols[i]+===+element+{
++++++++++++++++protocols.removeAtIndex(i)
++++++++++++++++return
++++++++++++}
++++++++}
++++}

}|code-block|syntax|javascript|2947209|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The limited solution that I found is to mark the protocol as a class-only protocol. This will allow you to compare objects using '===' operator. 
I understand this won't work for structs, etc., but it was good enough in my case.

<pre><code>protocol SomeProtocol: class {
 func bla()
}

class SomeClass {

 var protocols = [SomeProtocol]()

 func addElement(element: SomeProtocol) {
 self.protocols.append(element)
 }

 func removeElement(element: SomeProtocol) {
 for i in 0...protocols.count {
 if protocols[i] === element {
 protocols.removeAtIndex(i)
 return
 }
 }
 }

}
</code></pre>

blocks|key|2734544|text|解决方案非常简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2734545|protocol+SomeProtocol+{
++++func+bla()
}

class+SomeClass+{
++++init()+{}

++++var+protocols+=+[SomeProtocol]()

++++func+addElement<T:+SomeProtocol+where+T:+Equatable>(element:+T)+{
++++++++protocols.append(element)
++++}

++++func+removeElement<T:+SomeProtocol+where+T:+Equatable>(element:+T)+{
++++++++protocols+=+protocols.filter+{
++++++++++++if+let+e+=+$0+as?+T+where+e+==+element+{
++++++++++++++++return+false
++++++++++++}
++++++++++++return+true
++++++++}
++++}
}|code-block|syntax|javascript|2734546|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The solution is pretty simple:

<pre><code>protocol SomeProtocol {
 func bla()
}

class SomeClass {
 init() {}

 var protocols = [SomeProtocol]()

 func addElement&lt;T: SomeProtocol where T: Equatable&gt;(element: T) {
 protocols.append(element)
 }

 func removeElement&lt;T: SomeProtocol where T: Equatable&gt;(element: T) {
 protocols = protocols.filter {
 if let e = $0 as? T where e == element {
 return false
 }
 return true
 }
 }
}
</code></pre>

blocks|key|2947215|text|在Swift中，有一类特殊的协议，它不在实现它的类型上提供多态性。此类协议在其定义中使用Self或associatedtype关键字(+Equatable是其中之一)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2947216|在某些情况下，可以使用类型擦除的包装器来使集合同态。下面是一个例子。|2947217|//+This+protocol+doesn't+provide+polymorphism+over+the+types+which+implement+it.
protocol+X:+Equatable+{
++++var+x:+Int+{+get+}
}

//+We+can't+use+such+protocols+as+types,+only+as+generic-constraints.
func+==<T:+X>(a:+T,+b:+T)+->+Bool+{
++++return+a.x+==+b.x
}

//+A+type-erased+wrapper+can+help+overcome+this+limitation+in+some+cases.
struct+AnyX+{
++++private+let+_x:+()+->+Int
++++var+x:+Int+{+return+_x()+}

++++init<T:+X>(_+some:+T)+{
++++++++_x+=+{+some.x+}
++++}
}

//+Usage+Example

struct+XY:+X+{
++++var+x:+Int
++++var+y:+Int
}

struct+XZ:+X+{
++++var+x:+Int
++++var+z:+Int
}

let+xy+=+XY(x:+1,+y:+2)
let+xz+=+XZ(x:+3,+z:+4)

//let+xs+=+[xy,+xz]+//+error
let+xs+=+[AnyX(xy),+AnyX(xz)]
xs.forEach+{+print($0.x)+}+//+1+3|code-block|syntax|javascript|2947218|entityMap^0|18|4|1D|E|1W|9|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

In Swift there is a special class of protocols which doesn't provide polymorphism over the types which implement it. Such protocols use <code>Self</code> or <code>associatedtype</code> keywords in their definitions (and <code>Equatable</code> is one of them).

In some cases it's possible to use a type-erased wrapper to make your collection homomorphic. Below is an example.

<pre><code>// This protocol doesn't provide polymorphism over the types which implement it.
protocol X: Equatable {
 var x: Int { get }
}

// We can't use such protocols as types, only as generic-constraints.
func ==&lt;T: X&gt;(a: T, b: T) -&gt; Bool {
 return a.x == b.x
}

// A type-erased wrapper can help overcome this limitation in some cases.
struct AnyX {
 private let _x: () -&gt; Int
 var x: Int { return _x() }

 init&lt;T: X&gt;(_ some: T) {
 _x = { some.x }
 }
}

// Usage Example

struct XY: X {
 var x: Int
 var y: Int
}

struct XZ: X {
 var x: Int
 var z: Int
}

let xy = XY(x: 1, y: 2)
let xz = XZ(x: 3, z: 4)

//let xs = [xy, xz] // error
let xs = [AnyX(xy), AnyX(xz)]
xs.forEach { print($0.x) } // 1 3
</code></pre>

blocks|key|149742|text|我认为你的主要目标是持有一个符合某种协议的对象集合，添加到这个集合中，然后从中删除。这是您的客户端"SomeClass“中声明的功能。Equatable继承需要self，而这不是此功能所必需的。我们可以在Obj-C中使用"index“函数在数组中实现这一点，该函数可以接受自定义比较器，但在Swift中不支持。因此，最简单的解决方案是使用字典而不是数组，如下面的代码所示。我已经提供了getElements()，它将返回您想要的协议数组。因此，任何使用SomeClass的人都不会知道字典是用于实现的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|149743|因为在任何情况下，您都需要一些区分属性来分隔您的对象，所以我假设它是"name“。在创建新的SomeProtocol实例时，请确保您的do+element.name+=+"foo“。如果没有设置名称，您仍然可以创建实例，但不会将其添加到集合中，addElement()将返回"false“。|149744|protocol+SomeProtocol+{
++++var+name:String?+{get+set}+//+Since+elements+need+to+distinguished,+
++++//we+will+assume+it+is+by+name+in+this+example.
++++func+bla()
}

class+SomeClass+{

++++//var+protocols+=+[SomeProtocol]()+//find+is+not+supported+in+2.0,+indexOf+if
+++++//+There+is+an+Obj-C+function+index,+that+find+element+using+custom+comparator+such+as+the+one+below,+not+available+in+Swift
++++/*
++++static+func+compareProtocols(one:SomeProtocol,+toTheOther:SomeProtocol)->Bool+{
++++++++if+(one.name+==+nil)+{return+false}
++++++++if(toTheOther.name+==+nil)+{return+false}
++++++++if(one.name+==++toTheOther.name!)+{return+true}
++++++++return+false
++++}
+++*/

++++//The+best+choice+here+is+to+use+dictionary
++++var+protocols+=+[String:SomeProtocol]()


++++func+addElement(element:+SomeProtocol)+->+Bool+{
++++++++//self.protocols.append(element)
++++++++if+let+index+=+element.name+{
++++++++++++protocols[index]+=+element
++++++++++++return+true
++++++++}
++++++++return+false
++++}

++++func+removeElement(element:+SomeProtocol)+{
++++++++//if+let+index+=+find(self.protocols,+element)+{+//+find+not+suported+in+Swift+2.0


++++++++if+let+index+=+element.name+{
++++++++++++protocols.removeValueForKey(index)
++++++++}
++++}

++++func+getElements()+->+[SomeProtocol]+{
++++++++return+Array(protocols.values)
++++}
}|code-block|syntax|javascript|149745|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I take it that your main aim is to hold a collection of objects conforming to some protocol, add to this collection and delete from it. This is the functionality as stated in your client, "SomeClass". Equatable inheritance requires self and that is not needed for this functionality. We could have made this work in arrays in Obj-C using "index" function that can take a custom comparator but this is not supported in Swift. So the simplest solution is to use a dictionary instead of an array as shown in the code below. I have provided getElements() which will give you back the protocol array you wanted. So anyone using SomeClass would not even know that a dictionary was used for implementation.

Since in any case, you would need some distinguishing property to separate your objets, I have assumed it is "name". Please make sure that your do element.name = "foo" when you create a new SomeProtocol instance. If the name is not set, you can still create the instance, but it won't be added to the collection and addElement() will return "false".

<pre><code>protocol SomeProtocol {
 var name:String? {get set} // Since elements need to distinguished, 
 //we will assume it is by name in this example.
 func bla()
}

class SomeClass {

 //var protocols = [SomeProtocol]() //find is not supported in 2.0, indexOf if
 // There is an Obj-C function index, that find element using custom comparator such as the one below, not available in Swift
 /*
 static func compareProtocols(one:SomeProtocol, toTheOther:SomeProtocol)-&gt;Bool {
 if (one.name == nil) {return false}
 if(toTheOther.name == nil) {return false}
 if(one.name == toTheOther.name!) {return true}
 return false
 }
 */

 //The best choice here is to use dictionary
 var protocols = [String:SomeProtocol]()


 func addElement(element: SomeProtocol) -&gt; Bool {
 //self.protocols.append(element)
 if let index = element.name {
 protocols[index] = element
 return true
 }
 return false
 }

 func removeElement(element: SomeProtocol) {
 //if let index = find(self.protocols, element) { // find not suported in Swift 2.0


 if let index = element.name {
 protocols.removeValueForKey(index)
 }
 }

 func getElements() -&gt; [SomeProtocol] {
 return Array(protocols.values)
 }
}
</code></pre>

blocks|key|2734664|text|我在那篇博客文章中找到了一个而不是纯Swift解决方案：http://blog.inferis.org/blog/2015/05/27/swift-an-array-of-protocols/|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2734665|诀窍是在引入isEqual()时遵循NSObjectProtocol。因此，您可以编写自己的函数来查找元素并删除它，而不是使用Equatable协议及其默认用法==。|CODE|2734666|下面是您的find(array,+element)+->+Int?函数的实现：|2734667|protocol+SomeProtocol:+NSObjectProtocol+{

}

func+find(protocols:+[SomeProtocol],+element:+SomeProtocol)+->+Int?+{
++++for+(index,+object)+in+protocols.enumerated()+{
++++++++if+(object.isEqual(element))+{
++++++++++++return+index
++++++++}
++++}

++++return+nil
}|code-block|syntax|javascript|2734668|注意:在这种情况下，必须从NSObject继承符合SomeProtocol的对象。|2734669|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.inferis.org/blog/2015/05/27/swift-an-array-of-protocols/^0|E|3|S|1W|0|0|6|9|I|G|1R|9|28|2|0|5|S|0|0|D|8|P|C|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|H]|$9|18|A|19|B|H]|$9|1A|A|1B|B|H]|$9|1C|A|1D|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|1E|8|@$9|1F|A|1G|B|H]]|D|@]|E|$]]|$1|K|3|L|5|M|7|1H|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|1I|8|@$9|1J|A|1K|B|H]|$9|1L|A|1M|B|H]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|S|$T|$5|U|V|W|E|$X|Y]]]]

I found a not pure-pure Swift solution on that blog post:
<a href="http://blog.inferis.org/blog/2015/05/27/swift-an-array-of-protocols/" rel="nofollow noreferrer">http://blog.inferis.org/blog/2015/05/27/swift-an-array-of-protocols/</a>

The trick is to conform to <code>NSObjectProtocol</code> as it introduces <code>isEqual()</code>.
Therefore instead of using the <code>Equatable</code> protocol and its default usage of <code>==</code> you could write your own function to find the element and remove it.

Here is the implementation of your <code>find(array, element) -&gt; Int?</code> function:

<pre><code>protocol SomeProtocol: NSObjectProtocol {

}

func find(protocols: [SomeProtocol], element: SomeProtocol) -&gt; Int? {
 for (index, object) in protocols.enumerated() {
 if (object.isEqual(element)) {
 return index
 }
 }

 return nil
}
</code></pre>

Note: In this case your objects conforming to <code>SomeProtocol</code> must inherits from <code>NSObject</code>.

I want to create a class that can store objects conforming to a certain protocol. The objects should be stored in a typed array. According to the Swift documentation protocols can be used as types: 
<blockquote>
Because it is a type, you can use a protocol in many places where other types are allowed, including:
<ul>
<li>As a parameter type or return type in a function, method, or initializer</li>
<li>As the type of a constant, variable, or property</li>
<li>As the type of items in an array, dictionary, or other container</li>
</ul>
</blockquote>
However the following generates compiler errors:
<blockquote>
Protocol 'SomeProtocol' can only be used as a generic constraint because it has Self or associated type requirements
</blockquote>
How are you supposed to solve this:
<pre><code>protocol SomeProtocol: Equatable {
 func bla()
}

class SomeClass {
 
 var protocols = [SomeProtocol]()
 
 func addElement(element: SomeProtocol) {
 self.protocols.append(element)
 }
 
 func removeElement(element: SomeProtocol) {
 if let index = find(self.protocols, element) {
 self.protocols.removeAtIndex(index)
 }
 }
}
</code></pre>

Usage of protocols as array types and function parameters in swift

编译器

容器

Swift

我想创建一个可以存储符合特定协议的对象的类。对象应该存储在类型化数组中。根据Swift文档协议可以用作类型：因为它是一种类型，所以您可以在许多允许其他类型的地方使用协议，包括：作为函数、方法或初始值设定项中的参数类型或返回类型作为常量、变量或属性的类型作为数组、字典或其他容器中的项的类型但是，以下代码会生成编译器错误：...

问在swift中使用协议作为数组类型和函数参数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在swift中使用协议作为数组类型和函数参数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在swift中使用协议作为数组类型和函数参数
EN