179.HarmonyOS NEXT系列教程之列表交换组件工具类设计

温馨提示：本篇博客的详细代码已发布到 git : https://gitcode.com/nutpi/HarmonyosNext 可以下载运行哦！

HarmonyOS NEXT系列教程之列表交换组件工具类设计

效果演示

1. 工具类架构设计

1.1 基础工具类结构

// 工具类基础接口
interface Utility {
    name: string;
    version: string;
    description: string;
}

// 工具类注册中心
class UtilityRegistry {
    private static utilities: Map<string, Utility> = new Map();

    static register(utility: Utility): void {
        this.utilities.set(utility.name, utility);
    }

    static get(name: string): Utility | undefined {
        return this.utilities.get(name);
    }
}

1.2 工具类管理器

class UtilityManager {
    private static instance: UtilityManager;
    private utilities: Map<string, any> = new Map();

    static getInstance(): UtilityManager {
        if (!this.instance) {
            this.instance = new UtilityManager();
        }
        return this.instance;
    }

    registerUtility(name: string, utility: any): void {
        this.utilities.set(name, utility);
    }

    getUtility(name: string): any {
        return this.utilities.get(name);
    }
}

2. 数据处理工具

2.1 数据转换工具

class DataConverter {
    // 对象转数组
    static objectToArray<T>(obj: Record<string, T>): T[] {
        return Object.values(obj);
    }

    // 数组转对象
    static arrayToObject<T>(
        array: T[], 
        keyField: keyof T
    ): Record<string, T> {
        return array.reduce((acc, item) => {
            acc[String(item[keyField])] = item;
            return acc;
        }, {});
    }

    // 深度克隆
    static deepClone<T>(data: T): T {
        return JSON.parse(JSON.stringify(data));
    }
}

2.2 数据过滤工具

class DataFilter {
    // 过滤数组
    static filterArray<T>(
        array: T[],
        predicate: (item: T) => boolean
    ): T[] {
        return array.filter(predicate);
    }

    // 排序数组
    static sortArray<T>(
        array: T[],
        compareFn: (a: T, b: T) => number
    ): T[] {
        return [...array].sort(compareFn);
    }

    // 去重
    static unique<T>(array: T[]): T[] {
        return Array.from(new Set(array));
    }
}

3. 动画工具类

3.1 动画创建器

class AnimationCreator {
    // 创建弹性动画
    static createSpringAnimation(params: SpringAnimationParams): Animation {
        return {
            curve: curves.interpolatingSpring(
                params.velocity,
                params.mass,
                params.stiffness,
                params.damping
            ),
            delay: params.delay || 0,
            duration: params.duration || 300,
            iterations: params.iterations || 1,
            playMode: params.playMode || PlayMode.Normal
        };
    }

    // 创建过渡动画
    static createTransitionAnimation(params: TransitionParams): Animation {
        return {
            curve: params.curve || Curve.EaseInOut,
            delay: params.delay || 0,
            duration: params.duration || 300
        };
    }
}

3.2 动画辅助工具

class AnimationHelper {
    // 计算动画进度
    static calculateProgress(
        current: number,
        start: number,
        end: number
    ): number {
        return (current - start) / (end - start);
    }

    // 插值计算
    static interpolate(
        progress: number,
        start: number,
        end: number
    ): number {
        return start + (end - start) * progress;
    }
}

4. 验证工具类

4.1 数据验证器

class DataValidator {
    // 验证必填字段
    static required(value: any): boolean {
        return value !== undefined && value !== null && value !== '';
    }

    // 验证数字范围
    static numberRange(
        value: number,
        min: number,
        max: number
    ): boolean {
        return value >= min && value <= max;
    }

    // 验证字符串长度
    static stringLength(
        value: string,
        minLength: number,
        maxLength: number
    ): boolean {
        return value.length >= minLength && value.length <= maxLength;
    }
}

4.2 类型检查器

class TypeChecker {
    // 检查是否为数字
    static isNumber(value: any): boolean {
        return typeof value === 'number' && !isNaN(value);
    }

    // 检查是否为字符串
    static isString(value: any): boolean {
        return typeof value === 'string';
    }

    // 检查是否为对象
    static isObject(value: any): boolean {
        return value !== null && typeof value === 'object';
    }
}

5. 格式化工具

5.1 文本格式化

class TextFormatter {
    // 格式化日期
    static formatDate(date: Date, format: string): string {
        // 日期格式化逻辑
        return formattedDate;
    }

    // 格式化数字
    static formatNumber(
        number: number,
        decimals: number = 2
    ): string {
        return number.toFixed(decimals);
    }

    // 格式化金额
    static formatCurrency(
        amount: number,
        currency: string = 'CNY'
    ): string {
        return new Intl.NumberFormat('zh-CN', {
            style: 'currency',
            currency
        }).format(amount);
    }
}

5.2 数据格式化

class DataFormatter {
    // 格式化列表数据
    static formatListData<T>(
        data: T[],
        formatter: (item: T) => any
    ): any[] {
        return data.map(formatter);
    }

    // 格式化树形数据
    static formatTreeData<T>(
        data: T[],
        childrenKey: string = 'children'
    ): any[] {
        return data.map(item => ({
            ...item,
            [childrenKey]: item[childrenKey] ? 
                this.formatTreeData(item[childrenKey]) : 
                []
        }));
    }
}

6. 日志工具类

6.1 日志记录器

class Logger {
    private static readonly LOG_LEVELS = {
        DEBUG: 0,
        INFO: 1,
        WARN: 2,
        ERROR: 3
    };

    static debug(message: string, ...args: any[]): void {
        this.log('DEBUG', message, args);
    }

    static info(message: string, ...args: any[]): void {
        this.log('INFO', message, args);
    }

    static warn(message: string, ...args: any[]): void {
        this.log('WARN', message, args);
    }

    static error(message: string, ...args: any[]): void {
        this.log('ERROR', message, args);
    }

    private static log(
        level: string,
        message: string,
        args: any[]
    ): void {
        const logEntry = {
            timestamp: new Date().toISOString(),
            level,
            message,
            args
        };
        console.log(JSON.stringify(logEntry));
    }
}

6.2 性能日志

class PerformanceLogger {
    private static timers: Map<string, number> = new Map();

    // 开始计时
    static start(label: string): void {
        this.timers.set(label, performance.now());
    }

    // 结束计时
    static end(label: string): void {
        const startTime = this.timers.get(label);
        if (startTime) {
            const duration = performance.now() - startTime;
            Logger.info(`Performance [${label}]: ${duration}ms`);
            this.timers.delete(label);
        }
    }
}

7. 最佳实践

7.1 工具类设计原则

1. 单一职责原则
2. 功能模块化
3. 易于扩展
4. 高复用性

7.2 使用建议

1. 合理组织工具类
2. 提供完整文档
3. 实现错误处理
4. 优化性能表现

8. 小结

本篇教程详细介绍了：

1. 工具类的架构设计
2. 各类工具的实现方法
3. 数据处理的工具函数
4. 格式化工具的开发
5. 日志工具的实现

下一篇将介绍常量配置管理的实现。