[Any]和contains（）的数组

本文介绍了[Any]和contains（）的数组的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！ 问题描述

我正在尝试测试类型 [Any] 的数组是否包含特定类型的值（例如， Int ）。

I'm trying to test if an array of type [Any] contains a value of a specific type (say, Int).

我知道Swift不知道如何比较 Int 和值的类型，我想这就是自动完成模板中要表达的内容：

I'm aware that Swift does not know how to compare an Int and a value of arbitrary type, and I guess that's what's being expressed in the autocomplete template:

包含（谓词：（protocol<>））抛出- >布尔）

所以我尝试了以下代码：

So I tried this code:

let intValue:Int = 5 // for example let isContained = myArrayOfAny.contains({ element in return ((element as? Int) == intValue) })

...并且可以编译（无法确定是否可以正常使用） ）;但仍然不能成为谓词（（协议））部分的首尾。这是什么意思？ SequenceType 的文档非常隐秘：

...and it compiles (can't make sure it works yet); but still can't make heads or tails of the predicate: (protocol<>) part. What does it mean? The documentation for SequenceType is quite cryptic:

contains(_: (Self.Generator.Element) throws -> Bool) rethrows -> Bool Default Implementation Return true iff an element in self satisfies predicate. Declaration @warn_unused_result func contains(@noescape _ predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Bool

编辑：我很困惑，因为我看到的所有搜索结果都具有 Array 的 contains（）方法取要测试是否包含的值，例如：

I'm quite confused because, all search results I've seen have the contains() method of Array as just taking the value to be tested for containment, e.g.:

if myArrayOfInt.contains(someInt){ ...

而不是闭包。

推荐答案

有两种不同的 contains（）方法（这两种协议的扩展都是 SequenceType ）。第一个是

There are two different contains() methods (both protocol extensions to SequenceType). The first one is

extension SequenceType where Generator.Element : Equatable { /// Return `true` iff `element` is in `self`. @warn_unused_result public func contains(element: Self.Generator.Element) -> Bool }

，它要求序列元素符合平等的 协议，该协议保证可以将它们与 ==

and it requires that the sequence elements conform to the Equatable protocol, which guarantees that they can be compared with ==:

public protocol Equatable { // ... public func ==(lhs: Self, rhs: Self) -> Bool }

例如，在

let intValue:Int = 5 let myArrayOfInt = [4, 5, 6] let isContained = myArrayOfInt.contains(intValue)

您有一个 Int 和 Int 符合 Equatable ，，因此此 contains（）方法可以用来检查某个元素的存在。

you have an array of Int, and Int conforms to Equatable, so this contains() method can be used to check for the presence of a certain element.

这不适用于

let myArrayOfAny : [Any] = [4, 5, 6]

因为任何不符合 Equatable 。在这里，您可以使用作为第二个 contains（）方法

because Any does not conform to Equatable. Here you can use the second contains() method

extension SequenceType { /// Return `true` iff an element in `self` satisfies `predicate`. @warn_unused_result public func contains(@noescape predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Bool }

需要一个谓词，即布尔值功能。将谓词应用于每个数组元素，而不是将与 == 进行比较。 此方法不需要数组元素 Equatable 。

which takes a predicate, i.e. a boolean function. Instead of comparing with ==, the predicate is applied to each array element. This method does not require that the array elements are Equatable.

这就是您要做的

let myArrayOfAny : [Any] = [4, 5, 6] let intValue:Int = 5 // for example let isContained = myArrayOfAny.contains({ element in return ((element as? Int) == intValue) })

如果可以将任何数组元素转换为 Int，这将产生 true 并等于给定的 intValue 。

This will yield true if any array element can be cast to an Int and is equal to the given intValue.

可能会看到第一种方法使用频率更高，但是第二种则更为通用，例如，如果myArrayOfCustomObjects.contains（{$ 0。$

The might see the first method more frequently but the second is far more general, e.g.

if myArrayOfCustomObjects.contains ({ $0.someProperty == "foo" })

或

if myArrayOfInts.contains ({ $0 > 17 })

因此，第一个 contains（）是第二种的一种专门化形式，用于对平等的元素。它可以 实现为

So the first contains() is a kind of specialization of the second one for a simple containment check in arrays of equatable elements. It could be implemented as

extension SequenceType where Generator.Element : Equatable { public func contains(element: Self.Generator.Element) -> Bool { return self.contains({ $0 == element } ) } }

您会发现与 indexOf（）相同，它也有两种风格：

You'll find the same with indexOf() which also comes in two flavors:

extension CollectionType where Generator.Element : Equatable { // ... public func indexOf(element: Self.Generator.Element) -> Self.Index? } extension CollectionType { // ... public func indexOf(@noescape predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Self.Index? }