AutoHotkey v2 对面向对象编程进行了彻底的重新设计,提供了完整、现代化的 OOP 支持。与 v1 那种”半吊子”的类系统不同,v2 的 OOP 从语言底层就是原生构造——不再有 % 表达式、this 隐式对象这些历史包袱,取而代之的是类(Class)、属性(Property)、静态成员(static)、抽象方法等标准 OOP 设施。
本文将深入 AHK v2 的 OOP 体系,从类定义的本质到底层元表机制,再到 6 个完整的实战设计模式案例,帮你真正掌握这门语言最强大的抽象能力。
一、类定义的本质:Class 是 Object
在 AutoHotkey v2 中,class 关键字定义的不是一个”模板”,而是一个原型对象(prototype object)。理解这一点是整个 OOP 体系的基础。
1.1 类即对象
当你写下 class MyClass {},AHK 实际做的事情是:
- 创建一个名为
MyClass的对象(类型为Class) - 为该对象创建一个
Prototype子对象 MyClass.Prototype.__Class="MyClass"MyClass.Prototype的原型链指向Object.Prototype
class Animal {
static Count := 0
__New(Name) {
this.Name := Name
Animal.Count++
}
Speak() {
return "? ? ?"
}
}
; 验证本质
MsgBox Type(Animal) ; "Class" —— 类本身也是对象
MsgBox Type(Animal.Prototype) ; "Object" —— 原型链标准对象
MsgBox Animal.Prototype.__Class ; "Animal"
1.2 原型链查找机制
AHK v2 的属性/方法查找严格遵循原型链:
实例对象 → 实例自己的属性 → 类的 Prototype → 父类 Prototype → ... → Object.Prototype
与 v1 的 base 手动链不同,v2 的继承链由 extends 关键字自动维护,编译器直接优化了查找路径。
二、类成员:方法、属性、访问器与静态成员
2.1 方法定义
v2 的方法就是定义在类体中的函数,默认接收 this 作为第一个参数(隐式传递):
class Calculator {
Result := 0
Add(Value) {
this.Result += Value
return this
}
Sub(Value) {
this.Result -= Value
return this
}
GetResult() {
return this.Result
}
}
calc := Calculator()
MsgBox calc.Add(10).Sub(3).GetResult() ; 7
方法链(Method Chaining):返回 this 就可以链式调用 —— 这在构建器模式中特别有用。
2.2 属性(Property)
v2 的 Property 是真正的属性定义,支持 getter/setter,这是 v1 完全不具备的能力:
class Temperature {
_Celsius := 0
; 只读属性
Celsius {
get => this._Celsius
}
; 读写属性,带边界校验
Fahrenheit {
get => this._Celsius * 9 / 5 + 32
set {
if Value
属性语法要点:
- get / set 在属性名后用大括号包围
- set 中的 Value 是隐式参数(赋值的右值)
- 只读属性:只定义 get
- 只写属性:只定义 set(少见,通常用于配置注入)
2.3 静态成员
静态成员属于类本身,而非实例。用 static 关键字定义:
class ConfigManager {
static _Config := Map()
static _Instance := unset
; 静态属性
static DebugMode {
get => this._Config.Get("Debug", false)
set => this._Config["Debug"] := Value
}
; 静态方法
static Get(key, default := unset) {
if this._Config.Has(key)
return this._Config[key]
if IsSet(default)
return default
throw KeyError("配置项未找到: " key)
}
; 单例模式(Singleton)
static Instance {
get {
if !IsSet(this._Instance)
this._Instance := ConfigManager()
return this._Instance
}
}
__New() {
throw Error("请使用 ConfigManager.Instance 获取单例")
}
}
ConfigManager.DebugMode := true
MsgBox ConfigManager.Get("Debug") ; 1 (true)
cfg := ConfigManager.Instance ; 获取单例
注意:静态方法中的
this指向的是类本身(即ConfigManager这个Class对象),而非实例。
2.4 构造函数 __New 与析构函数 __Delete
class ResourceGuard {
_Handle := 0
__New(ResourceName) {
this._Handle := DllCall("OpenResource", "Str", ResourceName, "Ptr")
if !this._Handle
throw Error("资源打开失败: " ResourceName)
MsgBox "资源已打开: " ResourceName
}
__Delete() {
if this._Handle {
DllCall("CloseResource", "Ptr", this._Handle)
MsgBox "资源已释放"
}
}
}
{
guard := ResourceGuard("MyResource") ; 构造
; 使用资源...
} ; 离开作用域 → __Delete 自动调用
__New 在 new 之后、返回实例之前调用。__Delete 在实例被垃圾回收前调用。注意:__Delete 中不能抛出异常,且不要依赖成员变量的具体状态(可能已被部分清理)。
三、继承与多态(extends)
3.1 基础继承
class Shape {
static Version := 2
__New(X, Y) {
this.X := X
this.Y := Y
}
Area() {
return 0
}
Describe() {
return Format("图形在 ({}, {})", this.X, this.Y)
}
}
class Circle extends Shape {
__New(X, Y, Radius) {
super.__New(X, Y) ; 调用父类构造
this.Radius := Radius
}
Area() {
return 3.14159 * this.Radius ** 2 ; 覆盖(override)
}
Describe() {
return super.Describe() . ",半径: " this.Radius ; 复用父类
}
}
class Rectangle extends Shape {
__New(X, Y, W, H) {
super.__New(X, Y)
this.W := W
this.H := H
}
Area() {
return this.W * this.H
}
}
; 多态
shapes := [
Circle(0, 0, 10),
Rectangle(5, 5, 20, 30)
]
for s in shapes
MsgBox s.Describe() "`n面积: " s.Area()
3.2 super 关键字
super 是 v2 新增的关键字,用于调用父类的方法:
super.__New(...)— 调用父类构造函数(必须手动调用,不自动)super.MethodName(...)— 调用父类的同名方法super.PropertyName— 访问父类的属性
一个常见陷阱:忘记在子类 __New 中调用 super.__New。v2 不会自动调用父类构造函数,忘记调用可能导致父类初始化未执行。
3.3 抽象方法与接口模拟
AHK v2 没有原生的 abstract 或 interface 关键字,但可以通过抛出 MethodError 来模拟:
class AbstractPlugin {
__New() {
throw Error("不能直接实例化抽象类")
}
Process(Data) {
throw MethodError("子类必须实现 Process() 方法")
}
Validate() {
throw MethodError("子类必须实现 Validate() 方法")
}
}
class JsonPlugin extends AbstractPlugin {
Process(Data) {
return JSON.Stringify(Data)
}
Validate() {
return true
}
}
更优雅的写法是创建一个工厂函数来检查:
PluginInterface() {
; 返回一个"契约"描述对象,用于运行时校验
return Map(
"required_methods", ["Process", "Validate", "GetName"],
"required_props", ["Version"]
)
}
class AudioPlugin {
static Version := "1.0"
Process(Data) => "处理音频: " Data
Validate() => true
GetName() => "音频插件"
}
; 运行时校验
AssertImplements(AudioPlugin, PluginInterface()) ; 通过
四、元表(MetaTable)与自定义行为
AHK v2 的每个对象都有一个元表(MetaTable),定义了对象的底层行为——属性查找、枚举、调用等。这是实现高级 OOP 技巧的基石。
4.1 __Get / __Set:属性代理
class ProxyObject {
_Data := Map()
; 未定义属性的 getter
__Get(Name, Params*) {
if this._Data.Has(Name)
return this._Data[Name]
return unset ; 返回 unset = 继续沿原型链查找
}
; 未定义属性的 setter
__Set(Name, Params*) {
; Params 是索引参数,如 obj[Idx1, Idx2] := Value
if Params.Length
throw Error("不支持索引赋值")
this._Data[Name] := Value
}
}
p := ProxyObject()
p.Name := "河许人" ; 调用 __Set
MsgBox p.Name ; 调用 __Get → "河许人"
MsgBox p.Age ; 调用 __Get (不存在) → "" (返回空)
4.2 __Call:方法调用代理
class Router {
_Routes := Map()
Route(Path, Handler) {
this._Routes[Path] := Handler
}
__Call(Name, Params*) {
; 已定义的方法走正常路径
if this.HasMethod(Name)
return ; 不拦截
; 未定义的方法 → 检查是否为路由
if this._Routes.Has(Name)
return this._Routes[Name](Params*)
throw MethodError("未找到方法或路由: " Name)
}
}
app := Router()
app.Route("home", (*) => "首页")
app.Route("about", (*) => "关于我们")
MsgBox app.home() ; 通过 __Call 路由到 "首页"
4.3 __Enum:自定义迭代
class Range {
__New(Start, End) {
this.Start := Start
this.End := End
}
__Enum(IndexCount) {
; IndexCount = 1: for val in obj → 返回 [value]
; IndexCount = 2: for k, v in obj → 返回 [index, value]
current := this.Start - 1
stop := this.End
EnumFunc(&val) {
current++
if current > stop
return false
val := current
return true
}
return EnumFunc
}
}
for num in Range(1, 5)
MsgBox num ; 1, 2, 3, 4, 5
五、核心设计模式实战(完整案例)
以下 5 个实战案例展示 AHK v2 OOP 在生产中的最佳实践。
5.1 观察者模式(Observer / Event Emitter)
事件驱动是 GUI 编程和自动化的核心范式。
class EventEmitter {
static _NextId := 0
__New() {
this._Listeners := Map()
}
; 注册事件监听
On(Event, Callback, Addr := 0) {
if !this._Listeners.Has(Event)
this._Listeners[Event] := Map()
EventEmitter._NextId++
id := EventEmitter._NextId
this._Listeners[Event][id] := Callback
return id ; 返回订阅 ID,用于取消
}
; 取消监听
Off(Event, Id) {
if this._Listeners.Has(Event)
this._Listeners[Event].Delete(Id)
}
; 触发事件
Emit(Event, Args*) {
if !this._Listeners.Has(Event)
return
for id, cb in this._Listeners[Event]
cb(Args*)
}
}
class FileWatcher extends EventEmitter {
__New(TargetDir) {
super.__New()
this.TargetDir := TargetDir
this._KnownFiles := Map()
this._Scan()
}
_Scan() {
Loop Files, this.TargetDir "\*.*"
this._KnownFiles[A_LoopFileName] := A_LoopFileTimeModified
}
Check() {
seen := Map()
Loop Files, this.TargetDir "\*.*" {
seen[A_LoopFileName] := true
if !this._KnownFiles.Has(A_LoopFileName) {
this.Emit("created", A_LoopFileName)
} else if this._KnownFiles[A_LoopFileName] != A_LoopFileTimeModified {
this.Emit("modified", A_LoopFileName)
}
}
for name in this._KnownFiles {
if !seen.Has(name) {
this.Emit("deleted", name)
}
}
this._Scan()
}
}
; 使用
watcher := FileWatcher("C:\Temp")
id1 := watcher.On("created", (f) => MsgBox "新文件: " f)
id2 := watcher.On("modified", (f) => MsgBox "文件已修改: " f)
SetTimer () => watcher.Check(), 1000
5.2 策略模式(Strategy Pattern)
灵活替换算法,是自动化脚本中处理"多种工具/多种方式"的首选。
class ClipboardStrategy {
Copy(Text) {
throw MethodError("子类必须实现 Copy")
}
}
class StdClipboard extends ClipboardStrategy {
Copy(Text) {
A_Clipboard := Text
if !ClipWait(0.5)
throw Error("剪贴板操作超时")
return true
}
}
class PowerShellClipboard extends ClipboardStrategy {
Copy(Text) {
; 用 PowerShell 的 Set-Clipboard(更稳定)
Text := StrReplace(Text, "'", "''")
cmd := Format('Set-Clipboard -Value ''{1}''', Text)
RunWait("powershell -Command " cmd, , "Hide")
return true
}
}
class DllCallClipboard extends ClipboardStrategy {
Copy(Text) {
; 通过 Win32 API 直接操作剪贴板
if !DllCall("OpenClipboard", "Ptr", 0)
throw Error("无法打开剪贴板")
DllCall("EmptyClipboard")
size := (StrLen(Text) + 1) * 2
hMem := DllCall("GlobalAlloc", "UInt", 0x42, "UPtr", size, "Ptr")
pMem := DllCall("GlobalLock", "Ptr", hMem, "Ptr")
StrPut(Text, pMem, "UTF-16")
DllCall("GlobalUnlock", "Ptr", hMem)
DllCall("SetClipboardData", "UInt", 13, "Ptr", hMem) ; CF_UNICODETEXT
DllCall("CloseClipboard")
return true
}
}
class ClipboardManager {
__New(Strategy := unset) {
this.Strategy := IsSet(Strategy) ? Strategy : StdClipboard()
}
SetStrategy(Strategy) {
this.Strategy := Strategy
}
CopyWithFallback(Text) {
strategies := [this.Strategy, DllCallClipboard(), PowerShellClipboard()]
errors := ""
for s in strategies {
try {
s.Copy(Text)
return true
} catch as e {
errors .= Type(s) ": " e.Message "`n"
}
}
throw Error("所有剪贴板策略均失败:`n" errors)
}
}
; 使用
cm := ClipboardManager(StdClipboard())
cm.CopyWithFallback("测试文本")
5.3 构建器模式(Builder Pattern)
构建复杂对象时避免过长的构造函数。
class HttpRequestBuilder {
__New() {
this._Url := ""
this._Method := "GET"
this._Headers := Map()
this._Body := ""
this._Timeout := 30000
this._Proxy := unset
}
; 链式方法每个都返回 this
Url(U) {
this._Url := U
return this
}
Method(M) {
this._Method := M
return this
}
Header(Name, Value) {
this._Headers[Name] := Value
return this
}
JsonBody(Data) {
this._Body := JSON.Stringify(Data)
this.Header("Content-Type", "application/json")
return this
}
FormBody(MapData) {
parts := []
for k, v in MapData
parts.Push(UrlEncode(k) "=" UrlEncode(v))
this._Body := String.Join("&", parts)
this.Header("Content-Type", "application/x-www-form-urlencoded")
return this
}
Timeout(Ms) {
this._Timeout := Ms
return this
}
; 最终构建并执行
Exec() {
if !this._Url
throw Error("URL 未设置")
com := ComObject("WinHttp.WinHttpRequest.5.1")
com.Open(this._Method, this._Url, false)
for k, v in this._Headers
com.SetRequestHeader(k, v)
com.SetTimeouts(this._Timeout, this._Timeout, this._Timeout, this._Timeout)
com.Send(this._Body)
return {
Status: com.Status,
StatusText: com.StatusText,
Body: com.ResponseText,
Headers: com.GetAllResponseHeaders()
}
}
}
; 优雅的链式调用
response := HttpRequestBuilder()
.Url("https://api.example.com/data")
.Method("POST")
.JsonBody(Map("user", "admin", "action", "query"))
.Timeout(5000)
.Header("Authorization", "Bearer token123")
.Exec()
MsgBox response.Status ": " response.StatusText
5.4 命令模式(Command Pattern)
撤销/重做系统,非常适合自动化操作的撤销。
class Command {
Execute() {
throw MethodError("子类必须实现 Execute")
}
Undo() {
throw MethodError("子类必须实现 Undo")
}
}
class MoveFileCommand extends Command {
__New(Source, Dest) {
this.Source := Source
this.Dest := Dest
}
Execute() {
FileMove(this.Source, this.Dest, true)
if ErrorLevel
throw Error("移动文件失败: " this.Source)
}
Undo() {
FileMove(this.Dest, this.Source, true)
if ErrorLevel
throw Error("撤销移动失败: " this.Dest)
}
}
class EditTextCommand extends Command {
__New(Control, OldText, NewText) {
this.Control := Control
this.OldText := OldText
this.NewText := NewText
}
Execute() {
this.Control.Value := this.NewText
}
Undo() {
this.Control.Value := this.OldText
}
}
class CommandHistory {
__New(MaxUndo := 50) {
this._History := []
this._Index := -1
this._MaxUndo := MaxUndo
}
Execute(Cmd) {
Cmd.Execute()
this._History := this._History[:this._Index + 1]
this._History.Push(Cmd)
if this._History.Length > this._MaxUndo
this._History.RemoveAt(1)
this._Index := this._History.Length - 1
}
Undo() {
if this._Index = this._History.Length
throw Error("没有可重做的操作")
this._Index++
this._History[this._Index + 1].Execute()
}
}
; 使用
history := CommandHistory()
hisCmd := EditTextCommand(myEdit, "旧文本", "新文本")
history.Execute(hisCmd)
; 撤销
history.Undo() ; 恢复到 "旧文本"
5.5 状态模式(State Pattern)
自动化流程中常见——同一个对象在不同状态下行为不同。
class DownloadState {
Name {
get => "未命名状态"
}
Start(Context) {
throw MethodError("当前状态下不能开始下载")
}
Pause(Context) {
throw MethodError("当前状态下不能暂停")
}
Resume(Context) {
throw MethodError("当前状态下不能恢复")
}
Cancel(Context) {
throw MethodError("当前状态下不能取消")
}
}
class IdleState extends DownloadState {
Name {
get => "空闲"
}
Start(Context) {
MsgBox "开始下载: " Context.Url
Context.State := DownloadingState()
Context.SetTimer(Context._DoDownload, -1) ; 立即异步执行
}
}
class DownloadingState extends DownloadState {
Name {
get => "下载中"
}
Pause(Context) {
MsgBox "暂停下载"
Context.State := PausedState()
}
Cancel(Context) {
MsgBox "取消下载"
Context.State := CancelledState()
Context._Cleanup()
}
}
class PausedState extends DownloadState {
Name {
get => "已暂停"
}
Resume(Context) {
MsgBox "恢复下载"
Context.State := DownloadingState()
Context.SetTimer(Context._DoDownload, -1)
}
Cancel(Context) {
MsgBox "取消下载(已暂停状态)"
Context.State := CancelledState()
Context._Cleanup()
}
}
class CancelledState extends DownloadState {
Name {
get => "已取消"
}
}
class CompletedState extends DownloadState {
Name {
get => "已完成"
}
}
class Downloader {
__New(Url, TargetFile) {
this.Url := Url
this.TargetFile := TargetFile
this.State := IdleState()
this._Progress := 0
}
Start() => this.State.Start(this)
Pause() => this.State.Pause(this)
Resume() => this.State.Resume(this)
Cancel() => this.State.Cancel(this)
_DoDownload() {
; 模拟下载过程
loop 10 {
if Type(this.State) != "DownloadingState"
return ; 状态变了,停止
this._Progress := A_Index * 10
Sleep(500)
}
this.State := CompletedState()
MsgBox "下载完成!"
}
_Cleanup() {
if FileExist(this.TargetFile)
FileDelete(this.TargetFile)
this._Progress := 0
}
}
六、OOP 核心避坑指南
坑 1:忘记调用 super.__New
class Parent {
__New() {
MsgBox "父类初始化"
}
}
class Child extends Parent {
__New() {
; 忘了 super.__New()
MsgBox "子类初始化"
}
}
c := Child() ; 父类初始化不会执行!
解决:在子类 __New 的第一行(或适当位置)调用 super.__New()。
坑 2:__Delete 中抛出异常或访问已清理资源
class Fragile {
_Data := [1, 2, 3]
__Delete() {
; 危险!不确定 _Data 是否还存在
for v in this._Data { ; 可能抛出异常
; ...
}
throw Error("在析构中抛异常") ; 一定不要这样做
}
}
解决:__Delete 中只做简单的、无异常的资源释放。用 try 包裹清理操作。
坑 3:静态属性与实例属性混淆
class Counter {
static Value := 0
}
c1 := Counter()
c2 := Counter()
c1.Value := 5 ; 注意!这实际上给 c1 实例创建了新属性 Value
MsgBox c2.Value ; 还是 0,不是 5!
MsgBox Counter.Value ; 还是 0!
; 正确修改静态属性:
Counter.Value := 5
坑 4:== 比较对象而非引用
obj1 := {x: 1}
obj2 := {x: 1}
MsgBox obj1 == obj2 ; 0 (false) — 不是同一个引用
MsgBox obj1 = obj2 ; 0 (false)
MsgBox obj1 is Object ; 1 (true)
MsgBox Type(obj1) == Type(obj2) ; 1 (true)
比较对象内容需要自己实现比较方法,或使用 JSON 序列化后对比。
坑 5:for 循环中迭代方法返回的数组
class DataSource {
Items := [1, 2, 3]
GetItems() => this.Items
}
ds := DataSource()
for item in ds.GetItems() ; 这行代码在语法上是对的
MsgBox item
注意:__Enum 只对对象实例生效。如果是方法返回的数组,for ... in 迭代的是那个数组对象。
七、实战:完整的插件管理系统
用 OOP 设计模式构建一个可扩展的插件管理器,整合了工厂模式、注册模式和策略模式。
总结
AutoHotkey v2 的 OOP 系统是一个完整、现代、高效的面向对象编程框架。它不是"给脚本语言加个糖",而是从语言底层构建的抽象工具。
| 特性 | v1 | v2 |
|---|---|---|
| 类定义 | 简陋的 class |
完整的 class + extends |
| 属性 | 无 | Property getter/setter |
| 静态成员 | 全局变量模拟 | static 关键字+静态属性 |
| 继承 | base 手动链 |
extends 自动链+super |
| 元表 | 有限的自定义 | 完整 __Get/__Set/__Call/__Enum |
| 异常 | try/catch 基础 |
Error 对象体系+完整栈追踪 |
如果你从 v1 过来,最大的改变是:放弃全局变量和"手动链"思维,拥抱类和原型链。如果你从其他 OOP 语言过来,需要注意:AHK 的 this 是隐式传参,类即对象,以及 __Delete 需要谨慎处理。
延伸阅读:
- 官方文档:Classes
- 官方文档:Custom Objects
- AutoHotkey v2 命名管道深度实战

