鸿蒙PC上的 ArkUI 跨平台实战:用回溯 VM 与 Thompson NFA 解剖正则爆炸
鸿蒙PC上的 ArkUI 跨平台实战:用回溯 VM 与 Thompson NFA 解剖正则爆炸
欢迎加入开源鸿蒙PC社区: https://harmonypc.csdn.net/
欢迎在PC社区平台申请新建项目:https://atomgit.com/OpenHarmonyPCDeveloper
前言
一条看起来很普通的正则,可以把界面按住半秒不放。这件事在鸿蒙PC上尤其容易被放大:用户拖着一个宽窗口,左边是模式输入,右边是实时读数,中间的画布还在一帧一帧重绘,任何一次匹配卡顿都会直接变成鼠标指针的迟滞感。Regexcope 这个工具就是为了把这种「说不清为什么卡」变成「可以指着数字说卡在哪里」而写的——它用 ArkUI 跨平台框架搭声明式骨架,用 ArkTS 写了两套真实可执行的匹配引擎:一套深度优先的回溯虚拟机,一套 Thompson NFA 执行器,同一条模式、同一段输入,两种执行策略的步数与墙钟被并排摊在同一块桌面上。
这里需要先把技术口径说准。本文所说的 ArkUI 跨平台框架,指的是同一套 ArkTS 语法、同一套声明式组件体系、同一套状态管理模型,在鸿蒙PC(2-in-1 形态)这类大屏、鼠标键盘输入的设备上复用;它不是把界面搬到其他操作系统的方案,也不负责抹平窗口管理与输入设备的差异。工程的模块配置写死了 deviceTypes: ['2in1'],布局假设、字号、命中区域全部按桌面窗口来设计,没有为手机竖屏留兼容分支。所有计算都在本机内存里完成,不申请任何权限、不发一条网络请求。
关键词:鸿蒙PC、ArkUI 跨平台框架、ArkTS、正则回溯、Thompson NFA、Canvas 绘制、帧预算、2-in-1、桌面端布局、AtomGit。

图 1:鸿蒙PC真机运行画面。窗口是系统自带标题栏,右上角最小化、最大化、关闭三个按钮齐全;窗口内是「240vp 侧栏 + 自适应内容区」的桌面双栏结构,左侧三项导航常驻,右侧同屏并排放着模式卡、状态图卡、引擎读数卡、帧预算卡与风险判读卡。
一、桌面任务:把「正则卡死」做成可以测量的对象
Regexcope 要回答的是一个问题:同一条正则,为什么有的写法跑 23 步,有的写法跑 40 万步还没跑完。
它把这个问题拆成三块能力,对应侧栏三项导航。
第一块是执行台。输入一条模式,选一个危险长度 n 与一档步数预算(50k / 400k / 2M),点一次执行,回溯 VM 与 NFA 执行器同时跑同一段被测输入,返回步数、墙钟、栈峰、峰值活跃态。两块读数并排,中间给一个「量级差」的比值。
第二块是增长曲线。固定一条模式,让输入长度从 8 逐点加到 24,每个点都用 200k 步预算实测一次,把回溯步数与 NFA 步数画在 log10 纵轴上。曲线的斜率就是这个模式在你输入上的增长阶数。
第三块是改写处方。四处结构性问题(嵌套量词、可选空白、重叠分支、冗余星号)各给一条改写,改写前后用同一台回溯 VM、同一长度输入各跑一次,把步数与墙钟填回对照表。
为什么这些内容非要在鸿蒙PC上做,而不是塞进一个手机界面?因为对照需要同屏。手机竖屏一次只能显示一块内容,用户看到「回溯 40 万步」时,模式输入已经滚出屏幕,状态图也要来回切页;鸿蒙PC 的窗口动辄一千像素以上,61/39 的两栏比例可以把「模式与状态图」和「读数与判读」左右分开,视线不需要离开画面就能完成一次因果对照。桌面形态带来的不是更花哨的视觉,而是更短的信息往返路径。
二、工程骨架:2in1 形态与窗口接管
工程是标准单模块结构:AppScope 放应用级配置,entry 放入口 Ability、页面、引擎与组件,hvigor 与 build-profile.json5 描述构建流程。ArkUI 跨平台框架把「窗口」和「页面」拆得很干净:窗口属性在 Ability 里设置,界面内容在页面里构建,两者之间只靠一次 loadContent 连接。模块配置里只有一句关键声明:
{
"module": {
"name": "entry",
"type": "entry",
"mainElement": "EntryAbility",
"deviceTypes": ["2in1"],
"pages": "$profile:main_pages",
"abilities": [
{
"name": "EntryAbility",
"srcEntry": "./ets/entryability/EntryAbility.ets",
"exported": true,
"skills": [{ "entities": ["entity.system.home"], "actions": ["action.system.home"] }]
}
]
}
}
deviceTypes: ['2in1'] 决定了这个应用只会被安装到鸿蒙PC形态的设备上,也不会在应用市场里被推到手机上。skills 里挂了 entity.system.home 与 action.system.home,安装后可以直接从桌面图标启动,窗口由系统接管——截图里那圈带最小化、最大化、关闭的标题栏是系统画出来的,不是应用自绘的假标题栏。自绘标题栏会破坏拖拽、贴边分屏、双击最大化这些系统行为,在桌面端是明确的减分项。
构建配置里 compatibleSdkVersion 为 26.0.0,runtimeOS 为 HarmonyOS,strictMode.useNormalizedOHMUrl 打开,包名为 com.regexcope.lab,版本 1.0.0(versionCode 1000000)。
入口 Ability 只承担三件事:让窗口铺满、把底色压成石墨黑、加载页面。底色必须在这里设,否则窗口首次呈现的一瞬间会闪出系统默认亮色,在深色工具类应用上非常刺眼:
export default class EntryAbility extends UIAbility {
onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
hilog.info(DOMAIN, TAG, 'Regexcope onCreate');
}
onWindowStageCreate(windowStage: window.WindowStage): void {
windowStage.getMainWindow().then((win: window.Window) => {
win.setWindowLayoutFullScreen(true).catch(() => { });
win.setWindowBackgroundColor('#0B0B0C');
}).catch(() => { });
windowStage.loadContent('pages/Index', (err) => {
if (err.code) {
hilog.error(DOMAIN, TAG, 'loadContent failed %{public}s', JSON.stringify(err));
}
});
}
}
两个 catch 空实现是刻意的:窗口属性只在部分设备能力上生效,设置失败不应该阻断内容加载。真正决定可用性的还是 loadContent 的回调,错误码走 hilog 打出来,便于在鸿蒙PC真机上定位白屏。整个模块没有 requestPermissions 字段——不读文件、不联网、不请求剪贴板,一个纯本地计算工具不需要任何授权。
三、ArkUI 声明式骨架:双栏、构建器与状态分层
页面入口是 pages/Index.ets,@Entry 加 @Component 标记。ArkUI 跨平台框架的界面没有「先创建控件再改属性」这一步,整页就是一颗由状态驱动的构建函数。整页结构是一行两列:固定 240 的侧栏,权重为 1 的内容区。
build() {
Row() {
this.Sidebar()
Column() {
this.Header()
Divider().color(C.LINE).strokeWidth(1)
Scroll() {
Column() {
if (this.tab === 'bench') {
this.BenchView()
} else if (this.tab === 'growth') {
this.GrowthView()
} else {
this.ClinicView()
}
}
.width('100%')
.padding({ left: 34, right: 34, top: 22, bottom: 34 })
}
.scrollBar(BarState.Off)
.layoutWeight(1)
}
.layoutWeight(1)
.height('100%')
}
.width('100%')
.height('100%')
.backgroundColor(C.BG)
}
Scroll 上关掉了滚动条(BarState.Off),因为内容区右侧还有读数卡,滚动条会与卡片描边打架;滚动本身仍然可用,鼠标滚轮与触控板都能推。layoutWeight(1) 让内容区吃掉侧栏之外的全部宽度,窗口被拖宽时只有右侧变化,左侧导航的视觉位置稳定——这是桌面应用比手机界面更在意的「框架稳定性」。
侧栏用 @Builder 写,ForEach 的键值生成器用 item.key:
@Builder
Sidebar() {
Column() {
Row({ space: 12 }) {
this.BrandMark()
Column({ space: 2 }) {
Text('REGEXSCOPE').fontSize(16).fontWeight(FontWeight.Bold)
.fontColor(C.TEXT).letterSpacing(1.6)
Text('回溯显微台').fontSize(13).fontColor(C.SUB)
}
.alignItems(HorizontalAlign.Start)
}
.width('100%')
.padding({ left: 22, right: 22, top: 26, bottom: 22 })
Divider().color(C.LINE).strokeWidth(1)
Column({ space: 6 }) {
ForEach(NAV, (item: NavItem) => {
Row({ space: 12 }) {
Text(item.idx).fontSize(12).fontColor(this.tab === item.key ? C.INK : C.DIM)
Column({ space: 3 }) {
Text(item.label).fontSize(18)
.fontColor(this.tab === item.key ? C.INK : C.TEXT)
.fontWeight(this.tab === item.key ? FontWeight.Bold : FontWeight.Normal)
Text(item.desc).fontSize(12)
.fontColor(this.tab === item.key ? 'rgba(11,11,12,0.62)' : C.DIM)
}
.alignItems(HorizontalAlign.Start)
}
.width('100%')
.padding({ left: 16, right: 12, top: 13, bottom: 13 })
.borderRadius(8)
.backgroundColor(this.tab === item.key ? C.LIME : 'transparent')
.onClick(() => { this.tab = item.key; })
.animation({ duration: 180, curve: Curve.EaseOut })
}, (item: NavItem) => item.key)
}
.width('100%')
.padding({ left: 12, right: 12, top: 16 })
Blank()
Column({ space: 6 }) {
Divider().color(C.LINE).strokeWidth(1)
Text('LOCAL ENGINE').fontSize(12).fontColor(C.LIME).letterSpacing(2).margin({ top: 14 })
Text('回溯 VM + Thompson NFA').fontSize(12).fontColor(C.SUB)
Text('全部计算在本机完成 · 0 网络请求').fontSize(12).fontColor(C.DIM)
}
.width('100%')
.padding({ left: 22, right: 22 })
.alignItems(HorizontalAlign.Start)
}
.width(240)
.height('100%')
.backgroundColor('#0E0E10')
}
这里有一个桌面端的细节:选中态同时改底色和字色。底色是酸橙 #D8FF3E,字色压到近黑 #0B0B0C,副标题用 62% 透明度的黑。只靠颜色深浅区分选中态,在深色底上很容易和悬停态混淆;黑字压亮底的做法是「反相」,一眼能看出来。Blank() 把底部那块引擎说明推到侧栏最下沿,窗口拉高时侧栏不会出现上密下空的断层。
状态分成两层,这是整个页面最值得说清楚的设计。第一层是引擎结果,全部用 @State:步数、墙钟、是否被预算截断、是否命中、栈峰、波形、NFA 状态表、活跃态集合、回放游标、增长采样点、处方对照行。第二层是纯计算与纯引用,用 private:定时器 id、回放轨迹数组、种子字符串。
@State btSteps: number = 0;
@State btUs: number = 0;
@State btAborted: boolean = false;
@State btMatched: boolean = false;
@State btPeak: number = 0;
@State wave: number[] = [];
private timerId: number = -1;
private trace: number[][] = [];
private seed: string = PRESETS[0].seed;
分层标准只有一条:界面需要读的一切都进 @State,界面不需要读的一切都不进。trace 之所以不进 @State,是因为它只在回放推进时被按下标读取,读到的值再写到 @State active 上;如果把整份轨迹也声明成状态,每次推进一帧都会触发一次大数组的观测与比较,而这个比较对界面毫无意义。
与之配套的是「派生值不存字段」。量级差、风险等级、毫秒折算全部写成方法:
private ratio(): number {
if (this.nfaSteps <= 0) {
return 0;
}
return this.btSteps / this.nfaSteps;
}
private risk(): Risk {
return riskOf(this.btSteps, this.btAborted);
}
private ms(): number {
return this.btUs / 1000;
}
ratio() 依赖 btSteps 与 nfaSteps 两个状态,任何一个变化,读取它的组件自然会重新求值。如果把它存成第三个状态,就必须在每次执行后手动同步,一旦漏一处,界面就会出现「步数已更新、倍数还是上一次」的错位读数。工具类应用最怕这种静默错位,因为它会让人对着错误的数字做判断。
四、同一条模式的两种编译:CPS 生成回溯指令,片段拼接生成 NFA
引擎没有复用系统正则,而是自己写了一个刻意做小的子集:字面量、字符类、\d \w \s、分组、|、* + ? {m,n}、^ $。惰性量词、反向引用、环视全部不支持,原因写在文件头注释里——它们会把回溯成本本身搅浑。量词上界限制 12,模式长度限制 120 字符,都是为了让状态图还能画在一屏里。
解析器 RegexParser 是一个递归下降的手写器,产出 RNode 树,节点类型为 char / seq / alt / rep / bol / eol / empty。字符集统一抽成 CharSet,用区间数组加取反标记表示,test(code) 线性扫区间。\d 就是一串 [48,57],\w 是四段区间,这样编译器和字符类语法可以共用同一套判定,不必为简写单独开分支。
回溯引擎把 AST 编译成一条线性指令序列,指令只有五种:char / split / bol / eol / match。编译函数用尾传递风格,build(node, next) 返回「执行完这个节点后应该跳到哪里」的入口下标,从尾部往前生成:
const build = (node: RNode, next: number): number => {
if (node.t === 'char') {
const ins = new BtIns('char', node.label, node.set);
ins.next = next;
return emit(ins);
}
if (node.t === 'seq') {
let n = next;
for (let i = node.items.length - 1; i >= 0; i--) {
n = build(node.items[i], n);
}
return n;
}
if (node.t === 'alt') {
let start = build(node.alts[node.alts.length - 1], next);
for (let i = node.alts.length - 2; i >= 0; i--) {
const sp = new BtIns('split', '|', null);
sp.x = build(node.alts[i], next);
sp.y = start;
start = emit(sp);
}
return start;
}
// rep:无上界时生成一条指回自身的 split,这就是回溯点的来源
let code = next;
const child = node.child as RNode;
if (node.max < 0) {
const sp = new BtIns('split', '*', null);
sp.y = next;
const spIdx = emit(sp);
const body = build(child, spIdx);
p.prog[spIdx].x = body;
code = spIdx;
} else {
for (let i = node.max - 1; i >= node.min; i--) {
const sp = new BtIns('split', '?', null);
sp.x = build(child, code);
sp.y = next;
code = emit(sp);
}
}
for (let i = node.min - 1; i >= 0; i--) {
code = build(child, code);
}
return code;
};
关键在第 14 行往下那段:无上界量词会先发一条 split,把 y 指向「跳出循环」的 next,再把循环体的出口改回这条 split 自己。于是指令流里出现了一条向后跳的边——每一次回到循环体,都意味着又攒了一个「失败时可以退回来换个分法」的备选。嵌套量词 (a+)+ 会出现两条这样的回边,路径数量按 2 的幂展开,这就是执行台上 400k 步预算被烧穿的机械原因。
NFA 的编译走的是另一条路,用 Thompson 构造配合补丁点。每一个片段 Frag 带一个出口列表,每个出口记录「哪个状态的哪个槽还没接」:
const patch = (outs: PatchPoint[], target: number): void => {
for (let i = 0; i < outs.length; i++) {
const o = outs[i];
const st = p.states[o.s];
if (o.slot === 1) {
st.o1 = target;
} else {
st.o2 = target;
}
}
};
// 字符:一个状态,一个待接出口
if (node.t === 'char') {
const id = add('char', node.label, node.set);
return new Frag(id, [new PatchPoint(id, 1)]);
}
// 交替:一个 split 状态,两个分支各接一侧
if (node.t === 'alt') {
const id = add('split', '|', null);
const first = build(node.alts[0]);
let outs: PatchPoint[] = first.outs;
p.states[id].o1 = first.start;
if (node.alts.length === 2) {
const second = build(node.alts[1]);
p.states[id].o2 = second.start;
outs = outs.concat(second.outs);
}
return new Frag(id, outs);
}
两种构造的差别,直接决定了后面两种执行策略的形态。回溯版把「选择」变成 split 指令加一条栈上的备选地址,选错就退回来重选;NFA 版把「选择」变成同一时刻的两个活跃状态,两条路一起走。前者是一台只带一个指针的机器,后者是一张同时点亮的网。
五、回溯 VM:显式栈、步预算与栈深度采样
执行器没有用递归。递归写起来短,但两件事都做不到:一是在 JavaScript 运行时里,深递归会先撞上调用栈上限,程序直接抛异常退出,工具本身比被测正则先倒下;二是没法在「第 400000 条指令」这种精确位置停下来。工程用两个平行数组当显式栈:
export function runBacktrack(p: BtProgram, subject: string, cap: number, sampleEvery: number): BtResult {
const res = new BtResult();
const n = subject.length;
const codes: number[] = [];
for (let i = 0; i < n; i++) {
codes.push(subject.charCodeAt(i));
}
const stackPc: number[] = [p.start];
const stackPos: number[] = [0];
let steps = 0;
let peak = 0;
let countdown = sampleEvery;
const t0 = nowNs();
while (stackPc.length > 0) {
let pc = stackPc.pop() as number;
let pos = stackPos.pop() as number;
for (;;) {
steps++;
if (steps > cap) {
res.aborted = true;
res.cause = 'budget';
res.steps = cap;
res.peakDepth = peak;
res.us = (nowNs() - t0) / 1000;
return res;
}
...
const ins = p.prog[pc];
if (ins.op === 'char') {
let ok = false;
if (pos < n && ins.set !== null) {
ok = ins.set.test(codes[pos]);
}
if (ok) {
pc = ins.next;
pos++;
continue;
}
break;
} else if (ins.op === 'split') {
stackPc.push(ins.y);
stackPos.push(pos);
if (stackPc.length > peak) {
peak = stackPc.length;
}
pc = ins.x;
continue;
} else if (ins.op === 'match') {
if (pos === n) {
res.matched = true;
res.steps = steps;
res.peakDepth = peak;
res.us = (nowNs() - t0) / 1000;
return res;
}
break;
}
...
}
}
}
四个设计点值得展开。
其一,steps++ 放在内层 for (;;) 的第一行,而不是放在外层循环里。一条 char 指令匹配成功后会 continue 回到内层,不算新的栈帧;只有匹配失败 break 出来,才会从栈上弹一个备选继续。把计数挂在指令粒度上,得到的才是「执行了多少条指令」,比较容易跨模式、跨输入对照;如果按栈帧计数,嵌套量词的成本会被严重低估。
其二,预算判断在每条指令前做,一旦越界立刻返回,并把 steps 写成 cap 而不是真实步数。界面上显示的是 ≥400k 而不是精确值,因为没人知道真实值是多少——它被台面切断了。这一点在读数卡上必须诚实标注,否则用户会以为那就是全部成本。
其三,栈深度采样用倒计时。sampleEvery 传 64 表示每 64 条指令采一次待回溯栈的长度,最多存 2200 个采样点。波形数组有上限,长跑模式不会把内存吃穿;采样间隔也不能太小,否则数组填充本身就会变成可观的额外开销,污染被测对象的耗时。64 是实测下来的折中:(a+)+ 的锯齿在这个密度下能看清,线性模式也不会画出噪点。
其四,计时用系统启动以来的单调时钟,而不是 Date.now():
function nowNs(): number {
try {
return systemDateTime.getUptime(systemDateTime.TimeType.STARTUP, true);
} catch (e) {
return Date.now() * 1000000;
}
}
getUptime 返回纳秒级、单调递增的时长,不受系统时间被用户改表影响;Date.now() 只有毫秒精度,二十几毫秒的匹配它只能给出一个粗粒度值。try/catch 兜底是为了在个别环境不提供该能力时仍然可运行,退化到毫秒精度——对一个工具来说,退化总比崩溃好。
栈还有一个硬上限 MAX_STACK_FRAMES = 260000。预算按指令数封顶,栈则按帧数封顶,两种截断都会把结果标记成 aborted,但 cause 不同(budget / stack),界面上也就不会把「步数超预算」和「内存要炸了」混为一谈。
六、Thompson NFA:闭包并行与逐字符轨迹
NFA 执行器走的是经典三件套:当前活跃状态集合、ε 闭包、每读一个字符推进一次。
function closure(states: NfaState[], seeds: number[], pos: number, len: number, stepsIn: number): Closure {
const out = new Closure();
const stack: number[] = [];
for (let i = 0; i < seeds.length; i++) {
stack.push(seeds[i]);
}
const seen: boolean[] = [];
for (let i = 0; i < states.length; i++) {
seen.push(false);
}
let steps = stepsIn;
while (stack.length > 0) {
const pc = stack.pop() as number;
if (pc < 0 || seen[pc]) {
continue;
}
seen[pc] = true;
steps++;
const st = states[pc];
out.all.push(pc);
if (st.op === 'split') {
stack.push(st.o1);
stack.push(st.o2);
} else if (st.op === 'eps') {
stack.push(st.o1);
} else if (st.op === 'assert') {
if (pos === 0) {
stack.push(st.o1);
}
} else if (st.op === 'assertEnd') {
if (pos === len) {
stack.push(st.o1);
}
} else {
out.chars.push(pc);
}
}
out.steps = steps;
return out;
}
seen 是这个函数的核心。Thompson 构造出来的图里,split 与 eps 可以形成环,没有去重就是无限递归。每个位置重建一次 seen 数组而不是复用,是为了让「同一状态在同一个位置只计一次」这件事与位置严格绑定;顺带它也把闭包本身的成本记进了 steps,这正是 NFA 在短输入上步数不如回溯「好看」的原因。
主循环里有个提前退出:cur.all.length === 0 时直接 break。活跃集合空了,说明这个前缀已经不可能再匹配任何一条路径,后面的字符不必再看。这个短路让不匹配的输入反而更快,是 NFA 相比回溯最实用的一个性质——最坏情况被钉死在「状态数 × 输入长度」,不会因为写法糟糕而指数爆炸。
trace 数组记录每个前缀位置的活跃集合,供状态图回放。它是一份 number[][],长度等于输入长度加一。回放时把 trace[cursor] 抄进 @State active,画布就会按位置点亮对应状态,用户看到的「并行线程逐字符推进」不是动画特效,而是真实活跃集合的逐帧快照。整个扫描跑在单次同步调用里,中间没有异步回调穿插,ArkUI 跨平台框架便只需要在结束时收敛一次状态,画布不会画到一半被打断。

图 2:执行台在鸿蒙PC窗口最大化后的画面。中间画布是 ^(a+)+$ 编译出的 6 个状态,酸橙高亮的是当前活跃态,底部胶片带显示 21 个字符全部被消费,游标停在 21/21;右侧读数 400.0k 步、149.1ms、栈峰 20,风险判读为「熔毁」,标注 BUDGET CUT。
七、Canvas 画状态图:分层布局与重绘时机
状态图是本项目里唯一的命令式绘制部分,也是 ArkUI 跨平台框架里少数需要手工计算每个坐标的地方。选择 Canvas 而不是用 Circle + Line 组件堆出来的原因很直接:一张 6 到 20 个状态、带箭头和回边的图,用组件表达要几十个节点加手工算坐标,而且每次活跃态变化都会牵动整棵子树的重建;用 CanvasRenderingContext2D 一次性画完,绘制成本可控,节点数量恒为一。
布局用 BFS 分层,把每条边尽量往右推,回边绕到下方:
const startId = this.start >= 0 && this.start < this.states.length ? this.start : 0;
const depth: number[] = [];
for (let i = 0; i < this.states.length; i++) {
depth.push(-1);
}
const q: number[] = [startId];
depth[startId] = 0;
let maxD = 0;
while (q.length > 0) {
const id = q.shift() as number;
const st = this.states[id];
const nb: number[] = [];
if (st.o1 >= 0) { nb.push(st.o1); }
if (st.o2 >= 0) { nb.push(st.o2); }
for (let k = 0; k < nb.length; k++) {
const t = nb[k];
if (depth[t] < 0) {
depth[t] = depth[id] + 1;
if (depth[t] > maxD) { maxD = depth[t]; }
q.push(t);
}
}
}
for (let i = 0; i < depth.length; i++) {
if (depth[i] < 0) { depth[i] = maxD; }
}
深度就是横坐标,同层内的序号就是纵坐标。回边(目标深度小于等于当前深度)用二次贝塞尔曲线向下兜一圈,dip 取绘图区高度的 42% 与 58 的较小值,避免在矮画布上画出巨大的弧:
if (depth[t] <= depth[i]) {
const dip = Math.min(plotH * 0.42, 58);
ctx.moveTo(x1, y1 + 16);
ctx.quadraticCurveTo((x1 + x2) / 2, y1 + dip, x2, y2 + 16);
} else {
ctx.moveTo(x1 + 16, y1);
ctx.lineTo(x2 - 16, y2);
}
这段分支在 (a+)+ 这种模式上尤其重要:两条回边如果按直线画,会横穿整张图,把中间的状态节点盖住,用户根本看不清「从哪里回哪里」。向下兜弧是低成本的解法,配合只给「两端都活跃」的边点亮,回放时能明确看到循环被激活的那一瞬。
重绘的触发方式是 @Prop @Watch:
@Prop @Watch('redraw') states: NfaState[] = [];
@Prop @Watch('redraw') active: number[] = [];
@Prop @Watch('redraw') consumed: number = 0;
@Prop @Watch('redraw') subject: string = '';
@Prop @Watch('redraw') start: number = 0;
@Prop canvasH: number = 392;
private ctx: CanvasRenderingContext2D = new CanvasRenderingContext2D(new RenderingContextSettings(true));
build() {
Canvas(this.ctx)
.width('100%')
.height(this.canvasH)
.onReady(() => {
this.redraw();
})
}
onReady 这一笔不能省。在 build() 期间,画布节点的实际尺寸还没确定,ctx.width 与 ctx.height 读出来是 0;任何按尺寸算出来的坐标都会退化到原点,图会被画成一团。onReady 在布局完成、节点可绘制时回调,此时尺寸才真实可信。redraw() 开头还有一道防线:
const W = this.ctx.width;
const H = this.ctx.height;
if (W <= 0 || H <= 0) {
return;
}
窗口被缩到极小、或者所在标签页刚被切换回来时,尺寸可能还是 0,直接返回比画错更安全。@Watch 只在传入值变化时触发,所以窗口尺寸变化本身不会重绘——这是当前实现的一处短板:用户拖动窗口改变宽度后,图会保持旧坐标直到下一次执行。合理的补法是监听区域变化重新布局重绘,这一点在鸿蒙PC上比在手机上更容易暴露,因为桌面窗口随时在被拖动。
八、增长扫描:斜率从哪里来,什么时候会骗你
执行台给的是单点数据,增长曲线给的是斜率。扫描器固定一条模式,让 n 从 8 到 24 每 2 个字符走一步,每个点都重新生成输入、分别喂给两台引擎:
for (let k = 8; k <= 24; k += 2) {
const s = buildSubject(this.seed, k);
const rb = runBacktrack(bt, s, 200000, 0);
const rn = runNfa(nfa, s, 1000000);
pts.push(new GrowthPoint(k, rb.steps, rn.steps, rb.aborted));
if (rb.aborted) {
hit = true;
break;
}
}
编译只做一次,输入与执行每个点重做一次。一旦某个点烧穿了 200k 预算,扫描立即停止,并把该点标成空心橙圈——后面的点不用测了,因为成本已经越过了台面,再往上只会更慢。这种「先撞墙再停」的策略比固定跑满全程更省时间,也更符合算法分析的直觉。
纵轴取 log10,是因为指数增长在等距坐标上会瞬间冲出画面,而对数坐标下 φⁿ 与 2ⁿ 的斜率差别一眼可辨。图下方还有一行实测斜率注记,用最后两个未截断点算:
const dn = last.n - prev.n;
const slope = (Math.log(last.bt / prev.bt) / Math.LN10) / Math.max(1, dn);
const per2 = Math.pow(10, slope * 2);
ctx.fillText(`实测斜率 ≈ ×${per2.toFixed(1)} / 每 +2 字符`, padL, padT - 12);
「每加 2 个字符乘几倍」这个口径比「时间复杂度是多少」更容易被现场理解:×1 就是线性,×3 以上就要警惕,×10 基本可以直接判死。
但这里必须交代一个真实的边界。图 3 那张鸿蒙PC截图里的曲线是两条水平线,回溯 23 步、NFA 37 步,倍数恒为 0.6×。看起来像「这个模式没有增长」,实际上是因为当前选中的是「多分支安全」预设 ^(ab|cd)+\d{2,3}$,它的种子生成器返回的是一段定长样本 abcdab123,与 n 无关:
export function buildSubject(seed: string, n: number): string {
if (seed === 'a-bang') {
return 'a'.repeat(n) + '!';
}
if (seed === 'code-ok') {
return 'abcdab' + '123';
}
if (seed === 'phone') {
return '010-1234';
}
if (seed === 'word-bang') {
return 'aaaa'.repeat(Math.max(1, Math.floor(n / 4))) + '!';
}
return 'a'.repeat(n) + '!';
}
只有 a-bang 与 word-bang 这两个种子会随 n 变长,code-ok 与 phone 返回的是写死的定长串。也就是说,扫描器的横轴是 n,但被测输入的长度只在部分种子上真的跟着 n 走。这暴露了一个测量口径的硬约束:横轴必须与被测变量严格对应,否则画出来的斜率是一个假读数。当前的正确用法是——要观察增长,就用会随 n 变长的种子;其余种子跑出来的平线只说明「输入没变长,成本自然不会变」。
真正需要改进的地方有两条:种子生成器应当显式声明「是否随 n 增长」,界面上对定长种子直接标注「本模式不适合斜率扫描」,而不是画出两条平线让人自己猜;或者把横轴改成实际输入长度而不是 n。这两条都已经记进待办,因为一个测量工具最不能容忍的就是读数含义不明。

图 3:增长曲线页在鸿蒙PC上的运行画面。横轴 n 从 8 到 24,右侧采样明细里每个点的回溯步数都是 23、NFA 步数都是 37、倍数都是 0.6×;曲线因此是两条平行的水平线,底部提示「完成 9 个采样点」,说明这轮扫描没有触发预算截断。
九、把毫秒翻译成帧:桌面端更在意这一格
读数是微秒,用户感知是帧。中间那层换算由帧预算卡承担:
update(): void {
const f = Math.ceil(this.ms / 16.7);
let filled = f;
if (filled < 0) {
filled = 0;
}
if (filled > 16) {
filled = 16;
}
if (this.ms <= 0) {
filled = 0;
}
this.filled = filled;
if (this.ms <= 16.7) {
this.tone = C.LIME;
} else if (this.ms <= 50) {
this.tone = C.AMBER;
} else {
this.tone = C.RED;
}
}
16 个格子、每格 16.7ms,取 ceil 而不是 floor:一件耗时 17ms 的事确实已经占满一帧还多一点,若向下取整会显示 1 格,与实际阻塞两帧的事实不符。上限钳 16 格,也就是约 267ms 之外的耗时全部显示为满格——再往上细分已经没有决策价值,反正都超标。
配色分三段也是刻意的:≤16.7ms 是酸橙,说明在一次绘制预算内;16.7 到 50ms 是琥珀,已经掉帧但还能忍;超过 50ms 转红。图 2 里 149.1ms 对应 9 格,卡上直接写「9 帧被阻塞」,比「149.1ms」更能让人意识到这是一次肉眼可见的顿挫。
风险判读把步数分成四档,判据写在 riskOf() 里:两千步以下是「冷静」,两千到五万是「温热」,五万到五十万是「炽热」,五十万以上是「爆表」,被预算截断则直接「熔毁」。这套阈值不是从某份规范抄来的,而是本项目在鸿蒙PC真机上反复跑出来的经验刻度——^\d{3}-\d{4}$ 这类定长模式基本落在几十步,而 (a+)+ 上 21 个字符就已经把 400k 步预算打穿。阈值可以商榷,但「按步数分档、档位有文字标签」这个做法是有效的:它把连续量变成了可沟通的结论。

图 4:换成互斥分支模式 ^(ab|cd)+\d{2,3}$ 后的鸿蒙PC画面。回溯 VM 23 步 / 32µs,NFA 37 步 / 67µs,量级差 0.6×,帧预算只占 1 格,风险判读为「冷静」,状态图右下的终止态被点亮。
这张图恰好解释了为什么「量级差」不能当绝对值读。回溯只用了 23 步,NFA 却用了 37 步,比值小于 1——但墙钟上回溯是 32µs、NFA 是 67µs,方向一致。原因很简单:两边的「步」定义不同,回溯一步是一条指令,NFA 一步是一次状态访问,闭包还要额外记步。跨引擎比绝对值没有意义,只有把同一条模式在不同输入长度上的增长斜率拿来比,结论才站得住。这一点在工具里也写成了固定文案,避免用户拿着 0.6× 得出「回溯更快」的错误外推。
十、真机验收清单与工程取舍
在鸿蒙PC真机上跑通之后,验收按下面六条走,每一条都能对应到具体代码或具体读数:
- 启动后确认窗口由系统接管,标题栏三键可用,拖拽、贴边、双击最大化都正常;窗口内 240vp 侧栏不随宽度变化,右侧内容区跟随拉伸。
- 切到执行台,选「嵌套量词」,确认被测输入显示为 20 个
a加一个!,执行后回溯读数被截断成≥400k并带橙色标记,帧预算卡填满 9 格,风险判读显示「熔毁」。 - 切换「状态图」与「回溯指纹」两个视图,确认前者画出 6 个状态且活跃态高亮,后者画出锯齿波形;拖动回放滑块,游标数值与高亮状态同步变化。
- 换成「多分支安全」,确认回溯 23 步、NFA 37 步、量级差 0.6×,风险判读落到「冷静」——同一台测量仪在不同模式上给出不同结论,说明读数确实来自执行而不是常量。
- 切到增长曲线,用「嵌套量词」扫描(种子会随 n 变长),确认曲线在 200k 预算处截断并出现空心橙圈;再用定长种子扫描,确认得到水平线,且明白那是输入没变长而不是模式安全。
- 切到改写处方,扫描一轮,确认四条改写的前后步数与墙钟都填上,且「载入执行台」能把改写后的模式带回执行台重新跑。
几个工程取舍值得记下来,它们都是在鸿蒙PC上被真实窗口尺寸和鼠标交互逼出来的。
字号整体上浮。 正文 13 到 15vp,卡片标题 17vp,页面主标题 32vp,读数数字 42vp。这个尺度放到手机上看偏大,但鸿蒙PC 的观看距离通常超过五十厘米,13vp 的说明文字在真机上恰好清晰。读数用 42vp 是因为它是最需要被「扫一眼抓住」的信息,视觉权重必须压过标题。
命中区域按鼠标重新估算。 预算档位按钮内边距左右 14、上下 6,加 1 像素描边,实际命中高度约 30 到 34vp;主执行按钮高 50vp,铺满整张卡片的宽度。滑块 Slider 的 blockColor 与 selectedColor 都用酸橙,鼠标拖动时能看清滑块与已选轨道的位置关系。这些尺寸在触屏上属正常,在鼠标下必须放宽,因为指针的落点精度比手指高,但误触的代价也更明显——点错一档预算,读数会差一个数量级。
深色底加单一强调色。 色板集中在 common/Theme.ets 的 C 类里,用 static readonly 定义:背景 #0B0B0C、面板 #121214、主文字 #F5F3EC、次级 #A2A29B、弱化 #6A6A64、酸橙 #D8FF3E,另有橙 #FF7A3D、红 #FF3D5A、蓝 #8FB4FF 三个语义色专供 NFA 与告警。只用一个高饱和强调色,好处是「哪里需要看」这件事不需要图例解释:酸橙就是当前值,橙红就是超限。
布局权重而不是固定宽度。 ArkUI 跨平台框架的 layoutWeight 在这里比写死像素好用得多:执行台用 layoutWeight(61) 对 layoutWeight(39) 分左右两栏,而不是写死像素。窗口被拖宽时,状态图区自动变宽,读数区同步变宽,比例保持;如果写死像素,宽窗口下右侧会留下一条空白,视觉上像是界面没加载完。
侧栏固定 240 的短板是明确的。 窗口被拖到很窄时,侧栏不会收缩,右侧内容会被挤压,读数卡的 42vp 数字可能换行。合理的改法是按可用宽度做断点,窄窗口把导航折叠成顶部横向标签。这类改造必须在鸿蒙PC真机上逐档拖动窗口核对,靠推算做不出来。
回放定时器必须显式清理。 回放用 setInterval 每 150ms 推进一步,aboutToDisappear() 里调用 stopPlay() 清掉计时器。少了这一步,页面销毁后计时器还在跑,回调里访问已卸载组件的状态,真机上表现为偶发报错或掉帧。桌面应用窗口可以被反复最小化、恢复,这类泄漏比手机上更容易被拖出来。
结语
Regexcope 的体量不大,但它把鸿蒙PC应用开发的几条主干都走了一遍:用 ArkUI 跨平台框架的声明式组件表达桌面双栏,用 @State 与 private 划清「读数」和「内部状态」的边界,用 Canvas 承担状态图这种高频、结构化的命令式绘制,用 ArkTS 写两台真的会执行的引擎,把「正则为什么慢」从体感变成步数、墙钟与帧格三组可对照的数字。
对 ArkUI 跨平台开发来说,真正需要投入精力的地方不是语法,而是形态差异与测量口径。窗口可以随时被拖动,画布尺寸必须在布局完成后才读得到;鼠标落点比手指精确,按钮命中区要重算;同一份读数在宽窗口里能被并排看见,于是「比什么、不比什么」这件事必须提前想清楚——就像 NFA 37 步对回溯 23 步那个 0.6×,稍不注意就会被读成相反结论。本文保留的四张鸿蒙PC真机截图里能看到系统标题栏、DevEco Studio 与底部 Dock,正是为了让这些形态细节有据可查。
后续可以继续推进的方向有三个:按窗口宽度做导航断点,让侧栏在窄窗口下折叠;把种子生成器改成显式声明是否随 n 增长,杜绝平线被误读;把两条引擎补上可复算的单元测试,让每一次改写处方的收益都有回归保护。工程代码托管在 AtomGit,结构可以对照本文逐节核查。这类「把性能问题做成可测量对象」的桌面工具,很适合沉淀到开源鸿蒙PC社区——窗口边界、命中容错、画布尺寸读取时机这些坑,在不同项目里会反复出现,一份能跑起来的工程比一段描述更有说服力。
更多推荐




所有评论(0)