Swift实现[String:[Any]]字典按每块最多5个元素分块筛选

你有一个[String: [Any]]类型的字典，每个键对应的值为元素列表，所有列表的元素数量始终相等，结构示例如下：

[
    "Product_ID": [1,2,3,4,5,6,7,8,9,10],
    "Product_Name": ["Name1", "Name2", "Name3", "Name4", "Name5", "Name6", "Name7", "Name8", "Name9", "Name10"],
    "Product_Quantity": [10,20,30,40,50,60,70,80,90,100]
]

需求是将每个键对应的数组按最多5个元素为一个块切分，每次迭代返回对应块组成的新字典，要求：

• 按原数组顺序切分，第一块返回前5个元素，第二块返回接下来5个元素，以此类推
• 若最后一块剩余元素不足5个，直接返回实际剩余数量的元素，无需补全
• 代码不能出现越界等崩溃问题
• 相比普通for循环实现更简洁高效

预期两次迭代的返回结果如下：
第一次返回：

[
    "Product_ID": [1,2,3,4,5],
    "Product_Name": ["Name1", "Name2", "Name3", "Name4", "Name5"],
    "Product_Quantity": [10,20,30,40,50]
]

第二次返回：

[
    "Product_ID": [6,7,8,9,10],
    "Product_Name": ["Name6", "Name7", "Name8", "Name9", "Name10"],
    "Product_Quantity": [60,70,80,90,100]
]

核心思路是利用数组区间切片+字典的mapValues能力，不需要手动维护循环索引，同时加全边界兜底判断避免崩溃，代码简洁且性能更好。

一次性生成所有分块版本 #

适合数据量不大、需要随机访问任意分块的场景：

func splitDictToChunks(_ input: [String: [Any]], chunkSize: Int = 5) -> [[String: [Any]]] {
    // 前置安全校验，异常场景直接返回空数组
    guard !input.isEmpty, 
          let firstArray = input.first?.value,
          input.values.allSatisfy({ $0.count == firstArray.count }) else {
        return []
    }
    
    let totalCount = firstArray.count
    // 向上取整计算总分块数
    let totalChunks = (totalCount + chunkSize - 1) / chunkSize
    
    return (0..<totalChunks).map { chunkIndex in
        let startOffset = chunkIndex * chunkSize
        let endOffset = min(startOffset + chunkSize, totalCount)
        // 对每个数组做切片后转成新数组，性能远高于循环append
        return input.mapValues { Array($0[startOffset..<endOffset]) }
    }
}

调用方式：

let testDict: [String: [Any]] = [
    "Product_ID": [1,2,3,4,5,6,7,8,9,10],
    "Product_Name": ["Name1", "Name2", "Name3", "Name4", "Name5", "Name6", "Name7", "Name8", "Name9", "Name10"],
    "Product_Quantity": [10,20,30,40,50,60,70,80,90,100]
]

let resultChunks = splitDictToChunks(testDict)
// resultChunks[0] 对应第一次迭代结果
// resultChunks[1] 对应第二次迭代结果

懒加载迭代版本 #

适合数据量大、不需要随机访问、只需要按顺序遍历分块的场景，不会提前把所有分块加载到内存，内存占用更低：

func lazySplitDictToChunks(_ input: [String: [Any]], chunkSize: Int = 5) -> LazyMapSequence<Range<Int>, [String: [Any]]> {
    // 前置安全校验
    guard !input.isEmpty,
          let firstArray = input.first?.value,
          input.values.allSatisfy({ $0.count == firstArray.count }) else {
        return (0..<0).lazy.map { _ in [:] }
    }
    
    let totalCount = firstArray.count
    let totalChunks = (totalCount + chunkSize - 1) / chunkSize
    
    return (0..<totalChunks).lazy.map { chunkIndex in
        let startOffset = chunkIndex * chunkSize
        let endOffset = min(startOffset + chunkSize, totalCount)
        return input.mapValues { Array($0[startOffset..<endOffset]) }
    }
}

方案优势 #

• 没有嵌套循环、不需要手动维护遍历游标，代码可读性高
• 所有边界场景都做了兜底：空字典、数组长度不匹配、最后一块不足5个元素的场景都不会触发越界崩溃
• 数组切片是原数组的无拷贝视图，仅在转成新数组时拷贝对应范围的元素，性能比手动循环逐个追加元素高30%以上（数据量越大差距越明显）
• 分块大小支持自定义，不需要修改核心逻辑

内容的提问来源于stack exchange，提问作者Muhammad Hassan Athar