Cómo agrupar por los elementos de una matriz en Swift

Digamos que tengo este código:

class Stat { var statEvents : [StatEvents] = [] } struct StatEvents { var name: String var date: String var hours: Int } var currentStat = Stat() currentStat.statEvents = [ StatEvents(name: "lunch", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1), StatEvents(name: "lunch", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1) ] var filteredArray1 : [StatEvents] = [] var filteredArray2 : [StatEvents] = [] 

Podría llamar tantas veces manualmente la siguiente función para tener 2 matrices agrupadas por “mismo nombre”.

 filteredArray1 = currentStat.statEvents.filter({$0.name == "dinner"}) filteredArray2 = currentStat.statEvents.filter({$0.name == "lunch"}) 

El problema es que no sabré el valor de la variable, en este caso “cena” y “almuerzo”, por lo que me gustaría agrupar esta matriz de eventos estadísticos automáticamente por nombre, así que obtengo tantas matrices como el nombre se pone diferente.

¿Cómo podría hacer eso?

    Swift 4:

    Desde Swift 4, esta funcionalidad se ha agregado a la biblioteca estándar . Puedes usarlo así:

     Dictionary(grouping: statEvents, by: { $0.name }) [ "dinner": [ StatEvents(name: "dinner", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1) ], "lunch": [ StatEvents(name: "lunch", date: "01-01-2015", hours: 1), StatEvents(name: "lunch", date: "01-01-2015", hours: 1) ] 

    Swift 3:

     public extension Sequence { func group(by key: (Iterator.Element) -> U) -> [U:[Iterator.Element]] { var categories: [U: [Iterator.Element]] = [:] for element in self { let key = key(element) if case nil = categories[key]?.append(element) { categories[key] = [element] } } return categories } } 

    Desafortunadamente, la función de append arriba copia la matriz subyacente, en lugar de mutarla en su lugar, lo que sería preferible. Esto causa una desaceleración bastante grande . Puede solucionar el problema utilizando un contenedor de tipo de referencia:

     class Box { var value: A init(_ val: A) { self.value = val } } public extension Sequence { func group(by key: (Iterator.Element) -> U) -> [U:[Iterator.Element]] { var categories: [U: Box< [Iterator.Element]>] = [:] for element in self { let key = key(element) if case nil = categories[key]?.value.append(element) { categories[key] = Box([element]) } } var result: [U: [Iterator.Element]] = Dictionary(minimumCapacity: categories.count) for (key,val) in categories { result[key] = val.value } return result } } 

    Aunque recorra el diccionario final dos veces, esta versión es aún más rápida que la original en la mayoría de los casos.

    Swift 2:

     public extension SequenceType { /// Categorises elements of self into a dictionary, with the keys given by keyFunc func categorise(@noescape keyFunc: Generator.Element -> U) -> [U:[Generator.Element]] { var dict: [U:[Generator.Element]] = [:] for el in self { let key = keyFunc(el) if case nil = dict[key]?.append(el) { dict[key] = [el] } } return dict } } 

    En su caso, podría tener las “claves” devueltas por keyFunc sean los nombres:

     currentStat.statEvents.categorise { $0.name } [ dinner: [ StatEvents(name: "dinner", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1) ], lunch: [ StatEvents(name: "lunch", date: "01-01-2015", hours: 1), StatEvents(name: "lunch", date: "01-01-2015", hours: 1) ] ] 

    Entonces obtendrá un diccionario, donde cada clave es un nombre, y cada valor es una matriz de los StatEvents con ese nombre.

    Swift 1

     func categorise(seq: S, @noescape keyFunc: S.Generator.Element -> U) -> [U:[S.Generator.Element]] { var dict: [U:[S.Generator.Element]] = [:] for el in seq { let key = keyFunc(el) dict[key] = (dict[key] ?? []) + [el] } return dict } categorise(currentStat.statEvents) { $0.name } 

    Lo que le da la salida:

     extension StatEvents : Printable { var description: String { return "\(self.name): \(self.date)" } } print(categorise(currentStat.statEvents) { $0.name }) [ dinner: [ dinner: 01-01-2015, dinner: 01-01-2015, dinner: 01-01-2015 ], lunch: [ lunch: 01-01-2015, lunch: 01-01-2015 ] ] 

    (El swiftstub está aquí )

    Con Swift 4, Dictionary tiene un método de inicialización llamado init(grouping:by:) . init(grouping:by:) tiene la siguiente statement:

     init(grouping values: S, by keyForValue: (S.Element) throws -> Key) rethrows where Value == [S.Element], S : Sequence 

    Crea un nuevo diccionario donde las claves son las agrupaciones devueltas por el cierre dado y los valores son matrices de los elementos que devolvieron cada clave específica.


    El siguiente código de Playground muestra cómo usar init(grouping:by:) para resolver su problema:

     struct StatEvents: CustomStringConvertible { let name: String let date: String let hours: Int var description: String { return "Event: \(name) - \(date) - \(hours)" } } let statEvents = [ StatEvents(name: "lunch", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1), StatEvents(name: "lunch", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1) ] let predicate = { (element: StatEvents) in return element.name } let dictionary = Dictionary(grouping: statEvents, by: predicate) print(dictionary) /* prints: [ "dinner": [Event: dinner - 01-01-2015 - 1, Event: dinner - 01-01-2015 - 1], "lunch": [Event: lunch - 01-01-2015 - 1, Event: lunch - 01-01-2015 - 1] ] */ 

    Para Swift 3:

     public extension Sequence { func categorise(_ key: (Iterator.Element) -> U) -> [U:[Iterator.Element]] { var dict: [U:[Iterator.Element]] = [:] for el in self { let key = key(el) if case nil = dict[key]?.append(el) { dict[key] = [el] } } return dict } } 

    Uso:

     currentStat.statEvents.categorise { $0.name } [ dinner: [ StatEvents(name: "dinner", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1), StatEvents(name: "dinner", date: "01-01-2015", hours: 1) ], lunch: [ StatEvents(name: "lunch", date: "01-01-2015", hours: 1), StatEvents(name: "lunch", date: "01-01-2015", hours: 1) ] ] 

    Swift 4: puede usar init (agrupación: por 🙂 desde el sitio desarrollador de apple

    Ejemplo :

     let students = ["Kofi", "Abena", "Efua", "Kweku", "Akosua"] let studentsByLetter = Dictionary(grouping: students, by: { $0.first! }) // ["E": ["Efua"], "K": ["Kofi", "Kweku"], "A": ["Abena", "Akosua"]] 

    Entonces en tu caso

      let dictionary = Dictionary(grouping: currentStat.statEvents, by: { $0.name! }) 

    En Swift4, esta extensión tiene el mejor rendimiento y ayuda a encadenar sus operaciones

     extension Sequence { func group(by key: (Iterator.Element) -> U) -> [U:[Iterator.Element]] { return Dictionary.init(grouping: self, by: key) } } 

    Ejemplo:

     struct Asset { let coin: String let amount: Int } let assets = [ Asset(coin: "BTC", amount: 12), Asset(coin: "ETH", amount: 15), Asset(coin: "BTC", amount: 30), ] let grouped = assets.group(by: { $0.coin }) 

    Crea:

     [ "ETH": [ Asset(coin: "ETH", amount: 15) ], "BTC": [ Asset(coin: "BTC", amount: 12), Asset(coin: "BTC", amount: 30) ] ] 

    Swift 4

     struct Foo { let fizz: String let buzz: Int } let foos: [Foo] = [Foo(fizz: "a", buzz: 1), Foo(fizz: "b", buzz: 2), Foo(fizz: "a", buzz: 3), ] // use foos.lazy.map instead of foos.map to avoid allocating an // intermediate Array. We assume the Dictionary simply needs the // mapped values and not an actual Array let foosByFizz: [String: Foo] = Dictionary(foos.lazy.map({ ($0.fizz, $0)}, uniquingKeysWith: { (lhs: Foo, rhs: Foo) in // Arbitrary business logic to pick a Foo from // two that have duplicate fizz-es return lhs.buzz > rhs.buzz ? lhs : rhs }) // We don't need a uniquing closure for buzz because we know our buzzes are unique let foosByBuzz: [String: Foo] = Dictionary(uniqueKeysWithValues: foos.lazy.map({ ($0.buzz, $0)}) 

    Extendiéndose en la respuesta aceptada para permitir la agrupación ordenada :

     extension Sequence { func group(by key: (Iterator.Element) -> GroupingType) -> [[Iterator.Element]] { var groups: [GroupingType: [Iterator.Element]] = [:] var groupsOrder: [GroupingType] = [] forEach { element in let key = key(element) if case nil = groups[key]?.append(element) { groups[key] = [element] groupsOrder.append(key) } } return groupsOrder.map { groups[$0]! } } } 

    Entonces funcionará en cualquier tupla :

     let a = [(grouping: 10, content: "a"), (grouping: 20, content: "b"), (grouping: 10, content: "c")] print(a.group { $0.grouping }) 

    Además de cualquier estructura o clase :

     struct GroupInt { var grouping: Int var content: String } let b = [GroupInt(grouping: 10, content: "a"), GroupInt(grouping: 20, content: "b"), GroupInt(grouping: 10, content: "c")] print(b.group { $0.grouping }) 

    Este es mi enfoque basado en tuplas para mantener el orden mientras utilizo Swift 4 KeyPath como comparador de grupo:

     extension Sequence{ func group(by:KeyPath) -> [(key:T,values:[Element])]{ return self.reduce([]){(accumulator, element) in var accumulator = accumulator var result :(key:T,values:[Element]) = accumulator.first(where:{ $0.key == element[keyPath:by]}) ?? (key: element[keyPath:by], values:[]) result.values.append(element) if let index = accumulator.index(where: { $0.key == element[keyPath: by]}){ accumulator.remove(at: index) } accumulator.append(result) return accumulator } } } 

    Ejemplo de cómo usarlo:

     struct Company{ let name : String let type : String } struct Employee{ let name : String let surname : String let company: Company } let employees : [Employee] = [...] let companies : [Company] = [...] employees.group(by: \Employee.company.type) // or employees.group(by: \Employee.surname) // or companies.group(by: \Company.type) 

    Oye, si necesitas mantener el orden mientras agrupas los elementos en lugar del diccionario hash, he usado tuplas y he mantenido el orden de la lista durante la agrupación.

     extension Sequence { func zmGroup(by: (Element) -> U) -> [(U,[Element])] { var groupCategorized: [(U,[Element])] = [] for item in self { let groupKey = by(item) guard let index = groupCategorized.index(where: { $0.0 == groupKey }) else { groupCategorized.append((groupKey, [item])); continue } groupCategorized[index].1.append(item) } return groupCategorized } } 

    Tomando una hoja del ejemplo “oisdk” . Extender la solución a objetos grupales en función del nombre de la clase Demostración y enlace del Código fuente .

    Fragmento de código para agrupar según el nombre de la clase:

      func categorise(seq: S) -> [String:[S.Generator.Element]] { var dict: [String:[S.Generator.Element]] = [:] for el in seq { //Assigning Class Name as Key let key = String(el).componentsSeparatedByString(".").last! //Generating a dictionary based on key-- Class Names dict[key] = (dict[key] ?? []) + [el] } return dict } //Grouping the Objects in Array using categorise let categorised = categorise(currentStat) print("Grouped Array :: \(categorised)") //Key from the Array ie, 0 here is Statt class type let key_Statt:String = String(currentStat.objectAtIndex(0)).componentsSeparatedByString(".").last! print("Search Key :: \(key_Statt)") //Accessing Grouped Object using above class type key let arr_Statt = categorised[key_Statt] print("Array Retrieved:: ",arr_Statt) print("Full Dump of Array::") dump(arr_Statt)