Swift contiene extensión para Array

Estoy intentando agregar un método de extensión en Array así:

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

Pero self.filter {$0 == obj} no funciona. Error del comstackdor:

no pudo encontrar una sobrecarga para '==' que acepte los arguments suministrados

en realidad no necesita escribir una extensión, puede usar la function global contains de la biblioteca Swift:

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

Swift 1.x

Como mencioné en los comentarios, hay una function contains . Pero para responder a la pregunta de cómo escribir una extensión y qué significa el error del comstackdor:

Los elementos en la matriz no necesariamente se pueden comparar con == . Equatable asegurarse de que el parámetro sea Equatable y debe asegurarse de que el elemento de matriz sea del mismo tipo.

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

Swift 2 / Xcode 7 (Beta)

Swift 2 incluye SequenceType.contains , que es exactamente lo que intentabas crear.

Esto es posible gracias a una syntax de Swift que permite restringir los methods a ciertos arguments de tipo (por ejemplo, Equatable). Se parece a esto:

 extension SequenceType where Generator.Element: Equatable { func contains(element: Self.Generator.Element) -> Bool { ... } } 

Descubrí que los contenidos integrados no funcionan con types de reference. Necesitaba esto y lo resolví con el siguiente código. Lo estoy pegando aquí porque alguien más podría estar confundido acerca de contiene () como yo.

 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 } } 

Esto funciona con Swift 2.1 para types de reference bastante buenos.

 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 } } 

Para los types de valor, puede agregar esto:

 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 } } 

No es perfecto, pero esta versión basada en la respuesta de nschum admite arguments opcionales (aunque no con matrices con types opcionales) también:

 extension Array { private func typeIsOptional() -> Bool { return reflect(self[0]).disposition == .Optional } func contains<U : Equatable>(obj: U) -> Bool { if isEmpty { return false } if (typeIsOptional()) { NSException(name:"Not supported", reason: "Optional Array types not supported", userInfo: nil).raise() } // cast type of array to type of argument to make it equatable for item in self.map({ $0 as? U }) { if item == obj { return true } } return false } // without this version, contains("foo" as String?) won't compile func contains<U : Equatable>(obj: U?) -> Bool { if isEmpty { return false } if (typeIsOptional()) { NSException(name:"Not supported", reason: "Optional Array types not supported", userInfo: nil).raise() } return obj != nil && contains(obj!) } } 

Si tiene una serie de opciones, puede get una copy de este con non-options (sin arguments eliminados) con esta function global gracias a jtbandes :

 func unwrapOptionals<T>(a: [T?]) -> [T] { return a.filter { $0 != nil }.map { $0! } } 

Uso:

  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" } 

Para una buena medida, agregue una que simplemente devuelva la matriz si su tipo no es opcional. De esta forma, evita errores de time de ejecución si llama a unwrapOptionals() en una matriz no opcional:

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

Tenga en count que podría pensar que podría llamar a unwrapOptionals dentro de la func contains<U : Equatable>(obj: U?) . Sin embargo, eso no funciona, porque el tipo de Element en la extensión de matriz es solo un tipo; no "sabe" que es un tipo opcional. Entonces, si llama a unwrapOptionals , se unwrapOptionals la segunda versión, y volverá a get la matriz llena de opciones.

    Intereting Posts