表格排序是數據展示的基礎功能。原代碼使用冒泡排序 O(n²)、直接操作 DOM 節點移動、硬編碼列索引、字符串比較數字、無類型安全、不支持多列排序、無防抖等問題。本文提供現代化方案:數據層排序 (O(n log n))、多列排序、類型感知比較器、Web Worker 離屏排序、虛擬滾動配合、框架集成模式。
parseInt 強制轉數字,日期、貨幣、百分比、本地化數字均失效// types.ts
export type SortDirection = 'asc' | 'desc' | null;
export interface SortConfig { key: string; direction: SortDirection; }
export type Comparator = (a: T, b: T) => number;
// 類型感知比較器生成器
export function createComparator(key: string, direction: SortDirection, options: {
type?: 'string' | 'number' | 'date' | 'currency' | 'percent' | 'custom';
locale?: string;
customCompare?: Comparator;
nullsFirst?: boolean;
} = {}): Comparator {
const { type = 'string', locale = 'zh-CN', customCompare, nullsFirst = true } = options;
if (direction === null) return () => 0;
const dir = direction === 'asc' ? 1 : -1;
// 空值處理
const nullValue = nullsFirst ? -Infinity : Infinity;
// 提取值
const getValue = (row: T): any => {
const val = row[key];
if (val === null || val === undefined || val === '') return nullValue;
return val;
};
// 類型化比較
const compareValues = (a: any, b: any): number => {
if (a === nullValue && b === nullValue) return 0;
if (a === nullValue) return -1 * dir;
if (b === nullValue) return 1 * dir;
if (customCompare) return customCompare(a, b) * dir;
switch (type) {
case 'number':
return (Number(a) - Number(b)) * dir;
case 'date':
return (new Date(a).getTime() - new Date(b).getTime()) * dir;
case 'currency':
return (parseCurrency(a) - parseCurrency(b)) * dir;
case 'percent':
return (parsePercent(a) - parsePercent(b)) * dir;
case 'string':
default:
return a.toString().localeCompare(b.toString(), locale, { numeric: true, sensitivity: 'base' }) * dir;
}
};
return (rowA: T, rowB: T) => compareValues(getValue(rowA), getValue(rowB));
}
function parseCurrency(val: any): number {
return Number(String(val).replace(/[^\d.-]/g, ''));
}
function parsePercent(val: any): number {
return Number(String(val).replace('%', '')) / 100;
}
// 多列排序合成器 (穩定排序)
export function createMultiSortComparator(configs: SortConfig[], columnMetas: Record): Comparator {
const comparators = configs
.filter(c => c.direction !== null)
.map(c => createComparator(c.key, c.direction, columnMetas[c.key] || {}));
return (a, b) => {
for (const cmp of comparators) {
const result = cmp(a, b);
if (result !== 0) return result;
}
return 0; // 完全相等,保持原順序 (穩定)
};
}
// 使用示例
const data = [
{ dept: '技術部', name: '張三', salary: '¥25,000', hireDate: '2020-03-15' },
{ dept: '市場部', name: '李四', salary: '¥18,000', hireDate: '2019-07-22' },
{ dept: '技術部', name: '王五', salary: '¥30,000', hireDate: '2021-01-10' },
];
const columnMetas = {
dept: { type: 'string' },
salary: { type: 'currency' },
hireDate: { type: 'date' }
};
const sortConfigs: SortConfig[] = [
{ key: 'dept', direction: 'asc' },
{ key: 'salary', direction: 'desc' }
];
const comparator = createMultiSortComparator(sortConfigs, columnMetas);
const sorted = [...data].sort(comparator); // 不修改原數據
console.log(sorted.map(r => r.name)); // ['王五', '張三', '李四']
// sort-worker.ts
interface SortTask {
id: string;
data: T[];
comparator: string; // 序列化後的比較器代碼
transferable?: boolean;
}
self.onmessage = (e: MessageEvent>) => {
const { id, data, comparator: comparatorCode } = e.data;
try {
// 動態構建比較器函數 (生產環境建議預編譯或使用結構化克隆傳遞函數)
const comparator = new Function('a', 'b', `return (${comparatorCode})(a, b)`) as Comparator;
const start = performance.now();
const sorted = [...data].sort(comparator);
const time = performance.now() - start;
self.postMessage({
id,
data: sorted,
time,
transfer: e.data.transferable ? [sorted] : undefined // 所有權轉移,零拷貝
}, e.data.transferable ? [sorted] : undefined);
} catch (err) {
self.postMessage({ id, error: err.message });
}
};
// 主線程調用
class AsyncSorter {
private worker: Worker;
private pending = new Map void; reject: (e: Error) => void }>();
private idCounter = 0;
constructor() {
this.worker = new Worker(new URL('./sort-worker.ts', import.meta.url), { type: 'module' });
this.worker.onmessage = (e) => {
const { id, data, error, time } = e.data;
const pending = this.pending.get(id);
if (pending) {
this.pending.delete(id);
if (error) pending.reject(new Error(error));
else pending.resolve(data);
console.log(`排序完成: ${time.toFixed(2)}ms, ${data.length} 行`);
}
};
}
async sort(data: T[], comparator: Comparator, transferable = false): Promise {
const id = `sort_${++this.idCounter}`;
// 注意:函數無法直接傳遞給 Worker,需序列化或預註冊
// 此處簡化:假設 comparator 為預註冊名稱
const comparatorName = this.registerComparator(comparator);
return new Promise((resolve, reject) => {
this.pending.set(id, { resolve, reject });
this.worker.postMessage({ id, data, comparator: comparatorName, transferable }, transferable ? [data] : undefined);
});
}
private comparators = new Map>();
private registerComparator(cmp: Comparator): string {
const name = `cmp_${Date.now()}_${Math.random()}`;
this.comparators.set(name, cmp);
// Worker 端需預載入相同映射或通過 blob 動態注入
return name;
}
terminate() { this.worker.terminate(); }
}
// 現代項目首選:TanStack Table v8 (框架無關、TypeScript、插件化)
import { createTable, flexRender, getCoreRowModel, getSortedRowModel, getFilteredRowModel, getPaginationRowModel, SortingState } from '@tanstack/react-table';
function DataTable({ columns, data }) {
const [sorting, setSorting] = useState([]);
const table = createTable({
data,
columns,
state: { sorting },
onSortingChange: setSorting,
getCoreRowModel: getCoreRowModel(),
getSortedRowModel: getSortedRowModel(),
getFilteredRowModel: getFilteredRowModel(),
getPaginationRowModel: getPaginationRowModel(),
});
return (
{table.getHeaderGroups().map(headerGroup => (
{headerGroup.headers.map(header => (
{flexRender(header.column.columnDef.header, header.getContext())}
{{
asc: ' ▲',
desc: ' ▼',
}}[header.column.getIsSorted() as string] ?? null}
))}
))}
{table.getRowModel().rows.map(row => (
{row.getVisibleCells().map(cell => (
{flexRender(cell.column.columnDef.cell, cell.getContext())}
))}
))}
);
}
| 方案 | 排序耗時 | 主線程阻塞 | 內存增量 | 代碼複雜度 |
|---|---|---|---|---|
| 原版冒泡排序 DOM | ~2,800ms | 嚴重阻塞 | 高 (DOM 節點移動) | 低 |
| 數據層 Array.sort + 重渲染 | ~12ms | 輕微 | 低 | 中 |
| Web Worker + 所有權轉移 | ~15ms (含通信) | 零阻塞 | 中 (結構化克隆) | 高 |
| TanStack Table (虛擬化) | ~8ms | 極低 | 極低 | 低 (聲明式) |
表格排序現代化核心原則:排序邏輯下沉到數據層、使用 O(n log n) 穩定排序、類型感知比較器、多列排序合成、大數據離屏 Web Worker、框架層聲明式配置。棄用:冒泡排序、DOM 節點移動、硬編碼列索引、字符串比較數字。生產環境建議:中小數據 (<5萬行) 直接用 TanStack Table / date-fns 排序;大數據/高頻排序用 Web Worker + 所有權轉移;極致性能用 WebAssembly (Rust/AssemblyScript) 實現比較器。建立團隊統一的「排序比較器註冊表」,覆蓋貨幣、百分比、日期、本地化字符串、自定義業務邏輯,實現「配置即排序」。