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

鼠标滚轮回弹(往回跳)怎么办

不知道你有没有遇到过这种情况:

  • 网页往下滚得好好的,页面突然往上一跳
  • 打游戏用滚轮切枪,明明往下滚,枪却往回切了一把
  • 在 Excel、代码编辑器里往下翻,翻着翻着画面抖一下往回退一行

这就是常说的鼠标滚轮回弹(也有人叫滚轮抽风、滚轮跳格、滚轮反跳)。鼠标别的地方都好好的,就滚轮时不时反着来一下,用起来特别难受,扔了又可惜。

我们手上好几只罗技 Superlight 都中招了,基本用一年左右就开始回弹;一只用了好几年的冰豹 Roccat Kone 也出现了一模一样的问题。于是研究了一下原因,最后用一个几十行的 AutoHotkey 脚本把它压住了(压住大部分,不是百分百)。后来针对它的盲点又写了一个改进版,两个版本各有取舍,都放在文里了。废话不多说,直接上干货。

TL;DR

  • 原因:滚轮里的机械编码器触点老化、氧化或进灰,接触一抖,鼠标芯片就把方向判反了
  • 简单修法:猛滚几十圈、吹灰、滴电子接点清洁剂、拆机捏紧编码器,或者干脆换编码器 / 走保修
  • 不想拆鼠标:用本文的 AutoHotkey 去抖脚本,在系统层面把「回弹」信号丢掉,正常滚动没有延迟
  • 两个版本:严格版滚动时零延迟,但换方向时第一下就是错的挡不住;改进版能挡住这种情况,代价是开始滚动时多一点延迟(见第四~六章)

一、先确认是不是滚轮硬件的问题

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

  • 🔌 换个 USB 口 / 换台电脑:别的电脑上也一样跳,基本就是鼠标本身的问题
  • 🖱️ 关掉驱动里的特效:鼠标驱动里的「平滑滚动」「高精度滚动」、浏览器的平滑滚动先关掉再试
  • 🐢 一格一格慢慢滚:打开一篇长网页,只往下、一格一格地滚,盯着看有没有某一格是往上走的
  • 📊 用后面的脚本来测:脚本运行后,鼠标悬停在托盘图标上会显示「已拦截 N 次」。只往一个方向滚一阵,如果这个数字在涨,说明确实有反方向的错误信号,就是回弹

二、为什么会回弹:滚轮里的编码器

2.1 鼠标是怎么知道你往哪边滚的

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

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

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

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

2.2 触点一抖,方向就判反了

问题就出在这些金属触点上。用久了以后:

  • 🪨 触点和导电片磨损,接触面变得坑坑洼洼
  • 🟫 金属表面氧化,或者里面的润滑脂干了、粘了灰
  • 🔩 固定编码器的金属卡扣松了,触点压得没那么紧

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

01 → 11

芯片却读到了:

01 → 00 → 01 → 11

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

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

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

三、简单的修法(先试这些)

方法 难度 效果 说明
快速来回猛滚几十圈 ⭐ 临时 能把触点上的氧化层磨掉一点,有时能管几天到几周
对着滚轮缝隙吹气 ⭐ 看情况 灰尘引起的有用,用气吹,别用嘴吹(有水汽)
滴电子接点清洁剂 ⭐⭐ 比较常见的有效办法 见下方 3.1
拆机捏紧编码器卡扣 ⭐⭐⭐ 效果较好 见下方 3.2,要拆鼠标,可能影响保修
更换编码器 ⭐⭐⭐⭐ 最彻底 需要焊接,要买尺寸一致的编码器
走保修 / 换新鼠标 ⭐ 最省事 还在保修期内的话,优先联系售后
软件过滤 ⭐ 治标,但很稳 不修硬件,只把错误信号挡掉,见第四章

3.1 滴清洁剂

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

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

3.2 捏紧编码器卡扣

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

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

3.3 那为什么最后还是用了软件

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

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


四、AutoHotkey 去抖脚本(严格版)

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

4.1 思路:怎么分辨「回弹」和「真的往回滚」

关键是看回弹信号有什么特点:

  • 一般只有一两个,夹在一串同方向的滚动中间,或者紧跟在一串滚动的末尾
  • 离上一次滚动的时间非常近

而真的往回滚通常是:

  • 连续好几格都是反方向
  • 或者停了一会儿之后才开始往回滚

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

4.2 四条规则

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

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

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

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

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

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

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

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

4.3 严格版完整脚本

#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 " 次"
}

4.4 安装和使用

  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(退出)

4.5 参数怎么调

参数 默认值 作用 调大 调小
HOLD 80 反向信号先扣留多久(毫秒) 判定更稳,但停顿后往回滚的第一格延迟更大 反应更快
QUIET 400 停多久之后的反向信号才可信(毫秒) 更严格,停下来之后冒出的回弹也能挡住 滚完马上改方向更灵敏
CONFIRM 3 连续几个反向信号才算真的往回滚 能挡住一次连跳好几格的回弹 往回滚更跟手

调参的思路很简单:

  • 还是偶尔会跳:先把 QUIET 调到 600;如果你的鼠标一回弹就连跳好几格,再把 CONFIRM 调到 4~5
  • 觉得往回滚不跟手、被吃格:把 QUIET 降到 250~300,或者把 CONFIRM 降到 2

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

4.6 几个代码细节

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

  • 星号前缀:*WheelUp / *WheelDown 前面的 * 表示按着 Ctrl、Shift 滚动时也会经过过滤;发送时加了 {Blind},修饰键会保留,所以 Ctrl + 滚轮缩放这些操作照常可用
  • Critical:函数开头的 Critical 让处理一个滚轮信号时不会被下一个信号打断,几个计数变量不会乱
  • 事件排队:#MaxThreadsBuffer True 让快速滚动时信号排队处理而不是被丢掉;A_MaxHotkeysPerInterval := 1000 是因为 AHK 默认 2 秒内触发超过 70 次热键就会弹警告,快速滚动很容易超,所以调高了
  • 不会自己触发自己:脚本用 Send 发出去的滚轮事件,AHK 的钩子热键默认会忽略,不会再被脚本拦截一遍,所以不会死循环
  • 同方向不做任何判断:过滤只针对「方向变了」的信号,正常滚动直接放行,没有额外延迟

4.7 注意事项

  • 🛡️ 管理员窗口里不生效:没有管理员权限的脚本,在以管理员身份运行的窗口里(比如任务管理器、部分安装程序和游戏)是拦不到输入的。需要的话,右键脚本选「以管理员身份运行」;或者按 AHK 文档的推荐用 UI Access 方式运行(要求 AutoHotkey 安装在 Program Files 下面)
  • 🎚️ 高精度滚动:脚本是按「一次滚轮事件 = 一格」转发的。有些鼠标开了高精度滚动,一次事件不到一格;滚得很快时,一次事件也可能代表好几格。这种情况下滚动速度可能和原来有点差别,建议在鼠标驱动里把高精度滚动关掉再用
  • 🎮 网游反作弊:个别网游的反作弊对 AutoHotkey 比较敏感,玩之前可以右键托盘图标暂停或退出脚本
  • 🔧 它不修硬件:编码器还是会继续磨损,回弹可能越来越频繁。如果「已拦截」的数字涨得飞快,还是该清洁或者换编码器了

4.8 局限性:换方向时第一下就错了,挡不住

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

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

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

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

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

情况 结果 能不能缓解
脚本刚启动后的第一格 不做判断,直接放行 无所谓,只影响一次
换方向时第一下就是错的(场景 5) 错误的一格被放行,后面 1~2 格正确的可能被吃掉 严格版没办法,改用第五章的改进版
回弹一次连跳 3 格以上 被当成真的往回滚放行 把 CONFIRM 调到 4~5
停下超过 400ms 后,滚轮自己冒出一个反向信号 被当成「停顿后往回滚」放行 把 QUIET 调大
滚完不到 400ms 就往回滚,只滚了 1~2 格 被当成回弹吃掉(误伤) 把 QUIET 调小,或者多滚一格

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


五、改进版:把「上来第一下」也管起来

5.1 思路

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

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

5.2 规则

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

阶段 规则
开始滚动:某个方向领先 先收集信号,最多等 START_HOLD 毫秒;某个方向领先 START_LEAD 个就立即放行,另一个方向的当回弹丢掉
开始滚动:等满了还没领先 哪个方向多就放行哪个;一样多就全部丢掉(宁可少滚一格,也不往反方向跳)
滚动过程中 和严格版一样:同方向直接放行;反方向先扣住,原方向又来了就丢掉,连续 CONFIRM 个才放行,扣满 HOLD 毫秒还没凑够也丢掉

还是用场景 5 来看:

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

5.3 和严格版的对比

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

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

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

代价是开始滚动时的延迟:

操作 严格版 改进版
滚动过程中 不延迟 不延迟
停顿后连续滚动 不延迟 第一格晚 20~30ms(等到第二格出现)
停顿后只滚 1 格(同方向) 不延迟 晚 100ms
停顿后往回滚 1 格 晚 80ms 晚 100ms
慢慢一格一格看(每格间隔超过 0.4 秒) 不延迟 每格晚 100ms

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

5.4 改进版完整脚本

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

#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 " 次"
}

5.5 新增的两个参数

HOLD、QUIET、CONFIRM 的含义和严格版一样(见 4.5),另外多了两个:

参数 默认值 作用 怎么调
START_HOLD 100 停顿后开始滚动时,最多观察多久再决定方向(毫秒) 开头还会跳就调大(如 150);觉得刚开始滚时发钝就调小(如 60~80)
START_LEAD 2 观察期内某个方向领先几个就立即放行 一般不用动;开头经常连冒两个错误信号的话可以调到 3,但开始滚动会更慢

六、两个版本怎么选

严格版 改进版
滚动中途、停下时的回弹 ✅ 挡得住 ✅ 挡得住
换方向时第一下就反 ❌ 挡不住,还可能吃掉后面 1~2 格 ✅ 大部分挡得住
开始滚动的延迟 基本没有 连续滚动晚 20~30ms,只滚一格晚 100ms
慢慢一格一格看 没延迟 每格晚 100ms
只滚 1 格又刚好回弹 同方向对,换方向会反跳 这一格丢掉,不会反跳
代码 更简单 多了一个观察阶段

简单说:

  • 🟢 回弹主要出现在滚动中途或者停下的时候,换方向时很少跳:用严格版,跟手、零延迟
  • 🔵 经常遇到「上来第一下就反」,或者滚轮已经磨得比较厉害:用改进版,多一点点延迟换不反跳
  • 📊 拿不准就先用严格版,看托盘上的拦截次数和实际手感,换方向时还经常跳再换改进版

⚠️ 两个版本不要同时运行,它们都会接管滚轮。换版本前先右键托盘图标退出旧的,开机自启的文件夹里也只放一个。托盘提示里会显示「严格」或「改进版」,可以用来区分正在跑的是哪个。


七、总结

鼠标滚轮回弹,说到底是滚轮编码器的金属触点老化,接触一抖,方向就判反了。处理思路也很清楚:

  1. 先确认是硬件问题,排除驱动和软件的平滑滚动
  2. 能动手就先试试清洁、捏紧卡扣,还在保修期就直接找售后
  3. 不想折腾,或者修完又犯,就上 AutoHotkey 去抖脚本,在系统层面把回弹信号丢掉:严格版零延迟,改进版能管住「上来第一下就反」,按自己的情况选
  4. 脚本只是治标,「已拦截」的次数越涨越快的时候,还是得回到第 2 步

几十行脚本救回一只鼠标,省下的钱够买好几包零食了 /狗头。如果你调出了更适合自己鼠标的参数,欢迎在评论区分享。


参考资料