Ios Swift包含数组的扩展名

我试图在数组中添加一个扩展方法，如下所示：

extension Array {
    func contains(obj: T) -> Bool {
        let filtered = self.filter {$0 == obj}
        return filtered.count > 0
    }
}

但是

self.filter{$0==obj}

不起作用。编译器错误：

找不到接受提供的参数的“==”的重载

Swift 1.x 正如我在评论中提到的，有一个

包含
函数。但要回答如何编写扩展以及编译器错误的含义的问题：

数组中的元素不一定能与
=
进行比较。您需要确保参数是
equalable
，并且需要确保数组元素的类型相同

extension Array {
    func contains<T : Equatable>(obj: T) -> Bool {
        let filtered = self.filter {$0 as? T == obj}
        return filtered.count > 0
    }
}

您实际上不需要编写扩展，可以使用Swift库中的全局函数
contains
：

contains([1,2,3], 1)

不完美，但此版本也支持可选参数（虽然不是具有可选类型的数组）：

注意：您可能认为可以在
func-contains（obj:U？）
内部调用
unwropationals
。但是，这不起作用，因为数组扩展中的
元素
类型只是一个类型——它不“知道”它是一个可选类型。因此，如果您调用
unwactionals
，将调用第二个版本，您只需返回满是optionals的数组。
我发现内置的contains不适用于引用类型。我需要这个，并用下面的代码解决了它。我把它粘贴到这里是因为其他人可能会像我一样对contains（）感到困惑

extension Array {
    func containsReference(obj: AnyObject) -> Bool {
        for ownedItem in self {
            if let ownedObject: AnyObject = ownedItem as? AnyObject {
                if (ownedObject === obj) {
                    return true
                }
            }
        }

        return false
    }
} 

这在Swift 2.1中对参考类型非常有效

extension SequenceType where Generator.Element: AnyObject {
    func contains(obj: Self.Generator.Element?) -> Bool {
        if obj != nil {
            for item in self {
                if item === obj {
                    return true
                }
            }
        }
        return false
    }
}

对于值类型，可以添加以下内容：

extension SequenceType where Generator.Element: Equatable {
    func contains(val: Self.Generator.Element?) -> Bool {
        if val != nil {
            for item in self {
                if item == val {
                    return true
                }
            }
        }
        return false
    }
}

另外，已经有一个
包含（数组、对象）
函数。：）非常感谢。我不知道。奇怪的是，它不是类方法。如果它是一个函数，我们可以在编译时阻止
包含（“a”，5）
。我的答案需要检查每个元素的类型。这肯定是正确的答案：）这应该是正确的答案，简单且已经存在的方法。这肯定是正确的答案，但我个人认为值得添加一个扩展名，以便您可以调用someArray.contains（someValue）全局函数的问题是序列和元素都不能是可选的。如果其中一个/两个都是，则需要检查零并强制展开它们。数组上处理可选参数的contains函数会更干净。它们怎么能没有引用类型的contains方法呢？这让我很困惑。
 1>     func unwrapOptionals<T>(a: [T?]) -> [T] {
  2.         return a.filter { $0 != nil }.map { $0! }
  3.     }
  4>
  5> let foo = ["foo" as String?]
foo: [String?] = 1 value {
  [0] = "foo"
}
  6> let bar = unwrapOptionals(foo)
bar: [String] = 1 value {
  [0] = "foo"
}

func unwrapOptionals<T>(a: [T]) -> [T] {
    return a
}

extension Array {
    func containsReference(obj: AnyObject) -> Bool {
        for ownedItem in self {
            if let ownedObject: AnyObject = ownedItem as? AnyObject {
                if (ownedObject === obj) {
                    return true
                }
            }
        }

        return false
    }
} 

extension SequenceType where Generator.Element: AnyObject {
    func contains(obj: Self.Generator.Element?) -> Bool {
        if obj != nil {
            for item in self {
                if item === obj {
                    return true
                }
            }
        }
        return false
    }
}

extension SequenceType where Generator.Element: Equatable {
    func contains(val: Self.Generator.Element?) -> Bool {
        if val != nil {
            for item in self {
                if item == val {
                    return true
                }
            }
        }
        return false
    }
}