算法結構 - 搜索過(guò)濾

搜索算法

1. 多條件搜索算法

// 高級搜索算法
export function advancedSearch(data, filters) {
    if (!data || !Array.isArray(data)) return [];
    if (!filters || filters.length === 0) return data;
    
    return data.filter(item => {
        return filters.every(filter => {
            if (!filter.field || !filter.operator || filter.value === undefined) {
                return true;
            }
            
            const itemValue = item[filter.field];
            
            switch (filter.operator) {
                case '=':
                    return itemValue == filter.value;
                case '!=':
                    return itemValue != filter.value;
                case '>':
                    return itemValue > filter.value;
                case '<':
                    return itemValue < filter.value;
                case '>=':
                    return itemValue >= filter.value;
                case '<=':
                    return itemValue <= filter.value;
                case 'like':
                    return String(itemValue).toLowerCase().includes(String(filter.value).toLowerCase());
                case 'in':
                    return Array.isArray(filter.value) ? filter.value.includes(itemValue) : false;
                case 'not in':
                    return Array.isArray(filter.value) ? !filter.value.includes(itemValue) : true;
                case 'between':
                    return Array.isArray(filter.value) && filter.value.length === 2 
                        ? itemValue >= filter.value[0] && itemValue <= filter.value[1]
                        : true;
                default:
                    return true;
            }
        });
    });
}

// 關(guān)鍵字搜索算法
export function keywordSearch(data, keyword, searchFields) {
    if (!data || !Array.isArray(data)) return [];
    if (!keyword || keyword.trim() === '') return data;
    
    const searchTerm = keyword.toLowerCase().trim();
    
    return data.filter(item => {
        // 如果沒(méi)有指定搜索字段，搜索所有字符串字段
        const fieldsToSearch = searchFields || 
            Object.keys(item).filter(key => typeof item[key] === 'string');
        
        return fieldsToSearch.some(field => {
            const fieldValue = String(item[field] || '').toLowerCase();
            return fieldValue.includes(searchTerm);
        });
    });
}

2. 范圍搜索算法

// 日期范圍搜索
export function dateRangeSearch(data, dateField, startDate, endDate) {
    if (!data || !Array.isArray(data)) return [];
    
    return data.filter(item => {
        const itemDate = new Date(item[dateField]);
        const start = startDate ? new Date(startDate) : null;
        const end = endDate ? new Date(endDate) : null;
        
        if (start && itemDate < start) return false;
        if (end && itemDate > end) return false;
        
        return true;
    });
}

// 數值范圍搜索
export function numberRangeSearch(data, numberField, min, max) {
    if (!data || !Array.isArray(data)) return [];
    
    return data.filter(item => {
        const value = parseFloat(item[numberField]);
        if (isNaN(value)) return false;
        
        if (min !== null && min !== undefined && value < min) return false;
        if (max !== null && max !== undefined && value > max) return false;
        
        return true;
    });
}

過(guò)濾算法

1. 數據去重算法

// 根據指定字段去重
export function uniqueByField(data, field) {
    if (!data || !Array.isArray(data)) return [];
    
    const seen = new Set();
    return data.filter(item => {
        const value = item[field];
        if (seen.has(value)) {
            return false;
        }
        seen.add(value);
        return true;
    });
}

// 多字段聯(lián)合去重
export function uniqueByFields(data, fields) {
    if (!data || !Array.isArray(data)) return [];
    if (!fields || !Array.isArray(fields)) return data;
    
    const seen = new Set();
    return data.filter(item => {
        const key = fields.map(field => item[field]).join('|');
        if (seen.has(key)) {
            return false;
        }
        seen.add(key);
        return true;
    });
}

2. 數據分組算法

// 按字段分組
export function groupByField(data, field) {
    if (!data || !Array.isArray(data)) return {};
    
    return data.reduce((groups, item) => {
        const key = item[field];
        if (!groups[key]) {
            groups[key] = [];
        }
        groups[key].push(item);
        return groups;
    }, {});
}

// 多字段分組
export function groupByFields(data, fields) {
    if (!data || !Array.isArray(data)) return {};
    if (!fields || !Array.isArray(fields)) return { '': data };
    
    return data.reduce((groups, item) => {
        const key = fields.map(field => item[field]).join('|');
        if (!groups[key]) {
            groups[key] = [];
        }
        groups[key].push(item);
        return groups;
    }, {});
}

排序算法

1. 基礎排序算法

// 數據排序算法
export function sortData(data, sortField, sortOrder = 'asc') {
    if (!data || !Array.isArray(data)) return [];
    
    return [...data].sort((a, b) => {
        const aValue = a[sortField];
        const bValue = b[sortField];
        
        // 處理空值
        if (aValue === null || aValue === undefined) return sortOrder === 'asc' ? 1 : -1;
        if (bValue === null || bValue === undefined) return sortOrder === 'asc' ? -1 : 1;
        
        // 數值比較
        if (typeof aValue === 'number' && typeof bValue === 'number') {
            return sortOrder === 'asc' ? aValue - bValue : bValue - aValue;
        }
        
        // 字符串比較
        const aStr = String(aValue);
        const bStr = String(bValue);
        
        return sortOrder === 'asc' 
            ? aStr.localeCompare(bStr)
            : bStr.localeCompare(aStr);
    });
}

2. 多字段排序

// 多字段排序
export function multiSortData(data, sortConfigs) {
    if (!data || !Array.isArray(data)) return [];
    if (!sortConfigs || !Array.isArray(sortConfigs)) return data;
    
    return [...data].sort((a, b) => {
        for (const config of sortConfigs) {
            const { field, order = 'asc' } = config;
            const aValue = a[field];
            const bValue = b[field];
            
            let comparison = 0;
            
            // 處理空值
            if (aValue === null || aValue === undefined) {
                comparison = order === 'asc' ? 1 : -1;
            } else if (bValue === null || bValue === undefined) {
                comparison = order === 'asc' ? -1 : 1;
            } else if (typeof aValue === 'number' && typeof bValue === 'number') {
                comparison = aValue - bValue;
            } else {
                comparison = String(aValue).localeCompare(String(bValue));
            }
            
            if (comparison !== 0) {
                return order === 'asc' ? comparison : -comparison;
            }
        }
        
        return 0;
    });
}

分頁(yè)算法

1. 客戶(hù)端分頁(yè)算法

// 客戶(hù)端分頁(yè)算法
export function paginateData(data, currentPage, pageSize) {
    if (!data || !Array.isArray(data)) {
        return {
            data: [],
            total: 0,
            pageCount: 0
        };
    }
    
    const total = data.length;
    const pageCount = Math.ceil(total / pageSize);
    
    // 計算起始索引
    const startIndex = (currentPage - 1) * pageSize;
    const endIndex = Math.min(startIndex + pageSize, total);
    
    // 獲取當前頁(yè)數據
    const currentPageData = data.slice(startIndex, endIndex);
    
    return {
        data: currentPageData,
        total: total,
        pageCount: pageCount,
        currentPage: currentPage,
        pageSize: pageSize
    };
}

這些搜索過(guò)濾算法為應用提供了強大的數據查詢(xún)和處理能力，支持復雜的搜索條件和高效的數據操作。