HarmonyOS Next 函数式编程与闭包在集合操作中的实战应用

本文致力于聚焦HarmonyOS Next中函数式编程与闭包在集合操作中的具体实践，通过代码示例解析如何利用闭包实现高效的数据处理逻辑，避免涉及未提及特性。

一、集合过滤与转换：闭包的动态条件捕获

在处理数组、列表等集合数据时，闭包可动态捕获过滤条件或转换规则，将业务逻辑与数据操作分离，提升代码复用性。

1.1 动态过滤集合元素

通过闭包工厂函数createFilter封装过滤逻辑，允许运行时传入不同的筛选条件。

// 闭包工厂：生成泛型过滤函数  
func createFilter<T>(predicate: (T) -> Bool): (Array<T>) -> Array<T> {  
  return { array in array.filter(predicate) }  
}  

// 业务场景：筛选字符串数组中的长文本（长度>5）  
let texts = ["apple", "banana", "cherry", "date"]  
let longTextFilter = createFilter { $0.length > 5 }  
let result = longTextFilter(texts) // 输出: ["banana", "cherry"]  

关键点：

• predicate闭包参数负责具体筛选逻辑，createFilter返回的闭包负责执行过滤；
• 支持动态切换条件（如从长度过滤切换为关键词过滤），无需修改过滤执行逻辑。

1.2 类型转换与映射

利用闭包实现集合元素的类型转换，结合流操作符|>构建处理管道。

// 字符串转整数数组（忽略无效值）  
let stringNumbers = ["1", "2", "three", "4"]  
let toInt = { (s: String) -> Int64? in Int64(s) } // 闭包处理类型转换  
let numbers = stringNumbers  
  |> map(toInt) // 映射为可选整数  
  |> filter { $0 != nil } // 过滤空值  
  |> map { $0! } // 解包可选值  

// 输出: [1, 2, 4]  

优势：

• 每一步转换由独立闭包完成，逻辑清晰且可复用；
• |>操作符使数据流向直观，便于调试和扩展。

二、集合排序与去重：纯函数与闭包的协同

纯函数确保排序规则的确定性，闭包则负责捕获动态排序参数，两者结合实现灵活的集合排序。

2.1 自定义排序规则

通过闭包传递排序逻辑，支持运行时调整排序策略（如升序、降序、自定义字段排序）。

// 纯函数：通用排序器（接受比较闭包）  
func sort<T>(array: Array<T>, comparator: (T, T) -> Bool): Array<T> {  
  return array.sorted(by: comparator)  
}  

// 业务场景：按字符串长度降序排序  
let fruits = ["apple", "grape", "banana", "pear"]  
let sortByLength = sort(comparator: { $0.length > $1.length })  
let sortedFruits = sortByLength(fruits) // 输出: ["banana", "grape", "apple", "pear"]  

设计要点：

• comparator闭包定义具体比较逻辑，sort函数专注于排序实现；
• 支持复杂排序（如多级条件），只需修改闭包内的比较规则。

2.2 去重逻辑的闭包封装

利用闭包捕获集合元素的唯一性判断规则，实现泛型去重功能。

// 纯函数：基于自定义相等性判断的去重  
func distinct<T>(array: Array<T>, isEqual: (T, T) -> Bool): Array<T> {  
  var uniqueItems = [T]()  
  for item in array {  
    if !uniqueItems.contains(where: { isEqual($0, item) }) {  
      uniqueItems.append(item)  
    }  
  }  
  return uniqueItems  
}  

// 场景：去重自定义对象（按ID判断相等性）  
struct User {  
  var id: Int64  
  var name: String  
}  

let users = [User(id: 1, name: "Alice"), User(id: 2, name: "Bob"), User(id: 1, name: "Alice")]  
let distinctUsers = distinct(users, isEqual: { $0.id == $1.id }) // 输出: [User(id:1), User(id:2)]  

关键逻辑：

• isEqual闭包定义对象相等性规则，解耦去重逻辑与具体类型；
• 适用于无法直接使用Equatable协议的复杂类型。

三、集合归约与聚合：闭包的状态累积

归约（Reduce）操作通过闭包累积集合元素为单一结果，闭包在此过程中负责状态更新逻辑。

3.1 数值聚合计算

使用闭包定义累积逻辑，实现求和、求积等操作。

// 计算数组元素平方和  
let numbers = [1, 2, 3, 4]  
let sumOfSquares = numbers.reduce(0) { acc, num in  
  acc + num * num // 闭包累积平方值  
} // 输出: 30（1+4+9+16）  

简洁性体现：

• 闭包参数acc为累积状态，num为当前元素，逻辑直接明了；
• 可轻松扩展为其他聚合逻辑（如求最大值、平均值）。

3.2 复杂对象聚合

对自定义对象集合进行分组、统计等操作，闭包负责提取特征值。

// 统计订单总金额（订单列表包含折扣信息）  
struct Order {  
  var quantity: Int64  
  var price: Float64  
  var discount: Float64  
}  

let orders = [Order(quantity: 2, price: 10.0, discount: 0.1), Order(quantity: 1, price: 15.0, discount: 0.2)]  
let totalAmount = orders.reduce(0.0) { acc, order in  
  let itemPrice = order.price * (1 - order.discount) * Float64(order.quantity)  
  return acc + itemPrice // 闭包计算单个订单金额并累加  
} // 输出: (2*10*0.9)+(1*15*0.8)=18+12=30.0  

优势分析：

• 闭包内可包含复杂业务逻辑（如折扣计算），保持归约操作的通用性；
• 避免显式循环遍历，代码更符合函数式编程范式。

四、性能优化与注意事项

4.1 避免闭包内的不必要操作

将不变计算移出闭包，减少循环中的重复处理。

// 反例：闭包内重复计算阈值  
let threshold = 100  
let data = [1, 2, 3, ..., 1000]  
let filtered = data.filter { $0 * 2 > threshold } // 每次调用闭包均计算threshold值  

// 优化：提前计算阈值倍数  
let doubleThreshold = threshold * 2  
let filtered = data.filter { $0 > doubleThreshold } // 闭包内仅做比较操作  

4.2 优先使用内置高阶函数

仓颉语言的集合类型（如Array）已内置filter、map、reduce等高阶函数，其性能经过优化，应优先使用而非手动实现。

// 推荐：使用内置filter而非自定义循环  
let evenNumbers = numbers.filter { $0 % 2 == 0 }  

// 不推荐：手动实现过滤逻辑  
let evenNumbers = [Int64]()  
for num in numbers { if num % 2 == 0 { evenNumbers.append(num) } }  

五、总结：函数式闭包在集合操作中的核心价值

通过函数式编程与闭包的整合，开发者可在鸿蒙应用中实现：

• 声明式数据处理：通过闭包链清晰表达数据转换流程；
• 逻辑复用与解耦：闭包封装独立业务规则，支持动态替换；
• 性能与可读性平衡：利用内置高阶函数与闭包组合，避免冗余代码。

我们在实际开发中，建议遵循「闭包单一职责」原则，每个闭包专注于完成一个数据处理步骤，通过流操作符或函数组合形成完整处理管道，确保代码简洁高效。