通过某些属性组合数组的元素 [英] Group elements of an array by some property

问题描述

我有一个数组的对象，具有属性 date 。

我想要的是创建数组每个数组将包含相同日期的对象。

我明白，我需要像 .filter 过滤对象，然后 .map 将每个东西添加到数组。

但是如何告诉 .map 我想要为筛选对象中的每个组分别设置一个数组，并且该数组必须添加到全局数组中，并且如何告诉 .filter 我想要同一个日期的对象？

解决方案

提取一步，你想要的是某个属性组数组的元素。您可以让地图为您进行分组：

 协议可分组{
关联类型GroupingType：Hashable 
 var grouping：GroupingType {get set} 
} 
 
 extension Array其中Element：Groupable {
 typealias GroupingType = Element.GroupingType 
 
 func grouping （） - > [[Element]] {
 var groups = [GroupingType：[Element]]（）
 
 for self for $ {
 if let _ = groups [element.grouping] { 
 groups [element.grouping] !. append（element）
} else {
 groups [element.grouping] = [element] 
} 
} 
 
返回数组< [Element]>（groups.values）
} 
} 
  

注意，这个分组是稳定，这是按照出现的顺序出现的组，而且在组内，各个元素按照与原始数组相同的顺序显示。 p>

使用示例

我将给出一个使用整数的例子;应该清楚如何使用 T 的任何（可散列）类型，包括 Date 。

  struct GroupInt：可分组{
 typealias GroupingType = Int 
 var grouping：Int 
 var content：String 
} 
 
 var a = [GroupInt（grouping：1，content：a），
 GroupInt（grouping：2，content：b），
 GroupInt分组：1，内容：c）] 
 
 print（a.grouped（））
 //> [GroupInt（grouping：2，content：b）]，[GroupInt（grouping：1，content：a），GroupInt（grouping：1，content：c）]] 
  




I have an array of objects with property date.

What I want is to create array of arrays where each array will contain objects with the same date.

I understand, that I need something like .filter to filter objects, and then .map to add every thing to array.

But how to tell .map that I want separate array for each group from filtered objects and that this array must be added to "global" array and how to tell .filter that I want objects with the same date ?

解决方案

Abstracting one step, what you want is to group elements of an array by a certain property. You can let a map do the grouping for you like so:

protocol Groupable {
    associatedtype GroupingType: Hashable
    var grouping: GroupingType { get set }
}

extension Array where Element: Groupable  {
    typealias GroupingType = Element.GroupingType

    func grouped() -> [[Element]] {
        var groups = [GroupingType: [Element]]()

        for element in self {
            if let _ = groups[element.grouping] {
                groups[element.grouping]!.append(element)
            } else {
                groups[element.grouping] = [element]
            }
        }

        return Array<[Element]>(groups.values)
    }
}

Note that this grouping is stable, that is groups appear in order of appearance, and inside the groups the individual elements appear in the same order as in the original array.

Usage Example

I'll give an example using integers; it should be clear how to use any (hashable) type for T, including Date.

struct GroupInt: Groupable {
    typealias GroupingType = Int
    var grouping: Int
    var content: String
}

var a = [GroupInt(grouping: 1, content: "a"),
         GroupInt(grouping: 2, content: "b") ,
         GroupInt(grouping: 1, content: "c")]

print(a.grouped())
// > [[GroupInt(grouping: 2, content: "b")], [GroupInt(grouping: 1, content: "a"), GroupInt(grouping: 1, content: "c")]]

这篇关于通过某些属性组合数组的元素的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！