作者:河许人 2024年4月13日,第11次更新,字数30264个,案例代码126段
在AutoHotkey中,对象(也称为类)是一种重要的编程概念,特别是自从AutoHotkey v2.0版本开始。大幅优化了对象编程,使其更现代化、更具灵活性。对象编程在AutoHotkey中变得至关重要,无论是对于新手还是有经验的开发者。
一、什么是对象?
在前文中,我们已经了解了变量和不同类型的数组,如简单(线性)数组、关联数组、多维数组等。这些都是常见的数据容器,用来存储和组织数据。对象不再是简单数据容器了,而是是一种数据结构,它可以包含数据和与这些数据相关的操作。对象将数据和操作封装在一起,使得代码更加模块化、可维护和可重用。其实在ahk中对象的概念非常宽泛,变量也是对象的一种形式,数组、还有我们常规认识的{}的这种形式都是对象.
以简单的比喻来说,对象就像是一个容器,可以存放各种类型的数据和方法。例如,我们可以创建一个名为”person”的对象,它包含了姓名、年龄、性别等属性,并且提供了一些方法如获取姓名、修改年龄等。
对象通常由一组属性和方法组成:
- 属性:对象的属性是描述对象特征的数据。
- 方法:对象的方法就是函数。
二、为什么用对象?
对象是编程中属性(数据)和方法(函数)的统一整合,是我们学习过的核心概念的结合体。数据和函数是编程的两个关键概念,而对象则将它们有机地结合在一起。在对象中,我们可以将数据存储在属性中,而方法则允许我们对这些数据进行操作和处理。
在获取或设置值时,对象的属性工作方式类似于键。然而,与简单的键相比,属性的值可以包含更复杂的数据结构或者可以动态计算生成的值,这使得属性更加灵活和功能强大。在 AHK v1 中,键和属性的语法是等价的,它们指向相同的内容,无论是键(或值属性)还是动态属性,都可以通过相同的语法来访问和操作。
对象是“复用”核心思想的重要延伸,是面向对象编程的关键发展。在编程中,复用是一种重要的原则,它允许我们有效地利用已有的代码和功能,减少重复劳动并提高代码的可维护性和可扩展性。在 AutoHotkey 中,最初的复用形式是简单的“标签”,但由于无法传递参数,对不同的数据进行处理时显得不够灵活。随后引入了“函数”,它在标签的基础上实现了参数传递和返回值,使得代码更加模块化和可复用。而对象则进一步将数据域和方法封装在一起,提供了更高级别的抽象和灵活性,使得代码的复用性达到了新的高度。
关于对象的应用是在 AutoHotkey 版本11.20.00之后开始完善的,并持续进行着改进和扩展。通过引入对象的概念,AutoHotkey 在面向对象编程方面逐渐变得更加完善和成熟。通过对象的递进关系,AutoHotkey 向着更加“面向对象”的方向发展,不断改进和完善,相信在编写相对大型的项目时,AutoHotkey 将会更加得心应手,提供更高效、灵活和可维护的编程体验。
综上所述,对象不仅是数据和方法的集成体,更是编程中复用核心思想的重要体现。学习和应用对象,有助于提高代码的可重用性、可维护性和可扩展性,是编写高质量软件的关键一步。
三、对象详解
AutoHotkey对象, 所有的内容, 都可以归结为对 (键) 与 (值) 的操作。
(一)对象分类
对象分为内置对象和自定义对象。

(二)创建与释放
1.创建对象
2.释放对象
脚本不会显式的释放对象. 当到对象的最后一个引用被释放时, 会自动释放这个对象. 当某个保存引用的变量被赋为其他值时, 会自动释放它原来保存的引用. 例如:
类似地, 当属性或数组元素被赋为其他值或从对象中删除时, 存储在属性或数组元素中的引用将被释放.
由于在释放一个对象时, 到这个对象的所有引用都必须被释放, 所以包含循环引用的对象无法被自动释放. 例如, 如果 x.child 引用 y 且 y.parent 引用了 x, 则清除 x 和 y 是不够的, 因为父对象仍然包含到这个子对象的引用, 反之亦然. 要避免此问题, 请首先移除循环引用.
(三)对象运算符
1. 成员访问 (Member Access):
- 用法:
Alpha.Beta - 解释: 访问对象
Alpha的属性Beta。
示例:
2. 方法调用 (Method Call):
- 用法:
Alpha.Beta() - 解释: 调用对象
Alpha的名为Beta的方法。
示例:
3. 带参数的成员访问 (Member Access with Parameters):
- 用法:
Alpha.Beta[Param] - 解释: 使用参数
Param访问对象Alpha的属性Beta。
示例:
4. 运行时确定属性或方法的名称 (Runtime Property or Method Name):
- 用法:
Alpha.%vBeta%,Alpha.%vBeta%[Param],Alpha.%vBeta%() - 解释: 在运行时根据变量
vBeta的值访问对象Alpha的属性或调用方法。
示例:
5. 默认属性访问 (Default Property Access):
- 用法:
Alpha[Index] - 解释: 使用
Index作为参数访问对象Alpha的默认属性。
示例:
6. 创建数组 (Array Creation):
- 用法:
[A, B, C] - 解释: 创建一个包含变量
A、B、C的数组。
示例:
7. 创建对象 (Object Creation):
- 用法:
{Prop1: Value1, Prop2: Value2} - 解释: 创建一个包含属性
Prop1和Prop2的对象。
示例:
名称替换允许通过计算表达式或变量来确定属性名称.
8. 可变函数调用 (Variable Function Call):
- 用法:
MyFunc(Params*) - 解释: 使用可变参数调用函数
MyFunc,Params必须是可枚举对象。
示例:
通过这些示例,你可以更好地理解在 AutoHotkey 中如何使用对象的运算符进行成员访问、方法调用、动态属性访问等操作。对象的灵活性和功能性可以帮助你编写更高效、模块化的代码,并充分利用面向对象编程的优势。
(四)扩展用法
1.自定义对象
创建自定义对象通常有两种方法:
- 专用: 创建对象并添加属性.
- 委托: 在共享 基对象 或类中定义属性.
元函数可用于进一步控制对象的行为方式.
注意: 在本节中, 对象 是 Object 类的任何实例. 本节不适用于 COM 对象.
(1)专用
属性和方法(可调用属性) 通常可以随时添加到新对象中. 例如, 一个具有一个属性和一个方法的对象可以这样构造:
你可以类似地用 thing := {foo: "bar"} 创建上面的对象. 当使用 {property:value} 表示法时, 属性不能使用引号.
调用 thing.test() 时, thing 会自动被插入到参数列表的开始处. 按照约定, 函数是通过结合对象的 “类型” 和方法名来命名的, 但这不是必要条件.
在上面的示例中, test 在被定义后可能会被赋值到其他函数或值, 在这种情况下, 原始函数将丢失, 并且无法通过此属性进行调用. 另一种方法是定义一个只读方法, 如下所示:
另请参阅: DefineProp
(2)委托
对象是 基于原型的. 也就是说, 没有在对象本身中定义的任何属性都可以在对象的基中定义. 这被称为 委托继承 或 差异继承, 因为对象可以只实现使其不同的部分, 而将其余部分委托给它的基.
虽然基对象通常也称为原型, 但我们使用 “类的原型” 来表示该类的每个实例所基于的对象, 而使用 “基” 来表示一个实例所基于的对象.
AutoHotkey 的对象设计主要受 JavaScript 和 Lua, 略带 C# 的影响. 我们使用 obj.base 代替 JavaScript 的 obj.__proto__ 和 cls.Prototype 代替 JavaScript 的 func.prototype. (使用类对象代替构造函数.)
对象的基也用于标识其类型或类. 例如, x := [] 创建 基于 Array.Prototype 的对象, 这意味着表达式 x is Array 并且 x.HasBase(Array.Prototype) 为 true, 而 type(x) 返回 “Array”. 每个类的 Prototype 都是基于其基类的 Prototype, 所以 x.HasBase(Object.Prototype) 也为 true.
对象或派生类的任何实例都可以是基对象, 但只能将对象赋值为具有相同原生类型的对象的基. 这是为了确保内置方法始终能够识别对象的原生类型, 并且仅对具有正确二进制结构的对象进行操作.
基对象可以用两种不同的方式定义:
- 通过创建一个普通对象.
- 通过定义一个类. 每个类都有一个 Prototype 属性, 包含一个对象, 该类的所有实例都基于该对象, 而类本身成为任何直接子类的基对象.
基对象可以赋值到其他对象的基属性, 但通常在创建对象时隐式地设置该对象的基.
2.创建基对象
任何对象都可以用作具有相同原生类型的任何其他对象的基. 下面的例子基于在之前的专用的例子(运行前将两者结合):
此时, other 从 thing 继承了 foo 和 test. 这种继承是动态的, 所以如果 thing.foo 被改变了, 这改变也会由 other.foo 表现出来. 如果脚本赋值给 other.foo, 值存储到 other 中并且之后对 thing.foo 任何改变都不会影响 other.foo. 当调用 other.test() 时, 它的 this 参数包含 other 而不是 thing 的引用.
(五)注意事项
对象 是 AutoHotkey 的复合或抽象数据类型. 对象可以由任意数量的 属性(可以检索或设置) 和 方法(可以调用) 组成. 每个属性或方法的名称和效果取决于特定的对象或对象类型.
- 对象是不能被包含的; 它们只是引用. 例如,
alpha := []创建一个新数组并在 alpha 中存储一个引用.bravo := alpha复制引用(不是对象) 到bravo, 因此两者都引用同一个对象. 当一个数组或变量被认为包含一个对象时, 它实际上包含的是对该对象的引用. - 只有在引用同一个对象时, 两个对象引用才被视为相等的.
- 当结果需要布尔值时, 对象总是被视为 true , 例如在
if obj,!obj或obj ? x : y. - 每个对象都有一个唯一的地址(内存中的位置), ObjPtr 函数可以检索该地址, 但通常不直接使用. 此地址唯一标识对象, 但仅在释放对象之前.
- 在某些情况下, 当一个对象被使用在不期望对象的任何上下文中, 它可能会被当作一个空字符串. 例如,
MsgBox(myObject)显示一个空的消息框. 在其他情况下, 可能会抛出 TypeError(这应该成为未来的标准).
注意: 所有从对象派生的对象都具有额外的共享行为, 属性和方法.
对象的一些使用方法包括:
- 包含项目或 元素 的集合. 例如, 数组包含一系列项, 而 Map 则将键与值相关联. 对象允许将一组值视为一个值, 赋值给单个变量, 传递给函数或从函数返回, 等等.
- 表示真实或概念性的东西. 例如: 如屏幕上某个位置的 X 坐标和 Y 坐标; 通讯录中的联系人, 包括姓名, 电话号码, 电子邮件地址等. 通过将对象与其他对象组合, 对象可用于构建更复杂的信息集.
- 封装一个或一组服务, 允许脚本的其他部分将重点放在任务上, 而不是该任务是如何执行的. 例如, File 对象提供了文件读取或写入数据的方法. 如果将信息写入文件的脚本函数接受 File 对象作为参数, 它不需要知道文件是如何打开的. 可以重复利用相同的函数将信息写入其他目标, 如 TCP/IP 套接字或 WebSocket(通过用户定义的对象).
- 以上的组合. 例如, Gui 表示 GUI 窗口; 它向脚本提供了创建和显示图形用户界面的方法; 它包含一组控件, 并通过 Title 和 FocusedCtrl 等属性提供有关窗口的信息.
适当的使用对象(特别是类) 能产生 模块化 和 可重复使用 的代码. 模块化代码通常更容易测试, 理解和维护. 例如, 人们可以改进或修改一段代码, 而不需要知道其他段的细节, 也不必对这些段做相应的修改. 可重复使用的代码节省了时间, 避免了一遍又一遍地为相同或相似的任务编写和测试代码.
(六)杂项
1.原始值
原始值, 如字符串和数字, 不能有自己的属性和方法. 然而, 原始值支持与对象相同类型的委托. 也就是说, 对原始值的任何属性或方法调用都被委托给预定义的原型对象, 也可以通过相应类的 Prototype 属性访问. 以下类与原始值相关:
- 原始值 (继承 Any)
- 数字
- 浮点数
- 整数
- 字符串
- 数字
虽然检查字符串的类型通常更快, 但是可以通过检查值是否具有给定的基来测试值的类型. 例如, 如果 n 是一个纯整数或浮点数, 则 n.HasBase(Number.Prototype) 或 n is Number 为真, 但如果 n 是一个数字字符串, 则不为真, 因为字符串不是从数字派生而来的. 相比之下, 如果 n 是数字或数字字符串, IsNumber(n) 为真.
ObjGetBase 和 Base 属性在适当的时候返回预定义的原型对象之一.
注意, 对于 AutoHotkey 的类型层次结构中的任何值, x is Any 通常为真, 而对于 COM 对象则为假.
2.添加属性和方法
通过修改该类型的原型对象, 可以为该类型的所有值添加属性和方法. 但是, 由于原始值不是对象并且不能具有自己的属性或方法, 因此原始原型对象不会从 Object.Prototype 派生. 换句话说, 默认情况下无法访问诸如 DefineProp 和 HasOwnProp 之类的方法. 可以间接调用它们. 例如:
尽管原始值可以从其原型继承值属性, 但是如果脚本尝试在原始值上设置值属性, 则会引发异常. 例如:
尽管可以使用 __Set 和属性设置器, 但它们没有用, 因为应将原始值视为不可变的.
3.引用计数
当脚本不再引用对象时, AutoHotkey 使用基本引用计数机制来自动释放对象使用的资源. 脚本作者不应该显式地调用这种机制, 除非打算直接处理未托管的对象的指针.
表达式中的函数, 方法或运算符返回的临时引用在表达式的计算完成或中止后释放. 在下面的例子中, 新的 GMem 对象只有在 MsgBox 返回后才被释放.
注意: 在本例中, .ptr 可以省略, 因为 Ptr 参数类型允许对象具有 Ptr 属性. 但是, 上面显示的模式甚至可以用于其他属性名.
如果希望在对象的最后一个引用被释放后运行一段代码, 可通过 __Delete 元函数实现.
已知限制:
- 循环引用必须被打破, 对象才能被释放. 有关详情和示例, 请参阅释放对象.
- 虽然程序退出时, 静态和全局变量中的引用会自动释放, 但非静态局部变量或表达式求值堆栈中的引用不会. 只有在函数或表达式能够正常完成时, 才会释放这些引用.
虽然当程序退出时, 操作系统会回收对象占用的内存, 但是除非释放了对对象的所有引用, 否则不会调用 __Delete. 如果它释放了操作系统不能自动回收的其他资源, 比如临时文件, 那么这一点很重要.
4.对象的指针
在一些罕见的情况中, 可能需要通过 DllCall 传递对象到外部代码或把它存储到二进制数据结构以供以后检索. 可以通过 address := ObjPtr(myObject) 来检索对象的地址; 不过, 这样实际上创建了一个对象的两个引用, 但程序只知道对象中的一个. 如果对象的最后一个 已知 引用被释放, 该对象将被删除. 因此, 脚本必须设法通知对象它的引用增加了. 可以这样做(下面两行是等同的):
脚本还必须在对象使用该引用完成时通知该对象:
一般来说, 对象地址的每个新副本都应该被视为对象的另一个引用, 所以脚本必须在获得副本之后立即调用 ObjRelease, 并在丢弃副本之前立即调用 ObjRelease. 例如, 每当通过类似 x := address 这样复制地址时, 就应该调用一次 ObjAddRef. 同样的, 当脚本使用 x 完时(或者用其他值覆盖 x), 就应该调用一次 ObjRelease.
要将地址转换为一个合适的引用, 请使用 ObjFromPtr 函数:
ObjFromPtr 假定 address 是一个引用计数, 并声称对它的所有权. 换句话说, myObject := "" 会导致原本由 address 代表的引用被释放. 之后, address 必须被认为是无效的. 如果要改用一个新的引用, 可以使用下面的一种方法:
四、类
学习到这部分,已经是入门阶段最难的部分了,其实不是知识难,而是可查资料太少了,案例很多,但没人给你解释都是啥意思。
(一)类是什么?
在 AutoHotkey 中,类就是使用 class 定义的一种对象。有些特殊的方法和属性,也有继承、嵌套等应用。
类有两种:
- 具有原型对象(“父亲”)的类(继承), 该类的所有实例都基于该对象. 原型对象包含所有适用于该类实例的方法和动态属性. 这包括所有没有
static关键字的属性和方法. - 没有原型对象的类, 只包含静态方法和属性. 这包括所有带有
static关键字的的所有属性和方法, 以及所有嵌套的类. 这些不适用于特定实例, 可以通过按名称引用类本身来使用.
(二)基本概念
1.术语:对象/实例/类。
- 简单来说:
- 类是一个蓝图对象。
- 实例是基于类蓝图创建的对象。
- AutoHotkey 有一个基本对象类,以及其他内置类(在下面列出,例如 RegExMatch,SafeArray)。
2.术语:实例和静态变量、方法(极端重要,必须理解)
(1)实例变量
实例变量是属于类的每个实例(对象)独立拥有的数据。每个对象都有自己的实例变量副本。在类的定义中,可以使用类似赋值的语法来声明和初始化实例变量,无需使用 this. 前缀:
每当使用 ClassName() 创建一个类的新实例时,系统会自动初始化这些实例变量。这些初始化操作会在所有基类声明被求值之后、但在调用 __New 方法之前执行。系统会自动创建一个名为 __Init 的方法来实现这一过程。__Init 方法会被调用,并将实例变量的声明插入其中,确保在对象初始化时设置这些变量。
在实例变量的声明中,可以通过 this 关键字访问其他实例变量和方法。全局变量可以被读取,但不能被赋值。在表达式中进行额外的赋值操作(或使用引用操作符)通常会在 __Init 方法中创建一个局部变量。例如,x := y := 1 会设置 this.x 和一个局部变量 y(初始化器完成后会释放局部变量)。
要访问实例变量,必须使用 this 关键字指定目标对象,例如 this.InstanceVar。
从外部访问实例变量时,首先要实例化 ClassName(),然后可以修改实例的变量值。这样的修改操作不会影响类本身的定义。
支持形如 x.y := z 的声明语法,但前提是变量 x 已在类中定义过。例如,x := {},x.y := 42 声明了变量 x 并初始化了 this.x.y。
(2)静态/类变量
静态或类变量属于整个类,而不是类的每个实例。它们的值可以被所有对象和子类继承。声明方式与实例变量类似,但要加上 static 关键字:
这些变量只在初始化类时计算一次,会自动通过一个名为 __Init 的静态方法进行处理。
在声明静态变量时,可以像声明实例变量那样使用其他变量和方法,但不能使用 this 关键字。
如果想在其他地方给类变量赋值,必须明确指定类名,例如 ClassName.ClassVar := Value。子类可以继承父类的类变量,如果子类没有定义同名变量,它会继承父类的值。但是,如果在子类中对这个变量进行赋值,它会在子类中创建一个新的变量。
支持形如 x.y := z 的声明语法,但前提是变量 x 已在类中定义过。例如,static x := {},x.y := 42 声明了变量 x 并初始化了 ClassName.x.y。
在外部访问时,直接使用类名和类变量的形式,例如 ClassName.ClassVar。需要注意的是,这些变量在实例化时不会被继承。
3.术语:对象,键/方法。
- 对象将数据/变量(键)和函数(方法)的概念结合起来。
4.术语:属性。
- 属性可以像键一样具有值,可以进行获取/设置。在 AHK v2 中称为“值属性”。
- 属性可以像方法一样,其值由 getter/setter 函数生成。在 AHK v2 中称为“动态属性”。
- 在使用时,这两种类型的属性看起来是一样的。(虽然在定义时看起来不同。)
- 在 AHK v1 中,键和属性共享相同的命名空间。
obj["key"]和obj.property语法通常是可互换的。 - 在 AHK v2 中,键和属性是不同的。
obj["key"]和obj.property语法是分开的。
5.术语:自定义类。
- 用户可以创建自定义类,即自己的类蓝图。
- 如果创建一个名为“MyClass”的自定义类,将创建一个名为“MyClass”的变量。可以通过 ListVars 或“View, Variables and their contents”(在 AHK 的“主窗口”上)查看它。
- (例如,如果通过
obj := {}创建基本对象实例,并定义一个名为“MyClass”的类,那么IsObject(obj)和IsObject(MyClass)都将报告为 true。) - 自定义类确定实例对象的键/属性/方法。还可以阻止添加新的键/属性/方法。
6.6 个方法:__Init/__New/__Get/__Set/__Call/__Delete。
- 创建自定义类时,以下 6 个方法对于自定义非常重要。
__Init(脚本不应使用):处理创建对象实例时的情况。__New:处理创建对象实例时的情况。__Get/__Set:处理获取/设置不存在的键/属性。__Call:处理调用存在/不存在的方法。__Delete:处理删除对象实例时的情况。
7.术语:基础对象。
- 对象的基础对象通常包含决定该对象如何工作的键/属性/方法。
- 在 AHK v1 中,基本对象没有基础对象。
- 在 AHK v1 中,使用“class”关键字创建的类对象没有基础对象。(除非手动添加。)
- 通过“new”关键字创建的实例对象是类的实例,实例对象的基础对象是类对象。
- 如果尝试访问对象的键/属性/方法,但找不到该项,则会检查对象的基础对象是否存在该项。
- 如果存在,则继续检查基础对象的基础对象,以此类推,直到达到没有基础对象的基础对象。
8.术语:枚举器。
2 个方法:_NewEnum/Next。
for 循环调用对象的_NewEnum方法。_NewEnum方法返回一个称为枚举器对象的对象。- 枚举器对象将具有一个
Next方法,该方法将返回键/值对,直到没有键/值对为止。 - 枚举器对象可能返回不基于对象内容的键/值对,而是计算得到的键/值对(例如平方数)。它可以无限期返回键/值对。
- 通常,
Next方法会 ByRef 输出 2 个值(键名和值),但它也可以输出其他数量的值。
9.术语:超类/子类,嵌套类
- 超类/子类:超类具有一些特征,子类继承这些特征并具有自己的特征。
- 对于基于子类的对象,如果超类和子类共享一个特征,则子类优先。
- 嵌套类:在另一个类内部定义的类。
(三)基础入门
1.创建类
创建类很简单,根据上面的分类,具有原型对象的需要使用extends关键字,没有原型对象的直接使用class关键字就可以的。
2.超类/子类
(1)什么是继承?
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。
多个类可以称为子类,单独这个类称为父类、超类或者基类。
子类可以直接访问父类中的非私有的属性和行为。
通过 extends 关键字让类与类之间产生继承关系。
- 当创建超类的实例时,不影响子类。
- 当创建子类的实例时,如果子类中不存在某个键/属性/方法,将会检查超类。
- 例如,在子类的实例中,如果超类和子类中都有同名的方法,则子类中的方法优先。
3.嵌套类
嵌套类是指在一个类的内部定义另一个类的情况。在面向对象编程中,一个类可以包含其他类的定义,这些被包含的类称为嵌套类或内部类。
嵌套类定义允许类对象与外部类的静态或类变量关联,而不是与独立的全局变量关联。举例来说,在上面的代码中,class NestedClass 创建了一个类对象,并将其存储在 ClassName.NestedClass 中。其他类可以继承这个 NestedClass,或者使用自己的嵌套类来替代它。在这种情况下,可以通过 WhichClass.NestedClass() 来实例化适当的类。
然而,嵌套一个类并不会导致它与外部类有任何特殊的关系。嵌套类不会自动实例化,也不会与外部类的实例产生连接,除非在脚本中显式地建立连接。
另外,由于 Object 方法的工作方式,调用 WhichClass.NestedClass() 会隐式地将 WhichClass 作为第一个参数传递给 NestedClass。这实际上相当于调用 WhichClass.NestedClass.Call(WhichClass)。除非重写了 static Call() 方法,否则这个参数会自动传递给 __New 方法。
- 嵌套类可以从包含它的类中访问,但不会列在其内容中。
4.实例化对象
实例化是面向对象编程中的一个重要概念,指的是根据类的定义创建类的实例(也称为对象)。在程序执行过程中,类是一个抽象的模板或蓝图,而实例则是根据这个模板创建出来的具体对象,具有独特的属性和行为。
下面详细解读实例化的过程和相关概念:
1. 类和对象的关系
- 类(Class):类是一种数据结构,用于描述具有相同属性(数据成员)和方法(函数成员)的对象的集合。它定义了对象的属性和行为。
- 对象(Object):对象是类的实例化结果,是内存中具体存在的实体,具有类定义的属性和行为。每个对象都是类的一个实例。
2. 实例化过程
实例化是通过类来创建对象的过程。当程序执行创建对象的代码时,会按照以下步骤进行实例化:
- 选择合适的类:首先根据程序的需要,选择要实例化的类。类定义了对象的属性和方法,确定了对象的行为。
- 分配内存空间:在内存中为对象分配足够的空间,用于存储对象的数据成员和方法。
- 初始化对象:调用类的构造函数(如果有的话)来初始化对象的状态。构造函数是一种特殊的方法,在对象创建时自动调用,用于初始化对象的属性。
- 返回对象的引用:实例化完成后,返回指向对象的引用或指针。通过这个引用,程序可以访问和操作对象的属性和方法。
3. 实例化的特点和作用
- 封装性:实例化是面向对象编程中实现封装的重要手段。通过类和对象的机制,可以将数据和操作封装在一起,提高代码的安全性和可维护性。
- 继承性:实例化过程中,如果类之间存在继承关系,子类会继承父类的属性和方法,从而实现代码的复用和扩展。
- 多态性:实例化时可以根据具体的对象类型调用相应的方法,实现多态的特性,提高代码的灵活性和扩展性。
在AutoHotkey v1.1中,通过new关键字进行实例化,在AutoHotkey v2.0版本,删除了new关键字,直接使用类名()进行实例化。
5.对象的基
(1)基本特征
- 当子类扩展超类时,超类是子类的基。
- 例如,这里
C.base是B,C.base.base是A。
(2)修改基
这些示例展示了以下内容:
- 如果创建了一个名为 ‘base’ 的键(/值属性),这将覆盖 ‘base’ 属性。
- 因此,’obj.base.__Class’ 获取来自名为 ‘base’ 的属性的内容。
- 但是,当 ‘obj.__Class’ 无法找到名为 ‘__Class’ 的属性时,它会检查基础对象,而不是检查名为 ‘base’ 的键(/值属性)。因此,在这方面,创建 ‘base’ 键并没有覆盖 ‘base’ 属性。
一些定义/修改基础对象的示例,以改变获取/设置值的方式:
6.AutoHotkey 的基本类对象
AutoHotkey 将 3 个概念合并为一个内置的基本对象类型:
- 线性数组(例如,obj[1] := “value”)(又称列表/向量)
- 关联数组(例如,obj[“key”] := “value”)(又称字典/映射)
- 默认类(自定义/内置,包括键/值属性/动态属性/方法,可以添加/修改/删除,用于创建自定义类)
例如,创建 AHK 基本对象的一些方式。 注意:在AutoHotkey v1.1版本中,AHK 基本对象没有基对象,而在v2.0版本是有基对象的。下面两段代码进行了验证:
注意:在 AutoHotkey 中,线性数组是具有 0 或多个整数键的数组,键从 1 开始。
当创建自定义类时,使用 AHK 基本对象作为模板。
内置的键/属性/方法可以被重写/移除,也可以添加额外的键/属性/方法。
默认情况下,对于可以添加到自定义类的键没有限制(它的行为类似于关联数组)。这可以通过指定自定义的 __Set 方法(稍后会讨论)来改变。
(1)内置方法和属性
下面是AutoHotkey v1.1基本对象的内置方法和属性列表,在上面对象部分已经对v 2.0的方法和属性进行了讲解,这里不再进行赘述。
基本对象:仅适用于整数键的方法(7):
InsertAt/RemoveAt:在任意位置添加/移除键(并移动后续键)Push/Pop:在数组末尾添加/移除键MinIndex/MaxIndex/Length:获取最小/最大键索引以及键的数量
基本对象:适用于所有键的方法(8):
Delete:删除键Count:获取键的数量SetCapacity/GetCapacity:设置/获取对象的键计数容量或值的字符串大小容量GetAddress:获取值的字符串缓冲区地址(如果值是字符串)_NewEnum:返回一个用于遍历对象键/值的枚举器对象HasKey:检查对象是否包含指定键Clone:创建对象的浅复制
基本对象:属性:
base:对象实例所基于的对象(如果在实例中未找到键/属性/方法,则检查基对象)
额外的方法:
__Init:处理对象实例创建时的初始化(不应由脚本使用)__New:处理对象实例创建时的初始化__Get/__Set:处理获取/设置不存在的键/属性__Call:处理调用不存在的方法__Delete:处理对象实例的删除
额外的方法(进一步):
Next:用于遍历对象键的方法ToString:返回一个字符串(注意:AHK v2 中的String函数会检查对象是否有ToString方法)
额外的属性:
__Class:对象实例的类名
一些额外的注意事项
- 键名可以是整数类型(正数/0/负数)或字符串类型。
- (键名也可以是对象,例如
o := {[]:1}。) - 键名是唯一的,不能有两个相同名称的键。
- 当使用超出某一大小的整数作为键名时,这些键名会以字符串形式存储(而不是整数)。
- 在 AHK v1 中,键名是不区分大小写的。区分大小写的替代方法是使用
Scripting.Dictionary对象或具有__Call方法的自定义类,该方法可以根据传递给它的键名的大小写执行操作。 - 值可以是字符串/整数/浮点数/对象引用/函数引用,以及可能的其他实体。(AutoHotkey 基本对象非常灵活,对值的类型没有限制。)
- 当对对象进行 for 循环时,整数键名(及其值)按数字顺序返回,然后按字母顺序返回字符串键名(及其值)。 (因此,要将整数视为字符串,可以使用前缀字符(例如 ‘z’)用于整数和字符串。)
- 注意:创建与方法/属性同名的键可能会阻止对该方法/属性的访问。例如,如果创建名为 ‘HasKey’ 的键,这将干扰
HasKey方法的使用。
AUTOHOTKEY 对象函数
- 以下是与对象相关的所有内置 AutoHotkey 函数的列表供参考。
- (此列表旨在完整,但可能会有其他/未来的函数符合条件。)
具有方法等效的函数
- 注意:AutoHotkey 有内置方法,但这些方法可以被覆盖。
- 例如,可以通过定义自定义的
HasKey方法来覆盖HasKey方法。 - 例如,如果存在称为
HasKey的键(/值属性),则HasKey方法会失败。 - 许多(但不是所有)ObjXXX 函数的目的是绕过任何已被覆盖的方法行为,而是使用默认行为。
AHK v1.1 对象方法
基本对象:仅适用于整数键的方法(7):
ObjInsertAt/ObjRemoveAtObjPush/ObjPopObjMinIndex/ObjMaxIndex/ObjLength
基本对象:适用于所有键的方法(8):
ObjDeleteObjCountObjSetCapacity/ObjGetCapacityObjGetAddressObjNewEnum[注意:没有下划线,与 ‘_NewEnum’ 不同]ObjHasKeyObjClone
AHK v2.0 对象方法
- 静态方法:
- Call: 创建一个新对象.
- 方法:
- Clone: 返回对象的一个浅拷贝.
- DefineProp: 定义一个新的自有属性.
- DeleteProp: 删除对象拥有的属性.
- GetOwnPropDesc: 返回给定自有属性的描述符, 兼容于 DefineProp.
- HasOwnProp: 如果对象拥有该名称的属性, 则返回 1(true).
- OwnProps: 枚举一个对象自有的属性.
- 属性:
- Base: 检索或设置一个对象的基对象.
- 函数:
- ObjSetBase: 设置对象的基对象.
- ObjGetCapacity, ObjSetCapacity: 检索或设置对象所包含属性的容量.
- ObjOwnPropCount: 检索对象包含的自有属性的数量.
- ObjHasOwnProp, ObjOwnProps: 等同于相应的预定义方法, 但不能被覆盖.
其他函数
Array/Object:创建一个数组/对象,分别相当于obj := []和obj := {}(注意:在 AHK v1 中,这两者都创建基本对象)(注意:AHK v2 使用[]/{}/Map()分别创建数组/对象/映射)ComObjActive/ComObjArray/ComObjConnect/ComObjCreate/ComObject/ComObjError/ComObjFlags/ComObjGet/ComObjQuery/ComObjType/ComObjValue:COM 对象不在本章节中讨论IsFunc:检查是否存在具有特定名称的函数(AHK v1 仅限:可以检查对象是否为函数引用,AHK v2 中可以使用hasmethod代替)IsObject:检查变量是否为对象ObjAddRef/ObjRelease:修改对象的引用计数(使用ObjAddRef,然后ObjRelease,可以检索计数,而不更改它)ObjBindMethod:为对象方法创建一个 BoundFunc 对象(即存储一个方法,以及可选的一些初始参数,作为对象变量)(即创建一个行为类似函数的变量)ObjGetBase/ObjSetBase:获取/设置对象的基对象ObjRawGet/ObjRawSet:获取/设置键(/值属性)的值,绕过任何自定义类行为String:基于变量返回一个字符串,将检查对象是否有 ‘ToString’ 方法StrSplit:基于分隔符拆分字符串创建一个数组Type:获取变量的类型(AutoHotkey v2.0)
8.自定义类示例:动物园类
这里是一个示例自定义类,包含多个键、方法和属性,以便您看看它的样子。
定义类之后,我们使用 for 循环列出了 4 个对象的内容(2 对象对):
- 实例对象(从类蓝图创建的单个对象),及其基础对象。
- 类对象(类蓝图存储为类对象),及其基础对象。(在 AHK v1 中,类对象没有基础对象,除非手动添加。)
一般来说,在 AHK v1 中,自定义类的实例具有基础对象。基础对象存储影响对象工作方式的内容。
但是 AHK 基础对象和类对象可以手动设置基础对象。
(注意:尝试探查 AHK 基础对象的基础对象,以列出任何键/属性/方法,不会显示任何内容。因为它没有基础对象。)
从检查对象内容中我们可以学到:
- 当基于类对象创建实例对象时,实例对象的基础对象是类对象的克隆。
- 创建一个
__Class属性,对应于类定义开头指定的类名称。
关于 __Init:
- 尽管我们在类对象中定义了
MyValueProperty,但我们在类对象的内容中没有看到它列出。(MyValueProperty是通过__Init方法创建的。) - 列出了
__Init方法,即使我们没有指定一个。__Init方法创建MyValueProperty。如果从类定义中移除MyValueProperty := "MyValuePropertyValue"这行,则在内容列表中不会出现__Init方法。 - 因此,
__Init方法是由 AHK 自动为我们创建的,它用于创建对象实例的键(/属性值)。
在 AHK v1 中,基础对象和自定义类对象没有基础对象。(虽然它们可以随后手动设置基础对象。)
自定义类的实例对象具有类对象作为其基础对象。
编辑基础对象时要小心,它会影响共享该基础对象的现有和未来实例对象。
其他说明: 类定义中 ‘base’ 关键字的可用性。
注意: 我还没有找到关于 AHK 基础对象是否具有基础对象的明确答案。
例如,这表明 AHK 基础对象没有基础对象:
但可以说在概念上,AHK 基础对象确实具有默认基础对象。例如,如果一个类的实例没有自己的 MyMethod 方法,它会检查基础对象中是否有 MyMethod。类似地,如果 AHK 基础对象没有自己的自定义 HasKey 方法,它会回退到默认的 HasKey 方法。
注意: AHK 文档讨论了非对象的“默认基础对象”。例如,当执行 "mystring".method() 或 myvar.method() 时,如果 var 不包含对象,则定义了会发生什么。
这一章暗示了我们将在接下来的章节中讨论的几乎所有内容。
还将提及的其他 3 个内容是:超类/子类(父类/子类,扩展类)、嵌套类(类内类)和枚举器对象。
超类/子类和嵌套类将在接下来的两章中介绍。
之后,我们将更详细地研究自定义类的特定方面。
最后,我们将考虑枚举器对象。这是因为与枚举器相关的问题与通常适用于类的问题有些分离。
__CLASS 属性和基础对象:追踪基础
- 如果我们定义一个空的类,它将产生一个与 AHK 基本对象相同的对象,唯一的区别是类名。
- 从类对象创建的任何实例对象都会在其基础对象中具有一个名为 ‘__Class’ 的属性。实例对象的基础对象就是类对象本身。’__Class’ 的值是类的名称。
- 在下面的示例中,我们将演示直接修改 ‘base’ 属性的值,并通过 ‘obj.base := ‘ 和 ObjSetBase 分配一个基础对象。
- 我们还将通过 for 循环演示列出对象的键/值对。
从上面的测试中,我们看到 obj2.base 有一个名为 ‘__Class’ 的属性,但 obj2 没有这样的属性。 obj2.base.__Class 返回了预期的值。 obj2 没有名为 ‘__Class’ 的属性,因此它检查它的基础对象,所以 obj2.__Class 返回 obj2.base.__Class 的值。 一般来说,对于对象,如果 obj.prop 不存在,会检查 obj.base.prop 和 obj.base.base.prop 等(你可以将其称为“追踪基础”)。 如果找到了这样的属性,则返回属性的值。如果没有找到属性,则返回空字符串。
- 注意:当定义一个类时,会创建一个与类名相同的类对象(变量),其中包含该对象。可以通过 ListVars 或 ‘View, Variables and their contents’ 查看。
- 因此,实例对象和类对象都是存储在变量中的对象。
- 注意:我们在“动物园类和基础对象”章节中学到,类对象没有基础对象,并且是 AHK 基本对象。
- 一些对比 AHK 基本对象、自定义类对象和自定义类对象实例的测试: (注意:在 AHK v1 中,HasKey 用于检查键(/值属性)的存在。)
- 注意:为什么尝试的修复方法没有起作用尚未完全解释清楚。
(四)键/属性/方法
1.类:值属性
以下是一些关于值属性和类的经典操作,将在下面进行介绍。
注意:在 AHK v1 中,键和值属性是相同的东西。
2.预先填充对象的值属性
在类体内定义值属性的示例,使用/不使用 ‘static’。
当使用 ‘static’ 时,属性将放置在基础对象中(类对象中)。
当省略 ‘static’ 时,属性的局部副本将放置在实例对象中。
尝试删除 ‘prop1’,只检查对象本身。
尝试检索 ‘prop1’ 的内容,首先检查对象本身,发现没有这样的属性,然后检查基础对象。
记录每次为特定类创建对象
这是一个保持实例计数并为每个对象分配问题编号的示例,它使用后面讨论的 __New 方法。
具有属性的对象(更改现有和未来实例的属性值)
在此示例中,更改所有实例的属性内容。
我们可以使用动态属性引用全局变量。更改全局变量的值将影响未来和现有实例。
其他操作
保持类实例列表
在这个示例中:
MyKeepTrackClass类有一个静态属性instances,它是一个数组,用于存储所有创建的MyKeepTrackClass实例的引用。- 在
__New()构造函数中,每次创建一个新实例时,会将该实例的引用&this添加到instances数组中,并且设置实例的属性prop初始值为"MyValue"。 UpdateAllProps(vValue)方法用于更新所有实例的prop属性为指定的值vValue。首先,它会更新当前实例的prop属性为vValue。然后,它会遍历instances数组中的所有实例引用,将每个实例的prop属性都设置为vValue。
通过调用 MyKeepTrackClass.UpdateAllProps("MyValueNEW") 方法后,所有实例的 prop 属性都被更新为 "MyValueNEW"。这个更新是通过静态属性 instances 中存储的实例引用来实现的。
当从一个类派生多个实例时,修改一个实例的基类会影响所有实例。
以下是一种方法,可以保留一个实例的特性,但允许对其基类进行任何编辑,而不影响其他实例。
当我们使用 MyPropClass.prop := "MyValueNEW" 时,会修改所有实例的 prop 值,因为这是一个静态属性。为了使 obj2 的 prop 值保持不受影响,我们首先使用 ObjGetBase(obj2) 获取 obj2 的基类,然后使用 ObjClone(base2) 创建一个基类的克隆,并将其设置为 obj2 的新基类,这样就使得 obj2 的 prop 值不再受到 MyPropClass.prop 的改变影响。
预先为对象填充键(更改未来实例但不影响现有实例)
要预先为对象填充键,并确保类的未来实例反映更新的键值,而不影响现有实例,您可以在AutoHotkey中使用静态属性和实例属性的组合。目标是使每个实例在实例化时捕获类的键值快照。
以下是实现此目的的方法:
在上面的示例中:
MyPropClass是一个类,具有静态属性prop,最初设置为"MyValue"。__New()方法是AutoHotkey类中的特殊方法,在创建类的新实例时自动调用。- 在
__New()方法中,this.prop := MyPropClass.prop将MyPropClass的静态属性prop的当前值分配给每个实例的prop属性。这样可以在实例创建时捕获静态属性的值快照。
当您将 MyPropClass.prop 更改为 "MyValueNEW",然后再更改为 "MyValueNEWER" 时,这些更改仅影响在每次更改后创建的未来实例,而不影响现有实例的捕获初始值。
类内部的 ‘static’ 使用与其他地方的区别
- 在类定义内部: 当
static在类体内部使用时(class MyPropClass { ... }),它定义了一个在类的所有实例之间共享的键值属性(在本例中为prop)。 - 访问静态值: 可以使用
myclass.prop(针对类本身)或myinstance.base.prop(针对类的实例)来访问类内部定义的静态值。 - 更改静态值: 可以在以后的某个时间修改静态值(例如
MyPropClass.prop := "MyValueNEW")以影响未来创建的实例。 - 与其他位置的静态值的对比: 这与在函数内部或动态属性的 getter/setter 中使用静态值的方式不同,在这些情况下,无法直接访问静态值。
在AutoHotkey中,方法、属性 getter(property.get)和属性 setter(property.set)都是函数,可以使用 A_ThisFunc 来访问它们的函数名。这种区别有助于理解静态值在类定义内部与语言的其他上下文中操作方式的不同。
类:属性
这里有一个简单的类,其中包含一个动态属性,其工作方式几乎与键/值属性相同。 有一个区别是,会创建一个存储属性值的键/值属性。
- 动态属性的功能类似于键,但在幕后的工作方式类似于方法。
- 它们允许具有动态生成值的属性,并允许只读属性。
- 一个只读属性应该定义当尝试设置其值时会发生什么,否则可能会创建一个同名的键/值属性,并且该键会优先于属性。将返回键的值,而不是动态属性的值。
- 注意:在编程中,对于仅用于内部使用的键/属性/方法,通常以下划线 ‘_’ 开头命名是很常见的。
- 注意:当在类中定义动态属性时,AutoHotkey会将它们定义为函数,函数名的形式为 ‘class.property.get’ 和 ‘class.property.set’(可以使用
A_ThisFunc查看)。
获取属性信息的示例代码:
以上是关于使用类属性的信息和示例代码。通过动态属性,您可以模拟类似于键/值属性的行为,并了解如何在类定义中定义和使用属性。
类:方法
这里是一个带有一些方法的简单类。
- 方法本质上是存储在类中的函数。
- 注意:在 AutoHotkey 中,方法是以 ‘class.method’ 形式命名的函数。
- 注意:
IsObject和Type函数演示了方法是类型为 ‘Func’ 的对象。
- 函数 vs 方法:
- 在函数中,您显式指定对象(作为第一个参数)。
- 在方法中,您不需要显式指定对象,它是一个隐式的第一个参数,可以通过
this访问。
以下是使用 this 的示例:
以下是将函数作为方法添加到对象的示例:
以下是动态方法调用的更多示例:
以上是关于方法的信息和示例代码。方法允许您在类中定义和使用函数,并了解如何使用隐式的 this 参数访问对象属性和方法。
类:键/属性/方法与优先级
- 在类定义中,不能同时存在同名的类键(/值属性)、实例键(/值属性)、动态属性或方法。如果取消注释任何 2 个(或更多),所有这 4 个项都会导致“重复声明”错误。
- 在类中不能同时存在同名的方法和动态属性。会出现“重复声明”错误。
- 如果键(/值属性)和方法共享相同的名称,则键(/值属性)优先级更高。
- 如果键(/值属性)和动态属性共享相同的名称,则键(/值属性)优先级更高。
以下示例演示了一些同名问题:
- 若要创建覆盖方法的键,请直接分配一个键,例如
obj["key"] := value,或使用ObjRawSet。 - 若要创建覆盖动态属性的键,分配键(/值属性)是行不通的,例如
obj["key"] := value,这只会为现有属性分配一个值,因此请使用ObjRawSet。
示例:替换方法和键
这里有一个示例,演示如何使用同名的键阻止方法工作,但如果添加的键是一个像方法一样运行的 func 对象,则即使添加了键,调用方法也会像以前一样正常工作。
以上是关于键、属性、方法和优先级的详细信息和示例代码。
(五)元函数(Meta-Functions)
1.元函数和其作用
在面向对象编程中,元函数是指在请求对象中未找到键(属性或方法)时会触发的特殊方法。以下是常见的元函数及其作用:
__Get(Name, Params)- 用于处理对未定义属性的获取操作。
- 可以自定义返回值或抛出
PropertyError。
__Set(Name, Params, Value)- 用于处理对未定义属性的赋值操作。
- 可以创建新属性并设置其值。
__Call(Name, Params)- 处理对未定义方法的调用操作。
- 可以自定义响应或抛出
MethodError。
2.元函数的调用方式
- 当访问对象的不存在的属性时,会调用
__Get。 - 当对对象的不存在方法进行调用时,会调用
__Call。 - 当给对象的不存在属性赋值时,会调用
__Set。
3.动态属性和元函数的应用
元函数与动态属性概念密切相关,通过元函数可以实现在运行时动态定义和处理属性。与静态属性定义不同,动态属性在每次访问时可以计算出一个值,而不需要事先定义每个属性。
例如,可以利用元函数实现代理对象,通过网络或其他通道发送属性请求,并在收到响应后返回相应的值。这种情况下,每个属性的具体操作相同,只是属性名称不同,因此元函数能够以属性名称作为参数处理这些动态属性请求。
4.元函数列表
以下是常见的元函数及其作用:
__Init(不应使用):处理对象实例创建时的行为。__New:处理对象实例创建时的行为。__Get/__Set:处理获取/设置不存在的键/属性时的行为。__Call:处理调用已存在/不存在的方法时的行为。__Delete:处理对象实例删除时的行为。
这些元函数是面向对象编程中重要的组成部分,通过自定义这些方法,可以更好地控制类的行为,实现更灵活和动态的对象操作。
下面是一个示例脚本,其中的消息框报告每次调用方法时的情况:
注意:像obj := ""这样的语句有时会删除对象,有时不会。 如果在obj := ""之前,obj指向的对象引用计数为1,则删除对象并调用 __Delete 方法。 如果在obj := ""之前,obj指向的对象引用计数大于1,则将对象的引用计数减少1。
此示例演示了定义类的两种方式:函数语法(老派)和方法语法(新派):
任何正常的函数,如果用作方法,应该有一个必需的参数,其他参数应该都是可选的。否则,调用可能会失败(在 AHK v1 中会静默失败)。
下面是一个示例,演示用作 __Delete 方法的任何自定义函数都应该有一个必需的参数和其他参数都是可选的:
以上是关于元函数的一些细微差别。在接下来的章节中,将讨论每个元函数的 return 的可能影响。
元函数+: __NEW / __DELETE
__New方法允许在对象创建时执行操作。__Delete方法允许在对象被删除时执行操作。
__Delete 方法可以作为一种技巧,允许您在对象被删除时执行特定操作。
- 注意:如果在
__Delete方法中使用return,对象仍然会被删除。 - 注意:如果在
__New方法中使用return,那么将覆盖对象的创建方式。甚至可以返回一个字符串而不是对象。
这是两个功能等效的类,它们在对象创建时创建属性。 一个在类的主体中指定了赋值,另一个在 __New 方法内部指定了赋值。
这是一个创建对象的示例,演示了如何指定参数,并演示了如何使用动态名称创建类。
元函数+: __INIT
__Init是一个未记录的方法,在脚本启动时调用。- 下面是一些关于
__Init的实验,展示了它的一些特性。 __Init向实例对象添加键(/值属性):
__Init 不会向类对象添加键(/值属性):
__Init 在 __New 之前被调用:
在类主体中定义变量会导致存在 __Init 方法:
关于 __Class 属性的测试:
下面的示例展示了 __Init 的作用。
在 __Init 中使用 ‘return’ 看起来没有效果。
元函数: __CALL
__Call是一个方法,当脚本尝试执行一个不存在的(或存在的)方法时调用。
使用 Call 的一个用途是通过将多个方法合并成一个方法,而不是有多个单独的方法。
使用 Call 的另一个用途是拥有区分大小写的方法名称。在AutoHotkey中,通常方法名是不区分大小写的。
- 这个示例演示了每次调用类似方法的东西时(即方法名和括号,以及可选的参数),都会调用
__Call方法。 - 即使方法(或属性)存在,也会调用
__Call方法。 - 如果存在与方法同名的键(/值属性),则不会调用
__Call方法。 - 使用
__Call方法的一个用途是监视每次调用方法或属性。
- 如果在
__Call方法中使用了 ‘return’,那么任何将要调用的方法/属性都不会被调用。 - 此外,’return’ 指定的值将被返回。
元函数: __GET
__Get是一个方法,当脚本尝试检索不存在的键的值时调用。- 这里我们将返回不存在键的默认值从空字符串改为数字0。
- 在
__Get方法中使用 ‘return’ 的效果是指定一个默认值,用于当未找到键时。 - 默认返回值为0可用于创建统计信息(频率计数)。
在这里,我们使用 Format 函数将数组的默认值更改为0。
这个示例演示了 __Get 方法仅在不存在的键上调用:
元函数: __SET
__Set是一个方法,当脚本尝试设置一个不存在的键的值时调用。- 在这个类中,我们只允许将正整数分配为键。
注意:如果在类内部尝试像这样分配一个键:
而不是这样:
将会导致 __Set 方法陷入无限循环。
ObjRawSet可以绕过__Set方法。
__GET/__SET: 监视每次获取/设置键的操作
- 这里是实现的方法,可以在键已存在时调用
__Get/__Set方法。 - 以下是两种能够监视每次获取/设置操作的方法。
- 在这个示例中,我们使用了一个全局对象。
- 所有的获取/设置操作都是对外部对象进行的,由于实例对象中不创建键,因此
__Get/__Set元函数会不断被调用。
- 在这个示例中,我们使用一个类对象来为所有实例对象存储数据。
- 这可能是一个更好的方法,因为通常在编程中,使用全局变量是不可取的。
__GET/__SET: 同时获取和设置
- ‘当获取变为设置时,那么它就不再是获取了。’
- 我们考虑当执行
var := obj["key"] := value时返回的内容。 - 我们进行了设置:
obj["key"] := value - 和获取:
var := obj["key"]
通用类示例: 日期和路径拆分
(六)枚举器和杂项
枚举器: _NewEnum 和 Next
- 与遍历对象中的每个项目相关的两个重要方法是 _NewEnum 和 Next。
- 当对对象应用 for 循环时,会调用对象的 _NewEnum 方法。该方法创建一个枚举器对象,然后将其传递给 for 循环。
- 枚举器对象只需要一个方法,即 Next 方法。
- Next 方法通过指定两个 ByRef 变量(key 和 value)确定在 for 循环期间输出哪些键/值对以及以什么顺序输出。
- 它可以输出除 2 个外的其他 ByRef 变量。
- 此外,Next 方法确定 for 循环何时结束。它通过将该方法的返回值指定为 0(结束循环)或非零整数(继续循环)来实现此目的。
- 注意:通常,枚举器对象类将具有两个方法:__New 方法用于准备信息,Next 方法用于输出信息。
示例: 重建 AHK 基本对象的功能
- 使用 Enum 方法直接可以实现同时执行 2 个 ‘for 循环’。
- 可以同时遍历 2 个对象。
自定义枚举器可用于创建无限 for 循环。
使用 Next 函数允许循环生成超过 2 个输出值。
- 以下是更多枚举器示例的链接。
- 注意:链接中所需的类/方法用于枚举器对象可以出现在不同位置:例如作为单独的类、嵌套类或与其他方法并列在类中。
每当使用 ClassName() 的默认实现创建对象时, 都会调用新对象的 __New 方法, 以便允许自定义初始化. 传递给 ClassName() 的任何参数都会被转发到 __New, 因此可能会影响对象的初始内容或如何构造它. 销毁对象时, 则调用 __Delete. 例如:
__Delete 不可被任何具有属性名 “__Class” 的对象所调用. 原型对象默认包含该属性.
如果在 __Delete 执行时抛出了异常或运行时错误, 并且未在 __Delete 中处理, 则它就像从一个新线程调用 __Delete. 也就是说, 显示一个错误对话框并 __Delete 返回, 但是线程不会退出(除非它已经退出).
如果脚本被任何方式直接终止, 包括托盘菜单或 ExitApp, 任何尚未返回的函数都没有机会返回. 因此, 这些函数的局部变量所引用的任何对象都不会被释放, 所以 __Delete 也不会被调用.
当脚本退出时, 全局变量和静态变量所包含的对象会按照任意的, 实现定义的顺序自动释放. 当 __Delete 在这个过程中被调用时, 一些全局变量或静态变量可能已经被释放, 但对象本身包含的任何引用仍然有效. 因此 __Delete 最好是完全自包含的, 而不依赖于任何全局变量或静态变量.
下面展示了类定义的大部分元素:
加载脚本时, 它构造一个类对象并将其存储在全局常量(只读变量) ClassName 中. 如果存在 extends BaseClassName, 那么 BaseClassName 必须为另一个类的全名. 每个类的全名存储在 ClassName.Prototype.__Class.
因为类本身是通过一个变量来访问的, 类名不能在同一个上下文中同时用于引用类和创建一个单独的变量(比如保存类的一个实例). 例如, box := Box() 将无法工作, 因为 box 和 Box 都解析为同一事物. 试图以这种方式重新分配一个顶层(非嵌套) 类会导致加载时错误.
在本文档中, 单词 “class” 本身通常表示用 class 关键字构造的类对象.
类定义可以包含变量声明, 方法定义和嵌套的类定义.
3.嵌套类
4.方法
方法定义看起来和函数定义相同. 每个方法定义都会创建一个 Func, 带有名为 this 的隐藏的第一个参数, 同时还定义了一个属性, 用于调用该方法或检索其函数对象.
有两种类型的方法:
- 实例方法定义如下, 并附加到类的原型, 这使得它们可以通过类的任何实例进行访问. 当方法被调用时,
this引用类的一个实例. - 静态方法是在方法名之前加上独立的关键字
static来定义的. 它们被附加到类对象本身, 但也被子类继承, 所以this要么引用类本身, 要么引用子类.
下面的方法定义创建了一个与 target.DefineProp('Method', {call: funcObj}) 相同类型的属性. 默认情况下, target.Method 返回 funcObj, 而试图赋值到 target.Method 会抛出错误. 这些默认值可以通过定义属性或调用 DefineProp 来覆盖.
胖箭头语法可以用来定义一个单行方法, 返回一个表达式:
Super
在方法或属性的 getter/setter 中, 关键字 super 可以代替 this 来访问在派生类中被重写的方法或属性的超类版本. 例如, 上面定义的类中的 super.Method() 通常会调用 BaseClassName 中定义的 Method 的版本. 注意:
super.Method()总是调用与当前方法的原始定义相关联的类或原型对象的基, 即使this是从该类的 subclass 或其他一些完全的类派生出来的.super.Method()隐式地将this作为第一个(隐藏的) 参数.- 由于不知道 ClassName 在基对象链中的位置(或是否存), ClassName 本身被用作起点. 因此,
super.Method()主要等同于(ClassName.Prototype.base.Method)(this)(但当 Method 是静态时, 没有 Prototype). 然而,ClassName.Prototype在加载时被解析. - 如果该属性没有在超类中定义, 或者不能被调用, 则抛出错误.
关键字 super 后面必须有下列符号之一: .[(.
super() 等同于 super.call().
6.属性
属性定义创建一个动态属性, 它会调用一个方法, 而不是简单地存储或返回一个值.
Property 是用户定义的名称, 用于标识属性. 如, obj.Property 将调用 get, 而 obj.Property := value 将调用 set. 在 get 或 set 内, this 指向被引用的对象. set, value 中包含正要赋予的值.
参数可以通过将它们括在属性名称右侧的方括号中来定义, 并以相同的方式传递(但在无参数时应省略). 除了使用方括号这点不同, 属性参数的定义方法与方法参数相同 – 支持可选参数, ByRef 和可变参数.
如果调用了一个带参数的属性, 但没有定义任何参数, 参数将自动转发给 get 返回的对象的 __Item 属性. 例如, this.Property[x] 与 (this.Property)[x] 或 y := this.Property, y[x] 具有相同的效果. 空方括号(this.Property[]) 总是会导致调用 __Item 属性的 属性值, 但是像 this.Property[args*] 这样的可变数量调用只有在参数数为非零的情况下才会有这种效果.
静态属性可以在属性名之前加上独立的关键字 static 来定义. 在这种情况下, this 指的是类本身或子类.
set 的返回值会被忽略. 例如, val := obj.Property := 42 总是赋值 val := 42 不管该属性做什么, 除非它抛出异常或退出线程.
每个类可定义部分或完整的属性. 如果一个类覆盖了属性, 可用 super.Property 访问其基类中定义的属性. 如果没有定义 Get 或 Set, 则可以从基对象继承它. 如果没有定义 Get, 则属性可以返回从基继承的值. 如果在该类和所有基对象中没有定义 Set(或被继承的值属性所掩盖), 尝试设置该属性会导致抛出异常.
同时具有 get 和 set 的属性定义实际上创建了两个独立的函数, 它们不共享局部或静态变量或嵌套函数. 与方法一样, 每个函数都有一个名为 this 的隐藏参数, 而 set 有名为 value 的第二个隐藏参数. 任何显式定义的参数都在这些参数之后.
属性定义以与 DefineProp 相同的方式定义属性的 get 和 set 访问函数, 而方法定义则定义 call 访问函数. 任何类都可以包含同名的属性定义和方法定义. 如果调用一个没有 call 访问函数的属性(方法), 则以没有参数的方式调用 get, 然后将结果作为方法调用.
7.胖箭头属性
胖箭头语法可以用来定义 getter 或 setter 属性, 它返回一个表达式:
当只定义 getter 时, 大括号和 get 可以省略:
在这两种情况下, 除非定义了参数, 否则必须省略方括号.
(二)__Enum 方法
当对象被传递给 for-loop 时, 将调用 __Enum 方法. 此方法应返回一个枚举器, 该枚举器将返回对象包含的项, 如数组元素. 如果未定义, 则不能将对象直接传递给 for-loop, 除非它具有枚举器-兼容的 Call(调用) 方法.
NumberOfVars 包含传递给 for-loop 的变量数量. 如果 NumberOfVars 为 2, 则期望枚举器将项的键或索引分配给第一个参数, 将值分配给第二个参数. 每个键或索引都应该作为 __Item 属性的参数而被接受. 这使基于 DBGp 的调试器能够通过调用枚举器列出它们之后可以获取或设置特定项.
使用三元运算符进行压缩:
只关注类和__enum,可以更浓缩
(三)__Item 属性
当索引操作符(数组语法) 与对象一起使用时, 将调用 _item 属性. 在下面的示例中, 属性被声明为静态的, 以便可以在 Env 类本身上使用索引运算符. 有关另一个例子, 请参阅 Array2D.
__Item 实际上是一个默认属性名(如果已经定义了这样一个属性):
- 当有参数时
object[params]等同于object.__Item[params]. object[]等同于object.__Item.
例如:
注意: 当显式属性名与空括号组合时, 如 obj.prop[], 它是作为两个独立的操作来处理的: 首先检索 obj.prop, 然后调用结果的默认属性. 这是语言语法的一部分, 所以不依赖于对象.
(四)初始化
当对类的引用第一次计算时, 每个类都会被自动初始化. 例如, 如果 MyClass 还没有初始化, MyClass.MyProp 会导致类在属性被检索之前被初始化. 初始化包括调用两个静态方法: __Init 和 __New.
static __Init 是为每个类自动定义的, 并且如果指定了基类, 则始终以对基类的引用开始, 以确保它被初始化. 静态/类变量和嵌套类按照它们被定义的顺序进行初始化, 除非在前一个变量或类初始化期间引用了嵌套类.
如果类定义或继承了一个 static __New 方法, 则在 __Init 之后立即被调用. 需要注意的是, __New 可以为定义它的类调用一次, 而 为每个没有定义它的子类调用一次(或调用 super.__New()). 这可以用来为每个子类执行共同的初始化任务, 或者在使用子类之前以某种方式修改它们.
如果 static __New 不打算作用于派生类, 这可以通过检查 this 的值来避免. 在某些情况下, 使用方法删除本身就足够了, 比如用 this.DeleteProp('__New'); 然而, 如果一个子类嵌套在基类中, 或者在静态/类变量的初始化过程中被引用, 那么 __New 的第一次执行可能是针对一个子类.
一个类的定义也有引用类的效果. 换句话说, 当脚本启动期间执行达到类定义时, 除非脚本已经引用了该类, 否则会自动调用 __Init 和 __New. 但是, 如果执行被阻止到达类的定义, 例如通过 return 或无限循环, 那么只有当类被引用时才会被初始化.
一旦自动初始化开始, 它就不会再发生在同一个类上. 这通常不是一个问题, 除非多个类相互引用. 例如, 考虑下面的两个类. 当 A 先被初始化时, 计算 B.SharedArray (A1) 会导致 B 在检索和返回值之前被初始化, 但是 A.SharedValue (A3) 是未定义的并且不会导致 A 的初始化, 因为它已经在进行了. 换句话说, 如果 A 先被访问或初始化, 顺序是 A1 到 A3; 否则是 B1 到 B4:


你好,
我想调用微信的截图DLL,使用CMD可以完成,vbs也可以。但是在ahk里面调用不成功。
DllCall(“prcscrn.dll prcscrn”)不知道什么原因,请教一下
DllCall(“D:Program FilesWeChatPrScrn.dllPrScrn”)
你好,
我想调用微信的截图DLL,使用CMD可以完成,vbs也可以。但是在ahsk里面调用不成功。
DllCall(“prcscrn.dllprcscrn”)不知道什么原因,请教一下