注: 本文由AI生成,ednovas编辑并审核发布。

2026-11-18 更新:新增滚轮回弹诊断网页和标准档脚本。现在推荐先用网页测一次,再按结果装脚本。原来的严格版和改进版留在后面。

鼠标滚轮回弹,就是明明往一个方向滚,页面却突然往回跳一下(也有人叫滚轮抽风、滚轮跳格、滚轮反跳)。

网页往下滚得好好的,页面突然往上一跳。

打游戏用滚轮切枪,明明往下滚,枪却往回切了一把。

在 Excel、代码编辑器里往下翻,翻着翻着画面抖一下往回退一行。

鼠标别的地方都好好的,就滚轮时不时反着来一下,用起来特别难受,扔了又可惜。

我们手上好几只罗技 Superlight 都中招了,基本用一年左右就开始回弹;一只用了好几年的冰豹 Roccat Kone 也出现了一模一样的问题。于是研究了一下原因,最后用一个几十行的 AutoHotkey 脚本把它压住了(压住大部分,不是百分百)。后来针对它的盲点又写了一个改进版。再后来干脆做了一个网页,用你自己鼠标的数据来挑脚本,网页推荐的标准档脚本也放在文里了。

原因是滚轮里的机械编码器触点老化、氧化或进灰,接触一抖,鼠标芯片就把方向判反了。修法可以猛滚几十圈、吹灰、滴电子接点清洁剂、拆机捏紧编码器,或者干脆换编码器、走保修。不想拆鼠标的话,用本文的脚本在系统层面把回弹信号丢掉,正常滚动没有延迟。

现在推荐的做法是先用滚轮回弹诊断网页测一次,它会用你的数据从宽松、标准、严格三档里挑一档,大多数人用标准档就行(见下文“滚轮回弹诊断”和“标准档脚本”两节)。早期写的严格版和改进版也留着,区别见“几个脚本怎么选”。

先排除软件问题

滚轮往回跳也可能是软件引起的,动手之前先花两分钟排除一下。

先换个 USB 口,或者换台电脑。别的电脑上也一样跳,基本就是鼠标本身的问题。

然后关掉驱动里的特效。鼠标驱动里的“平滑滚动”“高精度滚动”、浏览器的平滑滚动,先关掉再试。

也可以一格一格慢慢滚。打开一篇长网页,只往下、一格一格地滚,盯着看有没有某一格是往上走的。

更准的办法是用在线工具测。打开 StarryRing 鼠标滚轮测试,选好“向上”或“向下”模式,只往这个方向连续滚二三十下。如果出现红色的“!”,“反向错误”的计数也在涨,就说明滚轮发出了反方向的信号。打开网页就能用,不用装软件,比盯着网页看准得多,推荐先用它测一下。

也可以直接用我们做的滚轮回弹诊断,它会记下每一格的方向和时间,后面单独讲。

后面的脚本运行后,鼠标悬停在托盘图标上会显示“已拦截 N 次”。只往一个方向滚一阵,如果这个数字在涨,说明确实有反方向的错误信号,就是回弹。

回弹的原因

编码器的工作方式

大部分鼠标的滚轮下面都有一个小零件,叫机械编码器(旋转编码器)。里面有两组金属触点,一般叫 A 和 B。滚轮转动时,这两组触点会交替地接通、断开,输出两路错开四分之一个周期的信号。

鼠标里的芯片就是靠“A、B 谁先变”来判断方向的。把 A、B 的通断记成 0 和 1,滚动时的状态变化是这样的:

朝一个方向滚:AB = 00 → 01 → 11 → 10 → 00 → …
朝另一个方向:AB = 00 → 10 → 11 → 01 → 00 → …

顺序是固定的,芯片只要看下一个状态是往“前”走还是往“后”走,就知道你在往哪边滚、滚了几格。

触点抖动

问题就出在这些金属触点上。用久了以后,触点和导电片会磨损,接触面变得坑坑洼洼;金属表面会氧化,或者里面的润滑脂干了、粘了灰;固定编码器的金属卡扣也可能松了,触点压得没那么紧。

接触一不好,触点在接通、断开的那一瞬间就会来回“抖”几下(电子里叫 contact bounce,触点抖动),信号上多出一些毛刺。比如本来应该是:

01 → 11

芯片却读到了:

01 → 00 → 01 → 11

中间那一步 01 → 00 恰好是反方向的一步,芯片就老老实实地给电脑报了一格反向滚动。于是你明明在往下滚,页面却往上跳了一下,这就是回弹。

这也解释了几个常见现象:

  • 滚得越快越容易跳,触点切换得频繁,抖动的机会更多。
  • 滚完停下的那一下最容易跳,滚轮停在两个刻度之间时,触点处在半接触状态,最不稳定。
  • 一般是用了一段时间才出现,磨损和氧化都是慢慢积累的。我们的 Superlight 基本一年左右就开始,Kone 则是用了好几年才出现。
  • 光学编码器的滚轮很少有这个问题,它靠光栅和光电管判断,没有会磨损的金属触点。

硬件修法

先试这些。

快速来回猛滚几十圈,难度最低,能把触点上的氧化层磨掉一点,有时能管几天到几周,但只是临时的。

对着滚轮缝隙吹气,灰尘引起的有用,要看情况。用气吹,别用嘴吹(有水汽)。

滴电子接点清洁剂,难度不高,是比较常见的有效办法,见下面的“滴清洁剂”。

拆机捏紧编码器卡扣,效果较好,但要拆鼠标,可能影响保修,见下面的“捏紧编码器卡扣”。

更换编码器最彻底,但需要焊接,还要买尺寸一致的编码器。

还在保修期内的话,走保修或者换新鼠标最省事,优先联系售后。

软件过滤只治标,但很稳,不修硬件,只把错误信号挡掉,见后面的“严格版去抖脚本”一节。

滴清洁剂

  1. 拔掉鼠标,无线鼠标把电池取出来
  2. 在滚轮和外壳的缝隙里滴一两滴电子接点清洁剂(或高纯度的异丙醇)
  3. 一边滴一边来回滚动滚轮几十圈,让清洁剂渗进编码器里
  4. 晾干(一般十几分钟到半小时)再插上用

注意不要用普通的 WD-40 这类除锈润滑剂,它会留下油膜,过一段时间反而更容易粘灰。要选“挥发、不残留”的电子清洁剂。

捏紧编码器卡扣

拆开鼠标后,滚轮旁边那个带金属外壳的小方块就是编码器。它的金属外壳四个角有卡扣,把内部的触点压在导电片上。用尖嘴钳把这几个卡扣轻轻往里捏紧一点,触点压得更紧,接触就会变好。

捏太狠可能会让滚轮转起来发涩,宁可一点一点来。拆鼠标一般要撕脚贴、拧螺丝,有些鼠标的螺丝在贴纸下面,拆了可能就没法保修了,自己权衡。

为什么最后用了软件

硬件修法要么只能管一阵子(猛滚、清洁),要么就得拆机甚至焊接。编码器磨损是不可逆的,修好之后过段时间很可能又犯。

而软件过滤的思路很简单:错误信号既然已经发出来了,那就在系统里把它丢掉。不用拆鼠标,回弹不是特别严重的话都能压住,换台电脑把脚本拷过去就行。

滚轮回弹诊断

不同鼠标回弹的规律不一样。有的滚动中途跳,有的停一下再滚的第一下就跳,适合的脚本参数也不一样。前面的 StarryRing 能看出有没有回弹,所以我们又做了一个网页:滚轮回弹诊断。它会找出你的鼠标在什么时候回弹,再用你自己的数据回测三档防回弹脚本,给出推荐。

网页是纯静态的,部署在 Cloudflare Pages 上。所有计算都在浏览器里完成(网页设置了禁止向任何服务器发送数据的安全策略),测试记录只存在你自己浏览器的 localStorage 里,页面底部可以一键清除。

用法一共四步,每次测试大约 3 分钟。

  1. 准备。如果已经在用防回弹脚本,先在托盘里右键绿色的 H 图标,选 Suspend Hotkeys 或者 Exit,这样测到的才是鼠标本来的样子。用鼠标滚轮测,别用触控板。
  2. 不开脚本测一次。鼠标放在页面里的文章上,按右边的提示滚动,一共 5 小项。每录到一格反方向的跳动,文章边框会闪一下红色。
  3. 看结果,选一份脚本装上。页面会用你的数据算出每一档的效果并标出推荐,直接下载对应的 AHK 脚本即可。
  4. 开着脚本再测一次,对比前后的回弹率。

测试页在任何电脑的浏览器上都能用,但 AutoHotkey 只支持 Windows,所以脚本只能在 Windows 上装。

浏览器有时会把同一帧(约 16 毫秒)里的几个滚轮事件合并,极快的抖动可能会少算。想要更精确的话,第 3 步的“进阶”里有一个只记录、不拦截的 AHK 记录器,可以记下每一格的精确时间再导入。

如果回弹率高到 8% 以上,或者严格档也压不住,那就是编码器本身的问题了,还是回到上面的硬件修法,或者直接送修。

标准档脚本

这是诊断网页推荐给大多数人的一档。不想测的话,直接装这一份也行。

换了什么思路

网上最常见的防回弹写法是“这一格和上一格方向相反、间隔又很短,就丢掉”。滚动途中这招有效,但停顿一会儿再开始滚时,上一格早就超出了时间窗,脚本手里没有参考方向,起手的那一下回弹会被直接放过去。很多写法还拿“上一个触发的热键”做比较,被拦下的回弹也算数,于是紧接着那一格正常滚动反而被吃掉,滚起来像卡了一下又跳一下。

标准档换了个思路。

方向记得更久(3 秒),这段时间里单独冒出来的反方向格子,一律先拦下。

真要往回翻的时候,250 毫秒内连拨两格就放行,并把第一格补回来,滚动距离一格不少。

凑够两格之后再等 45 毫秒,下一格要是回到了原方向,说明刚才那两格也是抖动,一起丢掉。

另外还有两道抖动防护:紧贴着正常滚动 30 毫秒内冒出来的反方向格,直接当抖动;两个反方向格挨得比 6 毫秒还近,只算一格。

三档的区别

宽松档方向只记 1.2 秒,250 毫秒内连续 2 格就换向。往回翻几乎没有门槛,适合经常一格一格往回翻的人,代价是漏掉的回弹多一点。

标准档方向记 3 秒,250 毫秒内连续 2 格换向,凑够之后再等 45 毫秒确认。适合大多数人。

严格档方向记 4 秒,要 400 毫秒内连续 3 格才承认换方向,确认要等 60 毫秒,停顿后的第一格也先等 60 毫秒看清方向。适合回弹很严重的旧鼠标,往回翻会稍微“沉”一点。

(注意这里的“严格档”和后面早期写的“严格版”脚本不是一个东西,别搞混了。)

我们在两份真实录制(一共约 1900 格)上回测过三档,又在数据里模拟加入了“两格连抖”再测一次。每格里的两个数字分别对应两份录制:

档位 真实数据:漏掉的回弹 加入两格连抖后:漏掉的回弹 误拦的正常滚动
不加抖动防护的旧标准档 3/36、1/47 51/82、48/93 0
宽松 6/36、2/47 6/82、2/93 4、2
标准 3/36、2/47 3/82、2/93 3、6
严格 1/36、2/47 1/82、2/93 18、19

没有抖动防护的话,一遇到两格连抖几乎全漏。加上之后标准档只漏 3 格和 2 格,误拦 3 格和 6 格。严格档漏得最少,但误拦多到 18、19 格,所以一般不推荐直接上严格档。

完整脚本

下面是诊断网页生成的标准档脚本(AHK v2):

#Requires AutoHotkey v2.0
; 滚轮防回弹 —— 滚轮回弹诊断 · 「标准」档
; 方案:方向记忆 3.0 s · 250 ms 内连续 2 格才换向(补发) · 防连抖 45 ms
; 用法:保存为 wheel_filter.ahk(编码选 UTF-8),双击运行。
; 退出:任务栏托盘里右键绿色 H 图标 → Exit。
#SingleInstance Force
#MaxThreadsBuffer true
A_MaxHotkeysPerInterval := 5000
A_HotkeyInterval := 1000
ProcessSetPriority "High"

; ===== 参数(可以按手感微调)=====
global MEMORY_MS := 3000 ; 方向记忆:正常滚动后这么久之内,反方向的格子先当回弹
global CONFIRM_N := 2 ; 反方向连续几格才算真的换向(0 = 记忆期内一律拦下)
global CONFIRM_GAP := 250 ; 这几格之间的最大间隔(毫秒)
global REPLAY := true ; 确认换向后补发之前拦下的格子
global LOCK_MS := 30 ; 紧贴着正常滚动这么久之内的反方向格子,直接当抖动
global MIN_GAP := 6 ; 两个反方向格子挨得比这更近(毫秒),只算一格
global CONFIRM_WAIT := 45 ; 凑够换向格数后再等这么久,下一格回到原方向就判为抖动(0 = 不等)
global START_MS := 0 ; 起手判决:停顿后第一格先等多久再决定方向(0 = 关闭)
global TIE_LAST := false ; 起手窗口里两个方向一样多时:以最后一格为准 / 全部丢掉

; ===== 状态 =====
global accDir := 0, accT := 0.0, revCnt := 0, revT := 0.0
global pendOn := false, pendDir := 0, pendCnt := 0, pendT := 0.0
global winOpen := false, winUp := 0, winDn := 0, winLast := 0

DllCall("winmm\timeBeginPeriod", "UInt", 1) ; 让计时器更准

*WheelDown::OnWheel(1)
*WheelUp::OnWheel(-1)

NowMs() {
static freq := 0
if !freq
DllCall("QueryPerformanceFrequency", "Int64*", &freq)
DllCall("QueryPerformanceCounter", "Int64*", &cnt := 0)
return cnt * 1000.0 / freq
}

OnWheel(d) {
global accDir, accT, revCnt, revT, pendOn, pendDir, pendCnt, pendT, winOpen, winUp, winDn, winLast
Critical
t := NowMs()
if pendOn { ; 换向待确认:看这一格往哪走
if (t - pendT <= CONFIRM_WAIT) {
SetTimer ConfirmFire, 0
pendOn := false
if (d = pendDir) { ; 还是反方向:确认真的要换向
Emit(d, REPLAY ? pendCnt + 1 : 1)
accDir := d, accT := t, revCnt := 0
return
}
revCnt := 0, accT := t ; 马上回到原方向:刚才那几格是抖动,丢掉
Emit(d, 1)
return
}
ConfirmFire() ; 定时器来晚了:先按确认处理
}
if winOpen { ; 起手判决窗口内:先收集
if (d > 0)
winDn += 1
else
winUp += 1
winLast := d
return
}
if (accDir = 0 || t - accT > MEMORY_MS) { ; 停顿太久,没有参考方向
revCnt := 0
if (START_MS > 0) {
winOpen := true, winLast := d, winDn := (d > 0), winUp := (d < 0)
SetTimer CloseWindow, -START_MS
return
}
accDir := d, accT := t
Emit(d, 1)
return
}
if (d = accDir) { ; 同方向:放行
accT := t, revCnt := 0
Emit(d, 1)
return
}
; 反方向:先拦下,看是不是真的要换向
if (t - accT < LOCK_MS) ; 紧贴着上一格正常滚动:抖动
return
if (revCnt > 0 && t - revT < MIN_GAP) ; 和上一个反方向格几乎同时:同一次抖动
return
revCnt := (revCnt > 0 && t - revT <= CONFIRM_GAP) ? revCnt + 1 : 1
revT := t
if (CONFIRM_N > 0 && revCnt >= CONFIRM_N) {
if (CONFIRM_WAIT > 0) { ; 先别放,再等一格看看
pendOn := true, pendDir := d, pendCnt := revCnt, pendT := t, revCnt := 0
SetTimer ConfirmFire, -CONFIRM_WAIT
return
}
Emit(d, REPLAY ? revCnt : 1)
accDir := d, accT := t, revCnt := 0
}
}

ConfirmFire() {
global accDir, accT, revCnt, pendOn, pendDir, pendCnt, pendT
Critical
if !pendOn
return
SetTimer ConfirmFire, 0
pendOn := false
Emit(pendDir, REPLAY ? pendCnt : 1)
accDir := pendDir, accT := pendT + CONFIRM_WAIT, revCnt := 0
}

CloseWindow() {
global accDir, accT, revCnt, winOpen, winUp, winDn, winLast
Critical
winOpen := false
if (winDn = winUp) {
if !TIE_LAST ; 平票:当作起手抖动,全部丢掉
return
d := winLast ; 平票:以最后一格的方向为准
} else
d := (winDn > winUp) ? 1 : -1
Emit(d, (d > 0) ? winDn : winUp)
accDir := d, accT := NowMs(), revCnt := 0
}

Emit(d, n) {
Send "{Blind}{Wheel" (d > 0 ? "Down" : "Up") " " n "}"
}

安装和参数

安装和后面严格版的一样:保存为 wheel_filter.ahk(编码选 UTF-8),双击运行,托盘里会出现绿色的 H 图标。开机自启、管理员窗口这些注意事项也一样,见后面的“安装和使用”和“注意事项”。想停用的话,右键托盘图标选 Exit 即可。

同方向滚动完全不受影响,没有任何延迟。只有换方向时,第一格会等到第二格出现才一起放出来,通常晚 20 到 30 毫秒,几乎察觉不到(只往回拨两格就停手的话,还会再等 45 毫秒确认)。按住 Ctrl 滚轮缩放、Shift 滚轮横向滚动都照常工作。

参数都在脚本开头,一般不用动,想换档直接回诊断网页下载对应的那一份就行。

MEMORY_MS 默认 3000,是方向记忆的时间(毫秒),正常滚动后这么久之内,反方向的格子先当回弹。

CONFIRM_N 默认 2,是反方向连续几格才算真的换向(填 0 就是记忆期内一律拦下)。

CONFIRM_GAP 默认 250,是这几格之间允许的最大间隔(毫秒)。

REPLAY 默认 true,确认换向以后,把之前拦下的格子补发出去。

LOCK_MS 默认 30,紧贴着正常滚动这么久之内的反方向格子,直接当抖动。

MIN_GAP 默认 6,两个反方向格子挨得比这更近(毫秒),只算一格。

CONFIRM_WAIT 默认 45,凑够换向格数后再等这么久,下一格回到原方向就判为抖动(填 0 就是不等)。

START_MS 默认 0,也就是关闭。打开后,停顿后的第一格先等这么久再决定方向,严格档用的是 60。

TIE_LAST 默认 false。起手窗口里两个方向一样多时,false 是全部丢掉,true 是以最后一格的方向为准。

另外脚本用 QueryPerformanceCounter 计时,用 timeBeginPeriod 把系统计时器精度调到 1 毫秒,进程优先级也设成了 High,几毫秒级别的判断才准。

严格版去抖脚本

(这是最早写的版本,现在推荐用前面的标准档。思路和代码留在这里给想看的朋友参考。)

AutoHotkey(简称 AHK)是 Windows 上一个免费开源的自动化工具,可以拦截键盘、鼠标的输入,处理之后再发出去。我们就用它在系统层面接管滚轮信号。

判断思路

关键是看回弹信号有什么特点。回弹一般只有一两个,夹在一串同方向的滚动中间,或者紧跟在一串滚动的末尾,而且离上一次滚动的时间非常近。

真的往回滚通常是连续好几格都是反方向,或者停了一会儿之后才开始往回滚。

最直观的写法是“反方向信号离上次滚动不到 X 毫秒就丢掉”,但这样会有两难:X 设大了,快速往回滚时总要被吃掉好几格,很不跟手;X 设小了,回弹又会漏过去。所以下面这个严格版把几种判断组合在了一起,一共四条规则:

  1. 来了一个反方向信号,先扣住 HOLD 毫秒。这期间只要原方向的信号又来了,说明它是夹在中间的回弹,丢掉。
  2. 扣住的反向信号,离上一次滚动不到 QUIET 毫秒,说明是刚滚完就冒出来的反向,判定为回弹,丢掉。
  3. 连续 CONFIRM 个反向信号(中间没有原方向的信号),说明真的在往回滚,立即放行,之前扣住的也一起补发。
  4. 停顿超过 QUIET 毫秒后再往回滚,第一格就放行,只是晚 HOLD 毫秒。

同方向的滚动永远直接放行,没有任何延迟,所以日常滚动的手感完全不受影响。

用几个场景来看就很清楚了(↓ 往下,↑ 往上,按默认参数):

场景 1:滚动中途回弹
输入:↓ ↓ ↓ ↑ ↓ ↓
处理:↑ 先扣住,紧接着又来了 ↓ → 判定为回弹,丢掉
输出:↓ ↓ ↓ ↓ ↓

场景 2:滚完停下时回弹一格(最常见)
输入:↓ ↓ ↓ ↑(滚完 50ms 后冒出来)
处理:↑ 扣住 80ms,没等到别的信号;它离上次滚动不到 400ms → 丢掉
输出:↓ ↓ ↓

场景 3:真的快速往回滚
输入:↓ ↓ ↓ ↑ ↑ ↑ ↑
处理:连续 3 个 ↑ → 确认是真的往回滚,3 个一起放行,之后的 ↑ 直接放行
输出:↓ ↓ ↓ ↑ ↑ ↑ ↑

场景 4:停了一会儿,再往回滚一格
输入:↓ ↓ ↓ (停 1 秒)↑
处理:↑ 扣住 80ms,离上次滚动已经超过 400ms → 放行
输出:↓ ↓ ↓ ↑(晚了 80ms,基本感觉不到)

代价也要说清楚:如果你滚完不到 400 毫秒就往回滚,而且只滚了一两格,这一两格会被当成回弹吃掉。实际用下来,这种操作很少见,就算遇到了,多滚一格就好。

完整脚本

#Requires AutoHotkey v2.0
#SingleInstance Force
#MaxThreadsBuffer True ; 快速滚动时事件排队处理,不丢格
A_MaxHotkeysPerInterval := 1000 ; 防止快速滚动触发"热键过多"警告

; ============================================================
; 滚轮去抖(严格版)
; 规则:
; 1. 反方向信号先扣住 HOLD 毫秒;期间只要原方向的信号又来了,就判定为回弹,丢掉。
; 2. 刚滚完不到 QUIET 毫秒就冒出来的反向信号,一律丢掉。
; 3. 连续 CONFIRM 个反向信号(中间没有原方向信号)→ 真的在往回滚,立即放行,扣住的也一起补发。
; 4. 停顿超过 QUIET 毫秒后再往回滚,第一格就放行(延迟 HOLD 毫秒)。
; ============================================================

HOLD := 80 ; 反向信号扣留多久(毫秒)
QUIET := 400 ; 停顿多久之后的反向才可信(毫秒)。还有漏网就调大,比如 600
CONFIRM := 3 ; 连续几个反向信号才放行。还想更狠就调到 4~5

lastDir := 0 ; 当前方向:1 = 上,-1 = 下
lastTime := 0 ; 上一次放行的时间
revCount := 0 ; 自上次放行以来,连续出现的反向信号数
held := 0 ; 正在扣留、还没判定的反向信号数
heldStart := 0 ; 这批扣留信号里第一个的时间
blocked := 0 ; 累计拦截次数(鼠标悬停托盘图标可查看)

UpdateTip()

*WheelUp::OnWheel(1)
*WheelDown::OnWheel(-1)

OnWheel(dir) {
global
Critical
now := A_TickCount

; 同方向(或第一次滚动):直接放行;如果有扣留的反向信号,说明那是回弹,丢掉
if (lastDir = 0 || dir = lastDir) {
if (held > 0) {
SetTimer(HoldTimeout, 0)
blocked += held
held := 0
UpdateTip()
}
revCount := 0
Emit(dir, 1)
return
}

; 反方向信号
revCount += 1
if (held = 0)
heldStart := now
held += 1

if (revCount >= CONFIRM) { ; 连续多个反向 → 真的在往回滚
SetTimer(HoldTimeout, 0)
n := held
held := 0
revCount := 0
Emit(dir, n)
return
}
SetTimer(HoldTimeout, -HOLD) ; 先扣住,等等看后面来的是什么
}

HoldTimeout() {
global
Critical
if (held = 0)
return
if (heldStart - lastTime >= QUIET) { ; 停顿够久才往回滚 → 放行
n := held
held := 0
revCount := 0
Emit(-lastDir, n)
} else { ; 刚滚完就冒出来的反向 → 丢掉
blocked += held
held := 0
UpdateTip()
}
}

Emit(dir, n) {
global
lastDir := dir
lastTime := A_TickCount
key := dir = 1 ? "{Blind}{WheelUp}" : "{Blind}{WheelDown}"
Loop n
Send(key)
}

UpdateTip() {
global
A_IconTip := "滚轮去抖(严格)· 已拦截 " blocked " 次"
}

安装和使用

  1. 到 AutoHotkey 官网 下载 v2 版本并安装(写这篇文章时最新的稳定版是 2.0.31)。注意脚本第一行写了 #Requires AutoHotkey v2.0,用 v1 是跑不起来的
  2. 新建一个文本文件,把上面的脚本粘贴进去,保存为 wheel_debounce_strict.ahk。编码用 UTF-8(Windows 11 记事本默认就是),AHK v2 默认按 UTF-8 读取脚本,中文注释不会乱码
  3. 双击运行,右下角托盘会出现一个绿色的 H 图标,鼠标悬停在上面会显示“滚轮去抖(严格)· 已拦截 N 次”
  4. 开机自启:按 Win + R,输入 shell:startup 回车,把脚本(或者它的快捷方式)放进打开的文件夹里。以前写过一篇添加开机自启软件,原理是一样的
  5. 改了参数之后:右键托盘图标 → Reload Script,立刻生效
  6. 临时关掉:右键托盘图标 → Suspend Hotkeys(暂停)或者 Exit(退出)

参数

HOLD 默认 80,是反向信号先扣留多久(毫秒)。调大判定更稳,但停顿后往回滚的第一格延迟更大;调小反应更快。

QUIET 默认 400,是停多久之后的反向信号才可信(毫秒)。调大更严格,停下来之后冒出的回弹也能挡住;调小则滚完马上改方向更灵敏。

CONFIRM 默认 3,是连续几个反向信号才算真的往回滚。调大能挡住一次连跳好几格的回弹;调小往回滚更跟手。

还是偶尔会跳的话,先把 QUIET 调到 600;如果你的鼠标一回弹就连跳好几格,再把 CONFIRM 调到 4~5。

觉得往回滚不跟手、被吃格的话,把 QUIET 降到 250~300,或者把 CONFIRM 降到 2。

托盘上的“已拦截”次数就是很好的参考:只往一个方向滚的时候,这个数字涨了多少,就说明帮你挡掉了多少次回弹。

也可以用前面提到的滚轮测试页面来验证效果。网页收到的是脚本过滤之后发出来的滚轮信号,所以先关掉脚本测一遍,再开着脚本测一遍,对比一下“反向错误”的计数:开着脚本的时候基本不涨了,就说明脚本起作用了。调参数的时候也可以开着这个页面看效果。

代码细节

给想看懂代码的朋友简单说一下。

*WheelUp / *WheelDown 前面的星号,表示按着 Ctrl、Shift 滚动时也会经过过滤;发送时加了 {Blind},修饰键会保留,所以 Ctrl + 滚轮缩放这些操作照常可用。

函数开头的 Critical 让处理一个滚轮信号时不会被下一个信号打断,几个计数变量不会乱。

#MaxThreadsBuffer True 让快速滚动时信号排队处理而不是被丢掉。A_MaxHotkeysPerInterval := 1000 是因为 AHK 默认 2 秒内触发超过 70 次热键就会弹警告,快速滚动很容易超,所以调高了。

脚本用 Send 发出去的滚轮事件,AHK 的钩子热键默认会忽略,不会再被脚本拦截一遍,所以不会死循环。

过滤只针对“方向变了”的信号,同方向的正常滚动直接放行,没有额外延迟。

注意事项

管理员窗口里不生效。没有管理员权限的脚本,在以管理员身份运行的窗口里(比如任务管理器、部分安装程序和游戏)是拦不到输入的。需要的话,右键脚本选“以管理员身份运行”;或者按 AHK 文档的推荐用 UI Access 方式运行(要求 AutoHotkey 安装在 Program Files 下面)。

高精度滚动要注意。脚本是按“一次滚轮事件 = 一格”转发的。有些鼠标开了高精度滚动,一次事件不到一格;滚得很快时,一次事件也可能代表好几格。这种情况下滚动速度可能和原来有点差别,建议在鼠标驱动里把高精度滚动关掉再用。

个别网游的反作弊对 AutoHotkey 比较敏感,玩之前可以右键托盘图标暂停或退出脚本。

脚本不修硬件,编码器还是会继续磨损,回弹可能越来越频繁。如果“已拦截”的数字涨得飞快,还是该清洁或者换编码器了。

严格版的局限

这个脚本有一个绕不过去的盲点:它看不到你的手往哪边转,只能拿“这一格”和“上一次放行的方向”做比较。所以只要错误信号恰好和上一次的方向一致,它就分辨不出来。

最典型的就是换方向的那一下:

场景 5:换方向时,第一下就是错的(挡不住)
上一次:↑ ↑ ↑ (停 1 秒)
这次想往下滚:↑ ↓ ↓ ↓ ← 第一个 ↑ 是回弹
处理:第一个 ↑ 和上一次方向相同 → 直接放行
脚本以为当前方向还是 ↑,后面真正的 ↓ 反而成了「反向信号」,要连续 3 个才放行
输出:↑ ↓ ↓ ↓(页面先往上跳一格,再往下走)
更糟的情况:这次只滚了 1~2 格 ↓ → 这 1~2 格会被当成回弹吃掉

对比一下,如果停顿前后是同一个方向(上次往下,这次也往下),第一下冒出来的错误 ↑ 会被扣住,后面的 ↓ 一来就把它丢掉,这种是能挡住的。

其他几个挡不住或者会误伤的情况:

脚本刚启动后的第一格,不做判断,直接放行,只影响一次,无所谓。

换方向时第一下就是错的(上面的场景 5),错误的一格被放行,后面 1~2 格正确的可能被吃掉。严格版没办法,改用后面的改进版。

回弹一次连跳 3 格以上,会被当成真的往回滚放行,把 CONFIRM 调到 4~5。

停下超过 400ms 后,滚轮自己冒出一个反向信号,会被当成“停顿后往回滚”放行,把 QUIET 调大。

滚完不到 400ms 就往回滚,只滚了 1~2 格,会被当成回弹吃掉(误伤),把 QUIET 调小,或者多滚一格。

针对场景 5 这个盲点,我们后来又写了一个改进版:停下来之后的第一批信号也不直接相信,先观察一小会儿再决定方向。它能挡住场景 5,但也有自己的代价,两个版本各有取舍。

改进版去抖脚本

(同样是早期版本,现在推荐用前面的标准档。)

思路和规则

严格版的盲点在于:停顿之后的第一个信号,只要和上一次方向一样就直接放行。可偏偏换方向的时候,第一下冒出来的回弹往往就是和上一次一样的方向。

改进版的做法很简单:停顿之后的第一批信号谁都不信,先收集一小会儿,看哪个方向多再放行。滚动过程中的逻辑和严格版完全一样,同方向照样零延迟。

这里“开始滚动”指的是停顿超过 QUIET 毫秒之后(或者脚本刚启动)的第一批信号,“滚动过程中”指的是距上次放行不到 QUIET 毫秒。

开始滚动时,先收集信号,最多等 START_HOLD 毫秒;某个方向领先 START_LEAD 个就立即放行,另一个方向的当回弹丢掉。

等满了还没领先的话,哪个方向多就放行哪个;一样多就全部丢掉(宁可少滚一格,也不往反方向跳)。

滚动过程中和严格版一样:同方向直接放行;反方向先扣住,原方向又来了就丢掉,连续 CONFIRM 个才放行,扣满 HOLD 毫秒还没凑够也丢掉。

还是用场景 5 来看:

场景 5(改进版):换方向时,第一下是错的
上一次:↑ ↑ ↑ (停 1 秒)
这次想往下滚:↑ ↓ ↓ ↓ ← 第一个 ↑ 是回弹
处理:停顿后的第一批信号先观察:↑ 1 个、↓ 1 个、↓ 2 个、↓ 3 个
↓ 领先 2 个 → 立即按 ↓ 放行,那个 ↑ 当回弹丢掉
输出:↑ ↑ ↑ ↓ ↓ ↓(不再往上跳)

和严格版的对比

两个版本的逻辑我们原样移植成了一个 Python 模拟器,喂同一串信号,对比输出(↓ 往下,↑ 往上,默认参数):

场景 严格版 改进版
滚动中途回弹、滚完停下时回弹、快速往回滚、停一会儿再往回滚一格 挡住 挡住
换方向,第一下是错的,接着滚 3 格 没挡住,先往反方向跳一格 挡住
换方向,第一下是错的,慢慢滚 2 格 没挡住,往反方向跳,2 格都被吃掉 挡住
脚本刚启动,第一下是错的 没挡住,往反方向跳,后面的也被吃掉 挡住
只滚 1 格,又刚好回弹一次(同方向) 挡住 这一格丢了
只滚 1 格,又刚好回弹一次(换方向) 没挡住,往反方向跳 这一格丢了
开头连着冒两个错误信号,或者滚轮停着时自己冒一个反向信号 没挡住 没挡住

“只滚 1 格又刚好回弹一次”这种情况,脚本看到的就是一上一下各一个,信号本身分不出哪个是真的。严格版按“和上次方向比”去猜,同方向时猜对,换方向时就往反方向跳;改进版干脆两个都丢掉,偶尔会“滚了一格没反应”,但不会再反着跳。

代价是开始滚动时的延迟。滚动过程中两个版本都不延迟。停顿后连续滚动,严格版不延迟,改进版第一格晚 20~30ms(等到第二格出现)。停顿后只滚 1 格(同方向),严格版不延迟,改进版晚 100ms。停顿后往回滚 1 格,严格版晚 80ms,改进版晚 100ms。慢慢一格一格看(每格间隔超过 0.4 秒),严格版不延迟,改进版每格晚 100ms。

上面是按脚本逻辑模拟出来的结果,真实的回弹信号长什么样,每只鼠标、每个磨损阶段都不太一样。换上改进版以后,可以先观察几天托盘上的“已拦截”次数和手感。

完整脚本

保存为 wheel_debounce_strict_v2.ahk,安装和使用方法和严格版一样:

#Requires AutoHotkey v2.0
#SingleInstance Force
#MaxThreadsBuffer True ; 快速滚动时事件排队处理,不丢格
A_MaxHotkeysPerInterval := 1000 ; 防止快速滚动触发"热键过多"警告

; ============================================================
; 滚轮去抖(改进版)
; 在严格版的基础上,把「停下来之后的第一下」也纳入判断:
;
; A. 开始滚动(停顿超过 QUIET 毫秒,或脚本刚启动):先观察,不急着放行
; 1. 收集 START_HOLD 毫秒内的信号;某个方向领先 START_LEAD 个 → 立即按这个方向放行,
; 另一个方向的当作回弹丢掉。
; 2. 观察期到了还没领先够:哪个方向多就放行哪个;一样多就全部丢掉
; (宁可少滚一格,也不往反方向跳)。
; B. 滚动过程中(距上次放行不到 QUIET 毫秒):和严格版一样
; 3. 同方向直接放行,没有延迟。
; 4. 反方向先扣住 HOLD 毫秒;期间原方向的信号又来了 → 回弹,丢掉。
; 5. 连续 CONFIRM 个反向信号 → 真的在往回滚,立即放行,扣住的也一起补发。
; 6. 扣满 HOLD 毫秒还没凑够 → 回弹,丢掉。
;
; 代价:停顿后只滚一格时,这一格要晚 START_HOLD 毫秒;
; 连续快速滚动时,只晚到第二格出现为止(一般十几到几十毫秒)。
; ============================================================

HOLD := 80 ; 滚动中反向信号扣留多久(毫秒)
QUIET := 400 ; 停顿多久算「重新开始滚动」(毫秒)
CONFIRM := 3 ; 滚动中连续几个反向信号才放行。还有漏网就调到 4~5
START_HOLD := 100 ; 开始滚动时最多观察多久(毫秒)。开头还会跳就调大(如 150),嫌慢就调小(如 60)
START_LEAD := 2 ; 观察期内某个方向领先几个就立即放行

lastDir := 0 ; 当前方向:1 = 上,-1 = 下,0 = 还没滚过
lastTime := 0 ; 上一次放行的时间
revCount := 0 ; 滚动中连续出现的反向信号数
held := 0 ; 滚动中正在扣留、还没判定的反向信号数
probing := false ; 是否处在「开始滚动」的观察期
probeUp := 0 ; 观察期内收到的「上」
probeDown := 0 ; 观察期内收到的「下」
blocked := 0 ; 累计拦截次数(鼠标悬停托盘图标可查看)

UpdateTip()

*WheelUp::OnWheel(1)
*WheelDown::OnWheel(-1)

OnWheel(dir) {
global
Critical
now := A_TickCount

; ---------- A. 开始滚动:先观察 ----------
if (probing || lastDir = 0 || now - lastTime >= QUIET) {
if (!probing) {
if (held > 0) { ; 上一轮没判定完的反向信号,当回弹丢掉
SetTimer(HoldTimeout, 0)
blocked += held
held := 0
}
probing := true
probeUp := 0
probeDown := 0
SetTimer(ProbeTimeout, -START_HOLD)
}
if (dir = 1)
probeUp += 1
else
probeDown += 1
if (Abs(probeUp - probeDown) >= START_LEAD) { ; 某个方向明显领先 → 不用等了
SetTimer(ProbeTimeout, 0)
ProbeDecide()
}
return
}

; ---------- B. 滚动过程中 ----------
if (dir = lastDir) { ; 同方向:直接放行;扣着的反向信号是回弹,丢掉
if (held > 0) {
SetTimer(HoldTimeout, 0)
blocked += held
held := 0
UpdateTip()
}
revCount := 0
Emit(dir, 1)
return
}

revCount += 1 ; 反方向:先扣住,等等看后面来的是什么
held += 1
if (revCount >= CONFIRM) { ; 连续多个反向 → 真的在往回滚
SetTimer(HoldTimeout, 0)
n := held
held := 0
revCount := 0
Emit(dir, n)
return
}
SetTimer(HoldTimeout, -HOLD)
}

ProbeTimeout() {
global
Critical
if (probing)
ProbeDecide()
}

ProbeDecide() {
global
probing := false
revCount := 0
if (probeUp > probeDown) {
blocked += probeDown
Emit(1, probeUp)
} else if (probeDown > probeUp) {
blocked += probeUp
Emit(-1, probeDown)
} else { ; 一样多:分不清哪个是回弹,全部丢掉
blocked += probeUp + probeDown
}
UpdateTip()
}

HoldTimeout() {
global
Critical
if (held = 0)
return
blocked += held ; 滚动中扣满 HOLD 还没凑够 → 回弹,丢掉
held := 0
revCount := 0
UpdateTip()
}

Emit(dir, n) {
global
lastDir := dir
lastTime := A_TickCount
key := dir = 1 ? "{Blind}{WheelUp}" : "{Blind}{WheelDown}"
Loop n
Send(key)
}

UpdateTip() {
global
A_IconTip := "滚轮去抖(改进版)· 已拦截 " blocked " 次"
}

新增的两个参数

HOLD、QUIET、CONFIRM 的含义和严格版一样,另外多了两个。

START_HOLD 默认 100,是停顿后开始滚动时,最多观察多久再决定方向(毫秒)。开头还会跳就调大(如 150);觉得刚开始滚时发钝就调小(如 60~80)。

START_LEAD 默认 2,是观察期内某个方向领先几个就立即放行。一般不用动;开头经常连冒两个错误信号的话可以调到 3,但开始滚动会更慢。

几个脚本怎么选

现在推荐先用滚轮回弹诊断测一次,按它的推荐装,大多数人是标准档。不想测的话,直接装标准档。

早期的两个版本也能用,区别是这样的。

回弹主要出现在滚动中途或者停下的时候,换方向时很少跳,用严格版,跟手、零延迟。它的代码也更简单。

经常遇到“上来第一下就反”,或者滚轮已经磨得比较厉害,用改进版,多一点点延迟换不反跳。它多了一个观察阶段,换方向时第一下就反的大部分挡得住。

拿不准就先用严格版,看托盘上的拦截次数和实际手感,换方向时还经常跳再换改进版。

几个脚本不要同时运行,它们都会接管滚轮。 换脚本前先右键托盘图标退出旧的,开机自启的文件夹里也只放一个。托盘提示里严格版显示“严格”,改进版显示“改进版”,标准档没有设提示,显示的是文件名。

参考资料