Cómo get una list de elementos comunes de 2 array en swift

Tengo dos matrices:

fruitsArray = ["apple", "mango", "blueberry", "orange"] vegArray = ["tomato", "potato", "mango", "blueberry"] 

¿Cómo puedo get la list de elementos comunes en esos dos sets que da

 ouptput = ["mango", "blueberry"] 

No puedo usar if contains(array, string) ya que quiero comparar 2 arrays. Por favor ayuda

No necesita un set (como lo mencionaron los comentarios anteriores).

En su lugar, podría usar una function genérica , similar a la que Apple usa en su Swift Tour, y así evitar el casting :

 func anyCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, rhs: U) -> Bool { for lhsItem in lhs { for rhsItem in rhs { if lhsItem == rhsItem { return true } } } return false } 

Esta function puede tomar dos arrays (SequenceTypes) y si alguno de sus elementos es el mismo, devuelve true.

Simplemente puede modificar esta function genérica para empaquetar un set de cadenas y devolverlo en su lugar.

Por ejemplo así:

 func arrayOfCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, rhs: U) -> [T.Generator.Element] { var returnArray:[T.Generator.Element] = [] for lhsItem in lhs { for rhsItem in rhs { if lhsItem == rhsItem { returnArray.append(lhsItem) } } } return returnArray } 

Uso como este:

 var one = ["test2", "dog", "cat"] var other = ["test2", "cat", "dog"] var result = arrayOfCommonElements(one,other) print(result) //prints [test2, dog, cat] 

El beneficio adicional aquí es que esta function también funciona con todos los mismos arreglos typescripts. Entonces, si necesita comparar dos arreglos [myCustomObject] , una vez que ambos se conforman a ecuable, ¡está listo ! (juego de palabras)

Editar: (Para elementos no comunes) podrías hacer algo como esto

 func arrayOfNonCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, rhs: U) -> [T.Generator.Element] { var returnArray:[T.Generator.Element] = [] var found = false for lhsItem in lhs { for rhsItem in rhs { if lhsItem == rhsItem { found = true break } } if (!found){ returnArray.append(lhsItem) } found = false } for rhsItem in rhs { for lhsItem in lhs { if rhsItem == lhsItem { found = true break } } if (!found){ returnArray.append(rhsItem) } found = false } return returnArray } 

Sin embargo, esta implementación es fea.

También puede usar el filter y contains conjuntamente:

 let fruitsArray = ["apple", "mango", "blueberry", "orange"] let vegArray = ["tomato", "potato", "mango", "blueberry"] let output = fruitsArray.filter{ contains(vegArray, $0) } // in Swift 2 you can even use this let output = fruitsArray.filter(vegArray.contains) 

Conviértelos en Establecer y use la function intersect ():

 let fruitsArray = ["apple", "mango", "blueberry", "orange"] let vegArray = ["tomato", "potato", "mango", "blueberry"] let fruitsSet = Set(fruitsArray) let vegSet = Set(vegArray) let output = Array(fruitsSet.intersect(vegSet)) 

Un método genérico, inspirado en el ejercicio del lenguaje de progtwigción Swift 3 :

 func commonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> [T.Iterator.Element] where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element { var common: [T.Iterator.Element] = [] for lhsItem in lhs { for rhsItem in rhs { if lhsItem == rhsItem { common.append(lhsItem) } } } return common } 

Incluso puede comparar los objects dentro de la matriz y filtrar la matriz común

 struct myStruct { var userid:String; var details:String; init() { userid = "default value"; details = "default"; } }; var f1 = myStruct(); f1.userid = "1"; f1.details = "Good boy"; var f2 = myStruct(); f2.userid = "2"; f2.details = "Bad boy"; var f3 = myStruct(); f3.userid = "3"; f3.details = "Gentleman"; var arrNames1:Array = [f1,f3]; var arrNames2:Array = [f3,f1,f2]; let filtenetworkingArrayStruct = arrNames1.filter( { (user: myStruct) -> Bool in return arrNames2.contains({ (user1: myStruct) -> Bool in return user.userid == user1.userid; }) }) print(filtenetworkingArrayStruct) 

Swift 3.0

Use el filter para get elementos comunes de dos matrices.

 let fruitsArray = ["apple", "mango", "blueberry", "orange"] let vegArray = ["tomato", "potato", "mango", "blueberry"] let newArray = fruitsArray.filter { (string) -> Bool in return vegArray.contains(string) } print(newArray) // OR /*let newArray = fruitsArray.filter{vegArray.contains($0)}*/ 

Salida:

["mango", "arándano"]