Cangjie-SIG/fountain基础模块：base基础功能集合

孔秋宗Mora

1080人浏览 · 2025-08-29 23:15:48

孔秋宗Mora · 2025-08-29 23:15:48 发布

Cangjie-SIG/fountain基础模块：base基础功能集合

【免费下载链接】fountain 一个用于服务器应用开发的综合工具库。 - 零配置文件 - 环境变量和命令行参数配置 - 约定优于配置 - 深刻利用仓颉语言特性 - 只需要开发动态链接库，fboot负责加载、初始化并运行。项目地址: https://gitcode.com/Cangjie-SIG/fountain

还在为服务器应用开发中的基础功能重复造轮子而烦恼吗？fountain的base模块提供了一套完整、高效的基础工具集合，让你专注于业务逻辑而非底层实现。本文将深入解析f_base模块的核心功能和使用方法，助你快速上手这个强大的基础工具库。

基础模块概览

f_base模块是fountain框架的核心基础组件，提供了丰富的基础数据类型扩展、工具类和实用函数，涵盖了：

Result类型处理 - 函数式编程风格的错误处理
Option工具类 - 空值安全处理
比较器和相等器 - 灵活的对比机制
数据类型扩展 - 数字、字符串等基础类型增强
集合工具 - 空集合和大小策略管理
哈希构建 - 高效的哈希计算
线程安全 - 线程本地存储扩展

Result类型：优雅的错误处理

核心枚举定义

public enum Result<T, E> {
    | Ok
    | Ok(T)
    | Err
    | Err(E)
    | NoResult
}

Result类型提供了五种状态，支持无值成功、有值成功、无错误失败、有错误失败和无结果状态。

实用属性方法

// 判断结果状态
result.isOk      // 是否成功
result.isErr     // 是否失败  
result.isNoResult // 是否无结果
result.withValue  // 是否包含值
result.withE      // 是否包含错误

// 获取值或错误
result.result()  // 获取成功值
result.err()     // 获取错误信息

链式操作示例

// 值映射
let mapped = result.mapValue { value => 
    // 转换逻辑
    Result<String, Error>.Ok(value.toString())
}

// 错误映射
let errorMapped = result.mapError { error =>
    // 错误转换逻辑
    Result<String, CustomError>.Err(CustomError.from(error))
}

// 过滤操作
let filtered = result.filterValue { value => value > 0 }
                   .filterError { error => error.isRecoverable }

结果过滤器和映射器

// 复杂过滤
let complexFilter = result.filter()
    .filterOk { value => value.isValid() }
    .filterErr { error => error.isCritical() }
    .filterWithValue()
    .filter()

// 高级映射
let advancedMap = result.mapper()
    .result { value => processValue(value) }
    .error { error => handleError(error) }
    .none { => Result<T, E>.NoResult }
    .map()

Option工具类：空值安全处理

空值检查方法

// 各种空值判断
Options.isEmpty(option)          // 是否为空
Options.isNotEmpty(option)       // 是否非空
Options.isEmptyOrUnit(option)    // 是否为空或Unit
Options.isEmptyOrZero(option)    // 是否为空或零值
Options.isEmptyOrBlank(option)   // 是否为空或空白

类型转换工具

// 安全类型转换
let converted = Options.convert(originalOption) { value =>
    // 转换逻辑
    Some(value.toString())
}

// 带默认值的转换
let withDefault = Options.convert(originalOption, default: "default") { value =>
    Some(value.toString())
}

// 可能抛出异常的转换
let orThrow = Options.convertOrThrow(originalOption) { value =>
    if (value.isValid()) {
        Some(processedValue)
    } else {
        None
    }
}

比较器和相等器：灵活的对比机制

Comparator比较器

// 创建比较器
let intComparator = Comparator.create<Int64>()

// 自定义比较逻辑
let customComparator = Comparator<Person> { p1, p2 =>
    p1.age.compare(p2.age)
}

// 链式比较
let complexComparator = Comparator.comparing<Person, String> { p => p.name }
    .then { p1, p2 => p1.age.compare(p2.age) }
    .then(Comparator.comparing<Person, Int64> { p => p.salary })

// 反向比较
let reversed = comparator.reverse()

Equaler相等器

// 创建相等器
let defaultEqualer = Equaler.create<String>()

// 自定义相等逻辑
let personEqualer = Equaler<Person> { p1, p2 =>
    p1.name == p2.name && p1.age == p2.age
}

// 链式相等判断
let detailedEqualer = Equaler.equalling<Person, String> { p => p.name }
    .then { p1, p2 => p1.age == p2.age }
    .then(Equaler.equalling<Person, String> { p => p.email })

数据类型扩展：增强基础类型功能

数字类型扩展

// 所有数字类型都扩展了丰富功能
let num: Int64 = 42

num.numberOfLeadingZeros()  // 前导零数量
num.isEven                  // 是否为偶数
num.isOdd                   // 是否为奇数
num.toUInt()                // 转换为无符号整数

// 常量属性
Int64.zero    // 0
Int64.one     // 1  
Int64.ten     // 10
Float64.PI    // π
Float64.E     // 自然常数e

字符串处理工具

// 字符串拼接
let joined = stringJoin(["a", "b", "c"], delimiter: ", ", leftPadding: "[", rightPadding: "]")
// 结果: "[a, b, c]"

// 复杂拼接
let complexJoin = stringJoin(users, delimiter: " | ") { user =>
    user.name + " (" + user.age.toString() + ")"
}

集合和工具类

空集合管理

// 空集合常量
EmptyCollections.EMPTY_LIST
EmptyCollections.EMPTY_SET  
EmptyCollections.EMPTY_MAP

// 大小策略
OverSizePolicy.IGNORE      // 忽略超限
OverSizePolicy.THROW       // 抛出异常
OverSizePolicy.TRUNCATE    // 截断处理

哈希构建器

let builder = HashBuilder()
builder.append("key1", value1)
builder.append("key2", value2)
builder.append("key3", value3)

let hash = builder.build()  // 生成最终哈希值

实际应用场景

场景1：API响应处理

func handleApiResponse(): Result<Data, ApiError> {
    let response = fetchData()
    
    return response.mapper()
        .result { data => 
            if (data.isValid()) {
                Result.Ok(processData(data))
            } else {
                Result.Err(ApiError.INVALID_DATA)
            }
        }
        .error { error =>
            Result.Err(ApiError.fromNetworkError(error))
        }
        .map()
}

场景2：数据验证链

func validateUserInput(input: Option<String>): Result<User, ValidationError> {
    // 空值检查
    if (Options.isEmptyOrBlank(input)) {
        return Result.Err(ValidationError.EMPTY_INPUT)
    }
    
    let username = Options.convertOrThrow(input) { value =>
        if (value.length() >= 3) {
            Some(value)
        } else {
            None
        }
    }
    
    return Result.Ok(User(username))
}

场景3：排序和去重

// 复杂排序
let sortedUsers = users.sorted(Comparator
    .comparing<User, String> { u => u.lastName }
    .then(Comparator.comparing<User, String> { u => u.firstName })
    .then(Comparator.comparing<User, Int64> { u => u.age }.reverse()))

// 自定义去重
let uniqueUsers = users.distinct(Equaler
    .equalling<User, String> { u => u.email }
    .then(Equaler.equalling<User, String> { u => u.phone }))